Initial import.
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
495
Tools/Source/TianoTools/Common/CommonLib.c
Normal file
495
Tools/Source/TianoTools/Common/CommonLib.c
Normal file
@@ -0,0 +1,495 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
CommonLib.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Common Library Functions
|
||||
|
||||
--*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include "CommonLib.h"
|
||||
|
||||
VOID
|
||||
PeiZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Set Buffer to zero for Size bytes.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Memory to set.
|
||||
|
||||
Size - Number of bytes to set
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
INT8 *Ptr;
|
||||
|
||||
Ptr = Buffer;
|
||||
while (Size--) {
|
||||
*(Ptr++) = 0;
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Copy Length bytes from Source to Destination.
|
||||
|
||||
Arguments:
|
||||
|
||||
Destination - Target of copy
|
||||
|
||||
Source - Place to copy from
|
||||
|
||||
Length - Number of bytes to copy
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *Destination8;
|
||||
CHAR8 *Source8;
|
||||
|
||||
Destination8 = Destination;
|
||||
Source8 = Source;
|
||||
while (Length--) {
|
||||
*(Destination8++) = *(Source8++);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
ZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
{
|
||||
PeiZeroMem (Buffer, Size);
|
||||
}
|
||||
|
||||
VOID
|
||||
CopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
{
|
||||
PeiCopyMem (Destination, Source, Length);
|
||||
}
|
||||
|
||||
INTN
|
||||
CompareGuid (
|
||||
IN EFI_GUID *Guid1,
|
||||
IN EFI_GUID *Guid2
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Compares to GUIDs
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid1 - guid to compare
|
||||
Guid2 - guid to compare
|
||||
|
||||
Returns:
|
||||
= 0 if Guid1 == Guid2
|
||||
!= 0 if Guid1 != Guid2
|
||||
|
||||
--*/
|
||||
{
|
||||
INT32 *g1;
|
||||
INT32 *g2;
|
||||
INT32 r;
|
||||
|
||||
//
|
||||
// Compare 32 bits at a time
|
||||
//
|
||||
g1 = (INT32 *) Guid1;
|
||||
g2 = (INT32 *) Guid2;
|
||||
|
||||
r = g1[0] - g2[0];
|
||||
r |= g1[1] - g2[1];
|
||||
r |= g1[2] - g2[2];
|
||||
r |= g1[3] - g2[3];
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFileImage (
|
||||
IN CHAR8 *InputFileName,
|
||||
OUT CHAR8 **InputFileImage,
|
||||
OUT UINT32 *BytesRead
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function opens a file and reads it into a memory buffer. The function
|
||||
will allocate the memory buffer and returns the size of the buffer.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFileName The name of the file to read.
|
||||
InputFileImage A pointer to the memory buffer.
|
||||
BytesRead The size of the memory buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
||||
EFI_ABORTED An error occurred.
|
||||
EFI_OUT_OF_RESOURCES No resource to complete operations.
|
||||
|
||||
--*/
|
||||
{
|
||||
FILE *InputFile;
|
||||
UINT32 FileSize;
|
||||
|
||||
//
|
||||
// Verify input parameters.
|
||||
//
|
||||
if (InputFileName == NULL || strlen (InputFileName) == 0 || InputFileImage == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Open the file and copy contents into a memory buffer.
|
||||
//
|
||||
//
|
||||
// Open the file
|
||||
//
|
||||
InputFile = fopen (InputFileName, "rb");
|
||||
if (InputFile == NULL) {
|
||||
printf ("ERROR: Could not open input file \"%s\".\n", InputFileName);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Go to the end so that we can determine the file size
|
||||
//
|
||||
if (fseek (InputFile, 0, SEEK_END)) {
|
||||
printf ("ERROR: System error reading input file \"%s\".\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get the file size
|
||||
//
|
||||
FileSize = ftell (InputFile);
|
||||
if (FileSize == -1) {
|
||||
printf ("ERROR: System error parsing input file \"%s\".\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Allocate a buffer
|
||||
//
|
||||
*InputFileImage = malloc (FileSize);
|
||||
if (*InputFileImage == NULL) {
|
||||
fclose (InputFile);
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
//
|
||||
// Reset to the beginning of the file
|
||||
//
|
||||
if (fseek (InputFile, 0, SEEK_SET)) {
|
||||
printf ("ERROR: System error reading input file \"%s\".\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
free (*InputFileImage);
|
||||
*InputFileImage = NULL;
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Read all of the file contents.
|
||||
//
|
||||
*BytesRead = fread (*InputFileImage, sizeof (UINT8), FileSize, InputFile);
|
||||
if (*BytesRead != sizeof (UINT8) * FileSize) {
|
||||
printf ("ERROR: Reading file \"%s\"%i.\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
free (*InputFileImage);
|
||||
*InputFileImage = NULL;
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Close the file
|
||||
//
|
||||
fclose (InputFile);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT8
|
||||
CalculateChecksum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function calculates the value needed for a valid UINT8 checksum
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 8 bit checksum value needed.
|
||||
|
||||
--*/
|
||||
{
|
||||
return (UINT8) (0x100 - CalculateSum8 (Buffer, Size));
|
||||
}
|
||||
|
||||
UINT8
|
||||
CalculateSum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINT32 Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description::
|
||||
|
||||
This function calculates the UINT8 sum for the requested region.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 8 bit checksum value needed.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Index;
|
||||
UINT8 Sum;
|
||||
|
||||
Sum = 0;
|
||||
|
||||
//
|
||||
// Perform the byte sum for buffer
|
||||
//
|
||||
for (Index = 0; Index < Size; Index++) {
|
||||
Sum = (UINT8) (Sum + Buffer[Index]);
|
||||
}
|
||||
|
||||
return Sum;
|
||||
}
|
||||
|
||||
UINT16
|
||||
CalculateChecksum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description::
|
||||
|
||||
This function calculates the value needed for a valid UINT16 checksum
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 16 bit checksum value needed.
|
||||
|
||||
--*/
|
||||
{
|
||||
return (UINT16) (0x10000 - CalculateSum16 (Buffer, Size));
|
||||
}
|
||||
|
||||
UINT16
|
||||
CalculateSum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function calculates the UINT16 sum for the requested region.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 16 bit checksum
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Index;
|
||||
UINT16 Sum;
|
||||
|
||||
Sum = 0;
|
||||
|
||||
//
|
||||
// Perform the word sum for buffer
|
||||
//
|
||||
for (Index = 0; Index < Size; Index++) {
|
||||
Sum = (UINT16) (Sum + Buffer[Index]);
|
||||
}
|
||||
|
||||
return (UINT16) Sum;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PrintGuid (
|
||||
IN EFI_GUID *Guid
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function prints a GUID to STDOUT.
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid Pointer to a GUID to print.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The GUID was printed.
|
||||
EFI_INVALID_PARAMETER The input was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
if (Guid == NULL) {
|
||||
printf ("ERROR: PrintGuid called with a NULL value.\n");
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
printf (
|
||||
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PrintGuidToBuffer (
|
||||
IN EFI_GUID *Guid,
|
||||
IN OUT UINT8 *Buffer,
|
||||
IN UINT32 BufferLen,
|
||||
IN BOOLEAN Uppercase
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function prints a GUID to a buffer
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid - Pointer to a GUID to print.
|
||||
Buffer - Pointer to a user-provided buffer to print to
|
||||
BufferLen - Size of the Buffer
|
||||
Uppercase - If use upper case.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The GUID was printed.
|
||||
EFI_INVALID_PARAMETER The input was NULL.
|
||||
EFI_BUFFER_TOO_SMALL The input buffer was not big enough
|
||||
|
||||
--*/
|
||||
{
|
||||
if (Guid == NULL) {
|
||||
printf ("ERROR: PrintGuidToBuffer() called with a NULL value\n");
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (BufferLen < PRINTED_GUID_BUFFER_SIZE) {
|
||||
printf ("ERORR: PrintGuidToBuffer() called with invalid buffer size\n");
|
||||
return EFI_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
if (Uppercase) {
|
||||
sprintf (
|
||||
Buffer,
|
||||
"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
} else {
|
||||
sprintf (
|
||||
Buffer,
|
||||
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
131
Tools/Source/TianoTools/Common/CommonLib.h
Normal file
131
Tools/Source/TianoTools/Common/CommonLib.h
Normal file
@@ -0,0 +1,131 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
CommonLib.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Common library assistance routines.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_COMMON_LIB_H
|
||||
#define _EFI_COMMON_LIB_H
|
||||
|
||||
/*
|
||||
#include "TianoCommon.h"
|
||||
#include "TianoCommon.h"
|
||||
#include "PeiHob.h"
|
||||
*/
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _MAX_PATH
|
||||
#define _MAX_PATH 500
|
||||
#endif
|
||||
|
||||
#define PRINTED_GUID_BUFFER_SIZE 37 // including null-termination
|
||||
//
|
||||
// Function declarations
|
||||
//
|
||||
VOID
|
||||
PeiZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
;
|
||||
|
||||
VOID
|
||||
ZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
VOID
|
||||
CopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
;
|
||||
|
||||
INTN
|
||||
CompareGuid (
|
||||
IN EFI_GUID *Guid1,
|
||||
IN EFI_GUID *Guid2
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFileImage (
|
||||
IN CHAR8 *InputFileName,
|
||||
OUT CHAR8 **InputFileImage,
|
||||
OUT UINT32 *BytesRead
|
||||
)
|
||||
;
|
||||
|
||||
UINT8
|
||||
CalculateChecksum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
UINT8
|
||||
CalculateSum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
UINT16
|
||||
CalculateChecksum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
UINT16
|
||||
CalculateSum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PrintGuid (
|
||||
IN EFI_GUID *Guid
|
||||
)
|
||||
;
|
||||
|
||||
#define PRINTED_GUID_BUFFER_SIZE 37 // including null-termination
|
||||
EFI_STATUS
|
||||
PrintGuidToBuffer (
|
||||
IN EFI_GUID *Guid,
|
||||
IN OUT UINT8 *Buffer,
|
||||
IN UINT32 BufferLen,
|
||||
IN BOOLEAN Uppercase
|
||||
)
|
||||
;
|
||||
|
||||
|
||||
#endif
|
326
Tools/Source/TianoTools/Common/Crc32.c
Normal file
326
Tools/Source/TianoTools/Common/Crc32.c
Normal file
@@ -0,0 +1,326 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
crc32.c
|
||||
|
||||
Abstract:
|
||||
|
||||
CalcuateCrc32 routine.
|
||||
|
||||
--*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "Crc32.h"
|
||||
|
||||
UINT32 mCrcTable[256] = {
|
||||
0x00000000,
|
||||
0x77073096,
|
||||
0xEE0E612C,
|
||||
0x990951BA,
|
||||
0x076DC419,
|
||||
0x706AF48F,
|
||||
0xE963A535,
|
||||
0x9E6495A3,
|
||||
0x0EDB8832,
|
||||
0x79DCB8A4,
|
||||
0xE0D5E91E,
|
||||
0x97D2D988,
|
||||
0x09B64C2B,
|
||||
0x7EB17CBD,
|
||||
0xE7B82D07,
|
||||
0x90BF1D91,
|
||||
0x1DB71064,
|
||||
0x6AB020F2,
|
||||
0xF3B97148,
|
||||
0x84BE41DE,
|
||||
0x1ADAD47D,
|
||||
0x6DDDE4EB,
|
||||
0xF4D4B551,
|
||||
0x83D385C7,
|
||||
0x136C9856,
|
||||
0x646BA8C0,
|
||||
0xFD62F97A,
|
||||
0x8A65C9EC,
|
||||
0x14015C4F,
|
||||
0x63066CD9,
|
||||
0xFA0F3D63,
|
||||
0x8D080DF5,
|
||||
0x3B6E20C8,
|
||||
0x4C69105E,
|
||||
0xD56041E4,
|
||||
0xA2677172,
|
||||
0x3C03E4D1,
|
||||
0x4B04D447,
|
||||
0xD20D85FD,
|
||||
0xA50AB56B,
|
||||
0x35B5A8FA,
|
||||
0x42B2986C,
|
||||
0xDBBBC9D6,
|
||||
0xACBCF940,
|
||||
0x32D86CE3,
|
||||
0x45DF5C75,
|
||||
0xDCD60DCF,
|
||||
0xABD13D59,
|
||||
0x26D930AC,
|
||||
0x51DE003A,
|
||||
0xC8D75180,
|
||||
0xBFD06116,
|
||||
0x21B4F4B5,
|
||||
0x56B3C423,
|
||||
0xCFBA9599,
|
||||
0xB8BDA50F,
|
||||
0x2802B89E,
|
||||
0x5F058808,
|
||||
0xC60CD9B2,
|
||||
0xB10BE924,
|
||||
0x2F6F7C87,
|
||||
0x58684C11,
|
||||
0xC1611DAB,
|
||||
0xB6662D3D,
|
||||
0x76DC4190,
|
||||
0x01DB7106,
|
||||
0x98D220BC,
|
||||
0xEFD5102A,
|
||||
0x71B18589,
|
||||
0x06B6B51F,
|
||||
0x9FBFE4A5,
|
||||
0xE8B8D433,
|
||||
0x7807C9A2,
|
||||
0x0F00F934,
|
||||
0x9609A88E,
|
||||
0xE10E9818,
|
||||
0x7F6A0DBB,
|
||||
0x086D3D2D,
|
||||
0x91646C97,
|
||||
0xE6635C01,
|
||||
0x6B6B51F4,
|
||||
0x1C6C6162,
|
||||
0x856530D8,
|
||||
0xF262004E,
|
||||
0x6C0695ED,
|
||||
0x1B01A57B,
|
||||
0x8208F4C1,
|
||||
0xF50FC457,
|
||||
0x65B0D9C6,
|
||||
0x12B7E950,
|
||||
0x8BBEB8EA,
|
||||
0xFCB9887C,
|
||||
0x62DD1DDF,
|
||||
0x15DA2D49,
|
||||
0x8CD37CF3,
|
||||
0xFBD44C65,
|
||||
0x4DB26158,
|
||||
0x3AB551CE,
|
||||
0xA3BC0074,
|
||||
0xD4BB30E2,
|
||||
0x4ADFA541,
|
||||
0x3DD895D7,
|
||||
0xA4D1C46D,
|
||||
0xD3D6F4FB,
|
||||
0x4369E96A,
|
||||
0x346ED9FC,
|
||||
0xAD678846,
|
||||
0xDA60B8D0,
|
||||
0x44042D73,
|
||||
0x33031DE5,
|
||||
0xAA0A4C5F,
|
||||
0xDD0D7CC9,
|
||||
0x5005713C,
|
||||
0x270241AA,
|
||||
0xBE0B1010,
|
||||
0xC90C2086,
|
||||
0x5768B525,
|
||||
0x206F85B3,
|
||||
0xB966D409,
|
||||
0xCE61E49F,
|
||||
0x5EDEF90E,
|
||||
0x29D9C998,
|
||||
0xB0D09822,
|
||||
0xC7D7A8B4,
|
||||
0x59B33D17,
|
||||
0x2EB40D81,
|
||||
0xB7BD5C3B,
|
||||
0xC0BA6CAD,
|
||||
0xEDB88320,
|
||||
0x9ABFB3B6,
|
||||
0x03B6E20C,
|
||||
0x74B1D29A,
|
||||
0xEAD54739,
|
||||
0x9DD277AF,
|
||||
0x04DB2615,
|
||||
0x73DC1683,
|
||||
0xE3630B12,
|
||||
0x94643B84,
|
||||
0x0D6D6A3E,
|
||||
0x7A6A5AA8,
|
||||
0xE40ECF0B,
|
||||
0x9309FF9D,
|
||||
0x0A00AE27,
|
||||
0x7D079EB1,
|
||||
0xF00F9344,
|
||||
0x8708A3D2,
|
||||
0x1E01F268,
|
||||
0x6906C2FE,
|
||||
0xF762575D,
|
||||
0x806567CB,
|
||||
0x196C3671,
|
||||
0x6E6B06E7,
|
||||
0xFED41B76,
|
||||
0x89D32BE0,
|
||||
0x10DA7A5A,
|
||||
0x67DD4ACC,
|
||||
0xF9B9DF6F,
|
||||
0x8EBEEFF9,
|
||||
0x17B7BE43,
|
||||
0x60B08ED5,
|
||||
0xD6D6A3E8,
|
||||
0xA1D1937E,
|
||||
0x38D8C2C4,
|
||||
0x4FDFF252,
|
||||
0xD1BB67F1,
|
||||
0xA6BC5767,
|
||||
0x3FB506DD,
|
||||
0x48B2364B,
|
||||
0xD80D2BDA,
|
||||
0xAF0A1B4C,
|
||||
0x36034AF6,
|
||||
0x41047A60,
|
||||
0xDF60EFC3,
|
||||
0xA867DF55,
|
||||
0x316E8EEF,
|
||||
0x4669BE79,
|
||||
0xCB61B38C,
|
||||
0xBC66831A,
|
||||
0x256FD2A0,
|
||||
0x5268E236,
|
||||
0xCC0C7795,
|
||||
0xBB0B4703,
|
||||
0x220216B9,
|
||||
0x5505262F,
|
||||
0xC5BA3BBE,
|
||||
0xB2BD0B28,
|
||||
0x2BB45A92,
|
||||
0x5CB36A04,
|
||||
0xC2D7FFA7,
|
||||
0xB5D0CF31,
|
||||
0x2CD99E8B,
|
||||
0x5BDEAE1D,
|
||||
0x9B64C2B0,
|
||||
0xEC63F226,
|
||||
0x756AA39C,
|
||||
0x026D930A,
|
||||
0x9C0906A9,
|
||||
0xEB0E363F,
|
||||
0x72076785,
|
||||
0x05005713,
|
||||
0x95BF4A82,
|
||||
0xE2B87A14,
|
||||
0x7BB12BAE,
|
||||
0x0CB61B38,
|
||||
0x92D28E9B,
|
||||
0xE5D5BE0D,
|
||||
0x7CDCEFB7,
|
||||
0x0BDBDF21,
|
||||
0x86D3D2D4,
|
||||
0xF1D4E242,
|
||||
0x68DDB3F8,
|
||||
0x1FDA836E,
|
||||
0x81BE16CD,
|
||||
0xF6B9265B,
|
||||
0x6FB077E1,
|
||||
0x18B74777,
|
||||
0x88085AE6,
|
||||
0xFF0F6A70,
|
||||
0x66063BCA,
|
||||
0x11010B5C,
|
||||
0x8F659EFF,
|
||||
0xF862AE69,
|
||||
0x616BFFD3,
|
||||
0x166CCF45,
|
||||
0xA00AE278,
|
||||
0xD70DD2EE,
|
||||
0x4E048354,
|
||||
0x3903B3C2,
|
||||
0xA7672661,
|
||||
0xD06016F7,
|
||||
0x4969474D,
|
||||
0x3E6E77DB,
|
||||
0xAED16A4A,
|
||||
0xD9D65ADC,
|
||||
0x40DF0B66,
|
||||
0x37D83BF0,
|
||||
0xA9BCAE53,
|
||||
0xDEBB9EC5,
|
||||
0x47B2CF7F,
|
||||
0x30B5FFE9,
|
||||
0xBDBDF21C,
|
||||
0xCABAC28A,
|
||||
0x53B39330,
|
||||
0x24B4A3A6,
|
||||
0xBAD03605,
|
||||
0xCDD70693,
|
||||
0x54DE5729,
|
||||
0x23D967BF,
|
||||
0xB3667A2E,
|
||||
0xC4614AB8,
|
||||
0x5D681B02,
|
||||
0x2A6F2B94,
|
||||
0xB40BBE37,
|
||||
0xC30C8EA1,
|
||||
0x5A05DF1B,
|
||||
0x2D02EF8D
|
||||
};
|
||||
|
||||
EFI_STATUS
|
||||
CalculateCrc32 (
|
||||
IN UINT8 *Data,
|
||||
IN UINTN DataSize,
|
||||
IN OUT UINT32 *CrcOut
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The CalculateCrc32 routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
Data - The buffer contaning the data to be processed
|
||||
DataSize - The size of data to be processed
|
||||
CrcOut - A pointer to the caller allocated UINT32 that on
|
||||
contains the CRC32 checksum of Data
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Calculation is successful.
|
||||
EFI_INVALID_PARAMETER - Data / CrcOut = NULL, or DataSize = 0
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 Crc;
|
||||
UINTN Index;
|
||||
UINT8 *Ptr;
|
||||
|
||||
if ((DataSize == 0) || (Data == NULL) || (CrcOut == NULL)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Crc = 0xffffffff;
|
||||
for (Index = 0, Ptr = Data; Index < DataSize; Index++, Ptr++) {
|
||||
Crc = (Crc >> 8) ^ mCrcTable[(UINT8) Crc ^ *Ptr];
|
||||
}
|
||||
|
||||
*CrcOut = Crc ^ 0xffffffff;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
57
Tools/Source/TianoTools/Common/Crc32.h
Normal file
57
Tools/Source/TianoTools/Common/Crc32.h
Normal file
@@ -0,0 +1,57 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Crc32.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for CalcuateCrc32 routine
|
||||
|
||||
--*/
|
||||
|
||||
/*
|
||||
#include "TianoCommon.h"
|
||||
*/
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _CRC32_H
|
||||
#define _CRC32_H
|
||||
EFI_STATUS
|
||||
CalculateCrc32 (
|
||||
IN UINT8 *Data,
|
||||
IN UINTN DataSize,
|
||||
IN OUT UINT32 *CrcOut
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The CalculateCrc32 routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
Data - The buffer contaning the data to be processed
|
||||
DataSize - The size of data to be processed
|
||||
CrcOut - A pointer to the caller allocated UINT32 that on
|
||||
contains the CRC32 checksum of Data
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Calculation is successful.
|
||||
EFI_INVALID_PARAMETER - Data / CrcOut = NULL, or DataSize = 0
|
||||
|
||||
--*/
|
||||
#endif
|
1745
Tools/Source/TianoTools/Common/EfiCompress.c
Normal file
1745
Tools/Source/TianoTools/Common/EfiCompress.c
Normal file
File diff suppressed because it is too large
Load Diff
68
Tools/Source/TianoTools/Common/EfiCompress.h
Normal file
68
Tools/Source/TianoTools/Common/EfiCompress.h
Normal file
@@ -0,0 +1,68 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiCompress.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for compression routine
|
||||
|
||||
--*/
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _EFICOMPRESS_H
|
||||
#define _EFICOMPRESS_H
|
||||
EFI_STATUS
|
||||
Compress (
|
||||
IN UINT8 *SrcBuffer,
|
||||
IN UINT32 SrcSize,
|
||||
IN UINT8 *DstBuffer,
|
||||
IN OUT UINT32 *DstSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The compression routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
SrcBuffer - The buffer storing the source data
|
||||
SrcSize - The size of source data
|
||||
DstBuffer - The buffer to store the compressed data
|
||||
DstSize - On input, the size of DstBuffer; On output,
|
||||
the size of the actual compressed data.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. In this case,
|
||||
DstSize contains the size needed.
|
||||
EFI_SUCCESS - Compression is successful.
|
||||
|
||||
--*/
|
||||
typedef
|
||||
EFI_STATUS
|
||||
(*COMPRESS_FUNCTION) (
|
||||
IN UINT8 *SrcBuffer,
|
||||
IN UINT32 SrcSize,
|
||||
IN UINT8 *DstBuffer,
|
||||
IN OUT UINT32 *DstSize
|
||||
);
|
||||
|
||||
#endif
|
141
Tools/Source/TianoTools/Common/EfiCustomizedCompress.h
Normal file
141
Tools/Source/TianoTools/Common/EfiCustomizedCompress.h
Normal file
@@ -0,0 +1,141 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiCustomizedCompress.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for Customized compression routine
|
||||
|
||||
--*/
|
||||
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _EFICUSTOMIZEDCOMPRESS_H
|
||||
#define _EFICUSTOMIZEDCOMPRESS_H
|
||||
EFI_STATUS
|
||||
SetCustomizedCompressionType (
|
||||
IN CHAR8 *Type
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of Customized SetCompressionType().
|
||||
|
||||
Arguments:
|
||||
Type - The type if compression.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The type has been set.
|
||||
EFI_UNSUPPORTED - This type is unsupported.
|
||||
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
CustomizedGetInfo (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of Customized GetInfo().
|
||||
|
||||
Arguments:
|
||||
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
DstSize - The size of destination buffer.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
CustomizedDecompress (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of Customized Decompress().
|
||||
|
||||
Arguments:
|
||||
|
||||
This - The protocol instance pointer
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
Destination - The destination buffer to store the decompressed data
|
||||
DstSize - The size of destination buffer.
|
||||
Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Decompression is successfull
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
CustomizedCompress (
|
||||
IN UINT8 *SrcBuffer,
|
||||
IN UINT32 SrcSize,
|
||||
IN UINT8 *DstBuffer,
|
||||
IN OUT UINT32 *DstSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The Customized compression routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
SrcBuffer - The buffer storing the source data
|
||||
SrcSize - The size of source data
|
||||
DstBuffer - The buffer to store the compressed data
|
||||
DstSize - On input, the size of DstBuffer; On output,
|
||||
the size of the actual compressed data.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. In this case,
|
||||
DstSize contains the size needed.
|
||||
EFI_SUCCESS - Compression is successful.
|
||||
|
||||
--*/
|
||||
|
||||
#endif
|
790
Tools/Source/TianoTools/Common/EfiDecompress.c
Normal file
790
Tools/Source/TianoTools/Common/EfiDecompress.c
Normal file
@@ -0,0 +1,790 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiDecompress.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Decompressor. Algorithm Ported from OPSD code (Decomp.asm)
|
||||
|
||||
--*/
|
||||
|
||||
#include "EfiDecompress.h"
|
||||
|
||||
//
|
||||
// Decompression algorithm begins here
|
||||
//
|
||||
#define BITBUFSIZ 32
|
||||
#define MAXMATCH 256
|
||||
#define THRESHOLD 3
|
||||
#define CODE_BIT 16
|
||||
#define BAD_TABLE - 1
|
||||
|
||||
//
|
||||
// C: Char&Len Set; P: Position Set; T: exTra Set
|
||||
//
|
||||
#define NC (0xff + MAXMATCH + 2 - THRESHOLD)
|
||||
#define CBIT 9
|
||||
#define PBIT 5
|
||||
#define TBIT 5
|
||||
#define MAXNP ((1U << PBIT) - 1)
|
||||
#define NT (CODE_BIT + 3)
|
||||
#if NT > MAXNP
|
||||
#define NPT NT
|
||||
#else
|
||||
#define NPT MAXNP
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
UINT8 *mSrcBase; // Starting address of compressed data
|
||||
UINT8 *mDstBase; // Starting address of decompressed data
|
||||
UINT32 mOutBuf;
|
||||
UINT32 mInBuf;
|
||||
|
||||
UINT16 mBitCount;
|
||||
UINT32 mBitBuf;
|
||||
UINT32 mSubBitBuf;
|
||||
UINT16 mBlockSize;
|
||||
UINT32 mCompSize;
|
||||
UINT32 mOrigSize;
|
||||
|
||||
UINT16 mBadTableFlag;
|
||||
|
||||
UINT16 mLeft[2 * NC - 1];
|
||||
UINT16 mRight[2 * NC - 1];
|
||||
UINT8 mCLen[NC];
|
||||
UINT8 mPTLen[NPT];
|
||||
UINT16 mCTable[4096];
|
||||
UINT16 mPTTable[256];
|
||||
} SCRATCH_DATA;
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
FillBuf (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 NumOfBits
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
NumOfBit - The number of bits to shift and read.
|
||||
|
||||
Returns: (VOID)
|
||||
|
||||
--*/
|
||||
{
|
||||
Sd->mBitBuf = (UINT32) (Sd->mBitBuf << NumOfBits);
|
||||
|
||||
while (NumOfBits > Sd->mBitCount) {
|
||||
|
||||
Sd->mBitBuf |= (UINT32) (Sd->mSubBitBuf << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount)));
|
||||
|
||||
if (Sd->mCompSize > 0) {
|
||||
//
|
||||
// Get 1 byte into SubBitBuf
|
||||
//
|
||||
Sd->mCompSize--;
|
||||
Sd->mSubBitBuf = 0;
|
||||
Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++];
|
||||
Sd->mBitCount = 8;
|
||||
|
||||
} else {
|
||||
//
|
||||
// No more bits from the source, just pad zero bit.
|
||||
//
|
||||
Sd->mSubBitBuf = 0;
|
||||
Sd->mBitCount = 8;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits);
|
||||
Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT32
|
||||
GetBits (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 NumOfBits
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent
|
||||
NumOfBits of bits from source. Returns NumOfBits of bits that are
|
||||
popped out.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data.
|
||||
NumOfBits - The number of bits to pop and read.
|
||||
|
||||
Returns:
|
||||
|
||||
The bits that are popped out.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 OutBits;
|
||||
|
||||
OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits));
|
||||
|
||||
FillBuf (Sd, NumOfBits);
|
||||
|
||||
return OutBits;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT16
|
||||
MakeTable (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 NumOfChar,
|
||||
IN UINT8 *BitLen,
|
||||
IN UINT16 TableBits,
|
||||
OUT UINT16 *Table
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Creates Huffman Code mapping table according to code length array.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
NumOfChar - Number of symbols in the symbol set
|
||||
BitLen - Code length array
|
||||
TableBits - The width of the mapping table
|
||||
Table - The table
|
||||
|
||||
Returns:
|
||||
|
||||
0 - OK.
|
||||
BAD_TABLE - The table is corrupted.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Count[17];
|
||||
UINT16 Weight[17];
|
||||
UINT16 Start[18];
|
||||
UINT16 *Pointer;
|
||||
UINT16 Index3;
|
||||
UINT16 Index;
|
||||
UINT16 Len;
|
||||
UINT16 Char;
|
||||
UINT16 JuBits;
|
||||
UINT16 Avail;
|
||||
UINT16 NextCode;
|
||||
UINT16 Mask;
|
||||
|
||||
for (Index = 1; Index <= 16; Index++) {
|
||||
Count[Index] = 0;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < NumOfChar; Index++) {
|
||||
Count[BitLen[Index]]++;
|
||||
}
|
||||
|
||||
Start[1] = 0;
|
||||
|
||||
for (Index = 1; Index <= 16; Index++) {
|
||||
Start[Index + 1] = (UINT16) (Start[Index] + (Count[Index] << (16 - Index)));
|
||||
}
|
||||
|
||||
if (Start[17] != 0) {
|
||||
/*(1U << 16)*/
|
||||
return (UINT16) BAD_TABLE;
|
||||
}
|
||||
|
||||
JuBits = (UINT16) (16 - TableBits);
|
||||
|
||||
for (Index = 1; Index <= TableBits; Index++) {
|
||||
Start[Index] >>= JuBits;
|
||||
Weight[Index] = (UINT16) (1U << (TableBits - Index));
|
||||
}
|
||||
|
||||
while (Index <= 16) {
|
||||
Weight[Index++] = (UINT16) (1U << (16 - Index));
|
||||
}
|
||||
|
||||
Index = (UINT16) (Start[TableBits + 1] >> JuBits);
|
||||
|
||||
if (Index != 0) {
|
||||
Index3 = (UINT16) (1U << TableBits);
|
||||
while (Index != Index3) {
|
||||
Table[Index++] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
Avail = NumOfChar;
|
||||
Mask = (UINT16) (1U << (15 - TableBits));
|
||||
|
||||
for (Char = 0; Char < NumOfChar; Char++) {
|
||||
|
||||
Len = BitLen[Char];
|
||||
if (Len == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
NextCode = (UINT16) (Start[Len] + Weight[Len]);
|
||||
|
||||
if (Len <= TableBits) {
|
||||
|
||||
for (Index = Start[Len]; Index < NextCode; Index++) {
|
||||
Table[Index] = Char;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
Index3 = Start[Len];
|
||||
Pointer = &Table[Index3 >> JuBits];
|
||||
Index = (UINT16) (Len - TableBits);
|
||||
|
||||
while (Index != 0) {
|
||||
if (*Pointer == 0) {
|
||||
Sd->mRight[Avail] = Sd->mLeft[Avail] = 0;
|
||||
*Pointer = Avail++;
|
||||
}
|
||||
|
||||
if (Index3 & Mask) {
|
||||
Pointer = &Sd->mRight[*Pointer];
|
||||
} else {
|
||||
Pointer = &Sd->mLeft[*Pointer];
|
||||
}
|
||||
|
||||
Index3 <<= 1;
|
||||
Index--;
|
||||
}
|
||||
|
||||
*Pointer = Char;
|
||||
|
||||
}
|
||||
|
||||
Start[Len] = NextCode;
|
||||
}
|
||||
//
|
||||
// Succeeds
|
||||
//
|
||||
return 0;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT32
|
||||
DecodeP (
|
||||
IN SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Decodes a position value.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - the global scratch data
|
||||
|
||||
Returns:
|
||||
|
||||
The position value decoded.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Val;
|
||||
UINT32 Mask;
|
||||
UINT32 Pos;
|
||||
|
||||
Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
|
||||
|
||||
if (Val >= MAXNP) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 8);
|
||||
|
||||
do {
|
||||
|
||||
if (Sd->mBitBuf & Mask) {
|
||||
Val = Sd->mRight[Val];
|
||||
} else {
|
||||
Val = Sd->mLeft[Val];
|
||||
}
|
||||
|
||||
Mask >>= 1;
|
||||
} while (Val >= MAXNP);
|
||||
}
|
||||
//
|
||||
// Advance what we have read
|
||||
//
|
||||
FillBuf (Sd, Sd->mPTLen[Val]);
|
||||
|
||||
Pos = Val;
|
||||
if (Val > 1) {
|
||||
Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1)));
|
||||
}
|
||||
|
||||
return Pos;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT16
|
||||
ReadPTLen (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 nn,
|
||||
IN UINT16 nbit,
|
||||
IN UINT16 Special
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Reads code lengths for the Extra Set or the Position Set
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
nn - Number of symbols
|
||||
nbit - Number of bits needed to represent nn
|
||||
Special - The special symbol that needs to be taken care of
|
||||
|
||||
Returns:
|
||||
|
||||
0 - OK.
|
||||
BAD_TABLE - Table is corrupted.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Number;
|
||||
UINT16 CharC;
|
||||
UINT16 Index;
|
||||
UINT32 Mask;
|
||||
|
||||
Number = (UINT16) GetBits (Sd, nbit);
|
||||
|
||||
if (Number == 0) {
|
||||
CharC = (UINT16) GetBits (Sd, nbit);
|
||||
|
||||
for (Index = 0; Index < 256; Index++) {
|
||||
Sd->mPTTable[Index] = CharC;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < nn; Index++) {
|
||||
Sd->mPTLen[Index] = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Index = 0;
|
||||
|
||||
while (Index < Number) {
|
||||
|
||||
CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3));
|
||||
|
||||
if (CharC == 7) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 3);
|
||||
while (Mask & Sd->mBitBuf) {
|
||||
Mask >>= 1;
|
||||
CharC += 1;
|
||||
}
|
||||
}
|
||||
|
||||
FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3));
|
||||
|
||||
Sd->mPTLen[Index++] = (UINT8) CharC;
|
||||
|
||||
if (Index == Special) {
|
||||
CharC = (UINT16) GetBits (Sd, 2);
|
||||
CharC--;
|
||||
while ((INT16) (CharC) >= 0) {
|
||||
Sd->mPTLen[Index++] = 0;
|
||||
CharC--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while (Index < nn) {
|
||||
Sd->mPTLen[Index++] = 0;
|
||||
}
|
||||
|
||||
return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable);
|
||||
}
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
ReadCLen (
|
||||
SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Reads code lengths for Char&Len Set.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - the global scratch data
|
||||
|
||||
Returns: (VOID)
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Number;
|
||||
UINT16 CharC;
|
||||
UINT16 Index;
|
||||
UINT32 Mask;
|
||||
|
||||
Number = (UINT16) GetBits (Sd, CBIT);
|
||||
|
||||
if (Number == 0) {
|
||||
CharC = (UINT16) GetBits (Sd, CBIT);
|
||||
|
||||
for (Index = 0; Index < NC; Index++) {
|
||||
Sd->mCLen[Index] = 0;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < 4096; Index++) {
|
||||
Sd->mCTable[Index] = CharC;
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
Index = 0;
|
||||
while (Index < Number) {
|
||||
|
||||
CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
|
||||
if (CharC >= NT) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 8);
|
||||
|
||||
do {
|
||||
|
||||
if (Mask & Sd->mBitBuf) {
|
||||
CharC = Sd->mRight[CharC];
|
||||
} else {
|
||||
CharC = Sd->mLeft[CharC];
|
||||
}
|
||||
|
||||
Mask >>= 1;
|
||||
|
||||
} while (CharC >= NT);
|
||||
}
|
||||
//
|
||||
// Advance what we have read
|
||||
//
|
||||
FillBuf (Sd, Sd->mPTLen[CharC]);
|
||||
|
||||
if (CharC <= 2) {
|
||||
|
||||
if (CharC == 0) {
|
||||
CharC = 1;
|
||||
} else if (CharC == 1) {
|
||||
CharC = (UINT16) (GetBits (Sd, 4) + 3);
|
||||
} else if (CharC == 2) {
|
||||
CharC = (UINT16) (GetBits (Sd, CBIT) + 20);
|
||||
}
|
||||
|
||||
CharC--;
|
||||
while ((INT16) (CharC) >= 0) {
|
||||
Sd->mCLen[Index++] = 0;
|
||||
CharC--;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
Sd->mCLen[Index++] = (UINT8) (CharC - 2);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
while (Index < NC) {
|
||||
Sd->mCLen[Index++] = 0;
|
||||
}
|
||||
|
||||
MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable);
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT16
|
||||
DecodeC (
|
||||
SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Decode a character/length value.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data.
|
||||
|
||||
Returns:
|
||||
|
||||
The value decoded.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Index2;
|
||||
UINT32 Mask;
|
||||
|
||||
if (Sd->mBlockSize == 0) {
|
||||
//
|
||||
// Starting a new block
|
||||
//
|
||||
Sd->mBlockSize = (UINT16) GetBits (Sd, 16);
|
||||
Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3);
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
ReadCLen (Sd);
|
||||
|
||||
Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, PBIT, (UINT16) (-1));
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
Sd->mBlockSize--;
|
||||
Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)];
|
||||
|
||||
if (Index2 >= NC) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 12);
|
||||
|
||||
do {
|
||||
if (Sd->mBitBuf & Mask) {
|
||||
Index2 = Sd->mRight[Index2];
|
||||
} else {
|
||||
Index2 = Sd->mLeft[Index2];
|
||||
}
|
||||
|
||||
Mask >>= 1;
|
||||
} while (Index2 >= NC);
|
||||
}
|
||||
//
|
||||
// Advance what we have read
|
||||
//
|
||||
FillBuf (Sd, Sd->mCLen[Index2]);
|
||||
|
||||
return Index2;
|
||||
}
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
Decode (
|
||||
SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Decode the source data and put the resulting data into the destination buffer.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
|
||||
Returns: (VOID)
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 BytesRemain;
|
||||
UINT32 DataIdx;
|
||||
UINT16 CharC;
|
||||
|
||||
BytesRemain = (UINT16) (-1);
|
||||
|
||||
DataIdx = 0;
|
||||
|
||||
for (;;) {
|
||||
CharC = DecodeC (Sd);
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
return ;
|
||||
}
|
||||
|
||||
if (CharC < 256) {
|
||||
//
|
||||
// Process an Original character
|
||||
//
|
||||
Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC;
|
||||
if (Sd->mOutBuf >= Sd->mOrigSize) {
|
||||
return ;
|
||||
}
|
||||
|
||||
} else {
|
||||
//
|
||||
// Process a Pointer
|
||||
//
|
||||
CharC = (UINT16) (CharC - (UINT8_MAX + 1 - THRESHOLD));
|
||||
|
||||
BytesRemain = CharC;
|
||||
|
||||
DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1;
|
||||
|
||||
BytesRemain--;
|
||||
while ((INT16) (BytesRemain) >= 0) {
|
||||
Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++];
|
||||
if (Sd->mOutBuf >= Sd->mOrigSize) {
|
||||
return ;
|
||||
}
|
||||
|
||||
BytesRemain--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetInfo (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.GetInfo().
|
||||
|
||||
Arguments:
|
||||
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
DstSize - The size of destination buffer.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 *Src;
|
||||
|
||||
*ScratchSize = sizeof (SCRATCH_DATA);
|
||||
|
||||
Src = Source;
|
||||
if (SrcSize < 8) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
*DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
Decompress (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.Decompress().
|
||||
|
||||
Arguments:
|
||||
|
||||
This - The protocol instance pointer
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
Destination - The destination buffer to store the decompressed data
|
||||
DstSize - The size of destination buffer.
|
||||
Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Decompression is successfull
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 Index;
|
||||
UINT32 CompSize;
|
||||
UINT32 OrigSize;
|
||||
EFI_STATUS Status;
|
||||
SCRATCH_DATA *Sd;
|
||||
UINT8 *Src;
|
||||
UINT8 *Dst;
|
||||
|
||||
Status = EFI_SUCCESS;
|
||||
Src = Source;
|
||||
Dst = Destination;
|
||||
|
||||
if (ScratchSize < sizeof (SCRATCH_DATA)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Sd = (SCRATCH_DATA *) Scratch;
|
||||
|
||||
if (SrcSize < 8) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24);
|
||||
OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);
|
||||
|
||||
if (SrcSize < CompSize + 8) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (DstSize != OrigSize) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Src = Src + 8;
|
||||
|
||||
for (Index = 0; Index < sizeof (SCRATCH_DATA); Index++) {
|
||||
((UINT8 *) Sd)[Index] = 0;
|
||||
}
|
||||
|
||||
Sd->mSrcBase = Src;
|
||||
Sd->mDstBase = Dst;
|
||||
Sd->mCompSize = CompSize;
|
||||
Sd->mOrigSize = OrigSize;
|
||||
|
||||
//
|
||||
// Fill the first BITBUFSIZ bits
|
||||
//
|
||||
FillBuf (Sd, BITBUFSIZ);
|
||||
|
||||
//
|
||||
// Decompress it
|
||||
//
|
||||
Decode (Sd);
|
||||
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
//
|
||||
// Something wrong with the source
|
||||
//
|
||||
Status = EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
105
Tools/Source/TianoTools/Common/EfiDecompress.h
Normal file
105
Tools/Source/TianoTools/Common/EfiDecompress.h
Normal file
@@ -0,0 +1,105 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiDecompress.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for compression routine
|
||||
|
||||
--*/
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _EFI_DECOMPRESS_H
|
||||
#define _EFI_DECOMPRESS_H
|
||||
EFI_STATUS
|
||||
GetInfo (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
);
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.GetInfo().
|
||||
|
||||
Arguments:
|
||||
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
DstSize - The size of destination buffer.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
Decompress (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.Decompress().
|
||||
|
||||
Arguments:
|
||||
|
||||
This - The protocol instance pointer
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
Destination - The destination buffer to store the decompressed data
|
||||
DstSize - The size of destination buffer.
|
||||
Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Decompression is successfull
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
typedef
|
||||
EFI_STATUS
|
||||
(*GETINFO_FUNCTION) (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
);
|
||||
|
||||
typedef
|
||||
EFI_STATUS
|
||||
(*DECOMPRESS_FUNCTION) (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
);
|
||||
#endif
|
758
Tools/Source/TianoTools/Common/EfiUtilityMsgs.c
Normal file
758
Tools/Source/TianoTools/Common/EfiUtilityMsgs.c
Normal file
@@ -0,0 +1,758 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiUtilityMsgs.c
|
||||
|
||||
Abstract:
|
||||
|
||||
EFI tools utility functions to display warning, error, and informational
|
||||
messages.
|
||||
|
||||
--*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
/*
|
||||
#include "Tiano.h"
|
||||
*/
|
||||
#include "EfiUtilityMsgs.h"
|
||||
|
||||
#define MAX_LINE_LEN 200
|
||||
|
||||
//
|
||||
// Declare module globals for keeping track of the the utility's
|
||||
// name and other settings.
|
||||
//
|
||||
static STATUS mStatus = STATUS_SUCCESS;
|
||||
static CHAR8 mUtilityName[50] = { 0 };
|
||||
static UINT32 mDebugMsgMask = 0;
|
||||
static CHAR8 *mSourceFileName = NULL;
|
||||
static UINT32 mSourceFileLineNum = 0;
|
||||
static UINT32 mErrorCount = 0;
|
||||
static UINT32 mWarningCount = 0;
|
||||
static UINT32 mMaxErrors = 0;
|
||||
static UINT32 mMaxWarnings = 0;
|
||||
static UINT32 mMaxWarningsPlusErrors = 0;
|
||||
static INT8 mPrintLimitsSet = 0;
|
||||
|
||||
static
|
||||
void
|
||||
PrintMessage (
|
||||
CHAR8 *Type,
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
va_list List
|
||||
);
|
||||
|
||||
static
|
||||
void
|
||||
PrintLimitExceeded (
|
||||
VOID
|
||||
);
|
||||
|
||||
void
|
||||
Error (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Prints an error message.
|
||||
|
||||
Arguments:
|
||||
All arguments are optional, though the printed message may be useless if
|
||||
at least something valid is not specified.
|
||||
|
||||
FileName - name of the file or application. If not specified, then the
|
||||
utilty name (as set by the utility calling SetUtilityName()
|
||||
earlier) is used. Otherwise "Unknown utility" is used.
|
||||
|
||||
LineNumber - the line number of error, typically used by parsers. If the
|
||||
utility is not a parser, then 0 should be specified. Otherwise
|
||||
the FileName and LineNumber info can be used to cause
|
||||
MS Visual Studio to jump to the error.
|
||||
|
||||
MessageCode - an application-specific error code that can be referenced in
|
||||
other documentation.
|
||||
|
||||
Text - the text in question, typically used by parsers.
|
||||
|
||||
MsgFmt - the format string for the error message. Can contain formatting
|
||||
controls for use with the varargs.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
Notes:
|
||||
We print the following (similar to the Warn() and Debug()
|
||||
W
|
||||
Typical error/warning message format:
|
||||
|
||||
bin\VfrCompile.cpp(330) : error C2660: 'AddVfrDataStructField' : function does not take 2 parameters
|
||||
|
||||
BUGBUG -- these three utility functions are almost identical, and
|
||||
should be modified to share code.
|
||||
|
||||
Visual Studio does not find error messages with:
|
||||
|
||||
" error :"
|
||||
" error 1:"
|
||||
" error c1:"
|
||||
" error 1000:"
|
||||
" error c100:"
|
||||
|
||||
It does find:
|
||||
" error c1000:"
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check that we have not exceeded them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our error count
|
||||
//
|
||||
if (mMaxErrors != 0) {
|
||||
if (mErrorCount > mMaxErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mErrorCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("error", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_ERROR) {
|
||||
mStatus = STATUS_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ParserError (
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a parser error, using the source file name and line number
|
||||
set by a previous call to SetParserPosition().
|
||||
|
||||
Arguments:
|
||||
MessageCode - application-specific error code
|
||||
Text - text to print in the error message
|
||||
MsgFmt - format string to print at the end of the error message
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our error count
|
||||
//
|
||||
if (mMaxErrors != 0) {
|
||||
if (mErrorCount > mMaxErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mErrorCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("error", mSourceFileName, mSourceFileLineNum, MessageCode, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_ERROR) {
|
||||
mStatus = STATUS_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ParserWarning (
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a parser warning, using the source file name and line number
|
||||
set by a previous call to SetParserPosition().
|
||||
|
||||
Arguments:
|
||||
ErrorCode - application-specific error code
|
||||
OffendingText - text to print in the warning message
|
||||
MsgFmt - format string to print at the end of the warning message
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our warning count
|
||||
//
|
||||
if (mMaxWarnings != 0) {
|
||||
if (mWarningCount > mMaxWarnings) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mWarningCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("warning", mSourceFileName, mSourceFileLineNum, ErrorCode, OffendingText, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_WARNING) {
|
||||
mStatus = STATUS_WARNING;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
Warning (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a warning message.
|
||||
|
||||
Arguments:
|
||||
FileName - name of the file where the warning was detected, or the name
|
||||
of the application that detected the warning
|
||||
|
||||
LineNumber - the line number where the warning was detected (parsers).
|
||||
0 should be specified if the utility is not a parser.
|
||||
|
||||
MessageCode - an application-specific warning code that can be referenced in
|
||||
other documentation.
|
||||
|
||||
Text - the text in question (parsers)
|
||||
|
||||
MsgFmt - the format string for the warning message. Can contain formatting
|
||||
controls for use with varargs.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our warning count
|
||||
//
|
||||
if (mMaxWarnings != 0) {
|
||||
if (mWarningCount > mMaxWarnings) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mWarningCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("warning", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_WARNING) {
|
||||
mStatus = STATUS_WARNING;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
DebugMsg (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MsgMask,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a warning message.
|
||||
|
||||
Arguments:
|
||||
FileName - typically the name of the utility printing the debug message, but
|
||||
can be the name of a file being parsed.
|
||||
|
||||
LineNumber - the line number in FileName (parsers)
|
||||
|
||||
MsgMask - an application-specific bitmask that, in combination with mDebugMsgMask,
|
||||
determines if the debug message gets printed.
|
||||
|
||||
Text - the text in question (parsers)
|
||||
|
||||
MsgFmt - the format string for the debug message. Can contain formatting
|
||||
controls for use with varargs.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If the debug mask is not applicable, then do nothing.
|
||||
//
|
||||
if ((MsgMask != 0) && ((mDebugMsgMask & MsgMask) == 0)) {
|
||||
return ;
|
||||
}
|
||||
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("debug", FileName, LineNumber, 0, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
}
|
||||
|
||||
static
|
||||
void
|
||||
PrintMessage (
|
||||
CHAR8 *Type,
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
va_list List
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Worker routine for all the utility printing services. Prints the message in
|
||||
a format that Visual Studio will find when scanning build outputs for
|
||||
errors or warnings.
|
||||
|
||||
Arguments:
|
||||
Type - "warning" or "error" string to insert into the message to be
|
||||
printed. The first character of this string (converted to uppercase)
|
||||
is used to preceed the MessageCode value in the output string.
|
||||
|
||||
FileName - name of the file where the warning was detected, or the name
|
||||
of the application that detected the warning
|
||||
|
||||
LineNumber - the line number where the warning was detected (parsers).
|
||||
0 should be specified if the utility is not a parser.
|
||||
|
||||
MessageCode - an application-specific warning code that can be referenced in
|
||||
other documentation.
|
||||
|
||||
Text - part of the message to print
|
||||
|
||||
MsgFmt - the format string for the message. Can contain formatting
|
||||
controls for use with varargs.
|
||||
List - the variable list.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
Notes:
|
||||
If FileName == NULL then this utility will use the string passed into SetUtilityName().
|
||||
|
||||
LineNumber is only used if the caller is a parser, in which case FileName refers to the
|
||||
file being parsed.
|
||||
|
||||
Text and MsgFmt are both optional, though it would be of little use calling this function with
|
||||
them both NULL.
|
||||
|
||||
Output will typically be of the form:
|
||||
<FileName>(<LineNumber>) : <Type> <Type[0]><MessageCode>: <Text> : <MsgFmt>
|
||||
|
||||
Parser (LineNumber != 0)
|
||||
VfrCompile.cpp(330) : error E2660: AddVfrDataStructField : function does not take 2 parameters
|
||||
Generic utility (LineNumber == 0)
|
||||
UtilityName : error E1234 : Text string : MsgFmt string and args
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 Line[MAX_LINE_LEN];
|
||||
CHAR8 Line2[MAX_LINE_LEN];
|
||||
CHAR8 *Cptr;
|
||||
//
|
||||
// If given a filename, then add it (and the line number) to the string.
|
||||
// If there's no filename, then use the program name if provided.
|
||||
//
|
||||
if (FileName != NULL) {
|
||||
Cptr = FileName;
|
||||
} else if (mUtilityName[0] != 0) {
|
||||
Cptr = mUtilityName;
|
||||
} else {
|
||||
Cptr = "Unknown utility";
|
||||
}
|
||||
|
||||
strcpy (Line, Cptr);
|
||||
if (LineNumber != 0) {
|
||||
sprintf (Line2, "(%d)", LineNumber);
|
||||
strcat (Line, Line2);
|
||||
}
|
||||
//
|
||||
// Have to print an error code or Visual Studio won't find the
|
||||
// message for you. It has to be decimal digits too.
|
||||
//
|
||||
sprintf (Line2, " : %s %c%04d", Type, toupper (Type[0]), MessageCode);
|
||||
strcat (Line, Line2);
|
||||
fprintf (stdout, "%s", Line);
|
||||
//
|
||||
// If offending text was provided, then print it
|
||||
//
|
||||
if (Text != NULL) {
|
||||
fprintf (stdout, ": %s ", Text);
|
||||
}
|
||||
//
|
||||
// Print formatted message if provided
|
||||
//
|
||||
if (MsgFmt != NULL) {
|
||||
vsprintf (Line2, MsgFmt, List);
|
||||
fprintf (stdout, ": %s", Line2);
|
||||
}
|
||||
|
||||
fprintf (stdout, "\n");
|
||||
}
|
||||
|
||||
void
|
||||
ParserSetPosition (
|
||||
CHAR8 *SourceFileName,
|
||||
UINT32 LineNum
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Set the position in a file being parsed. This can be used to
|
||||
print error messages deeper down in a parser.
|
||||
|
||||
Arguments:
|
||||
SourceFileName - name of the source file being parsed
|
||||
LineNum - line number of the source file being parsed
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
mSourceFileName = SourceFileName;
|
||||
mSourceFileLineNum = LineNum;
|
||||
}
|
||||
|
||||
void
|
||||
SetUtilityName (
|
||||
CHAR8 *UtilityName
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
All printed error/warning/debug messages follow the same format, and
|
||||
typically will print a filename or utility name followed by the error
|
||||
text. However if a filename is not passed to the print routines, then
|
||||
they'll print the utility name if you call this function early in your
|
||||
app to set the utility name.
|
||||
|
||||
Arguments:
|
||||
UtilityName - name of the utility, which will be printed with all
|
||||
error/warning/debug messags.
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Save the name of the utility in our local variable. Make sure its
|
||||
// length does not exceed our buffer.
|
||||
//
|
||||
if (UtilityName != NULL) {
|
||||
if (strlen (UtilityName) >= sizeof (mUtilityName)) {
|
||||
Error (UtilityName, 0, 0, "application error", "utility name length exceeds internal buffer size");
|
||||
strncpy (mUtilityName, UtilityName, sizeof (mUtilityName) - 1);
|
||||
mUtilityName[sizeof (mUtilityName) - 1] = 0;
|
||||
return ;
|
||||
} else {
|
||||
strcpy (mUtilityName, UtilityName);
|
||||
}
|
||||
} else {
|
||||
Error (NULL, 0, 0, "application error", "SetUtilityName() called with NULL utility name");
|
||||
}
|
||||
}
|
||||
|
||||
STATUS
|
||||
GetUtilityStatus (
|
||||
VOID
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
When you call Error() or Warning(), this module keeps track of it and
|
||||
sets a local mStatus to STATUS_ERROR or STATUS_WARNING. When the utility
|
||||
exits, it can call this function to get the status and use it as a return
|
||||
value.
|
||||
|
||||
Arguments:
|
||||
None.
|
||||
|
||||
Returns:
|
||||
Worst-case status reported, as defined by which print function was called.
|
||||
|
||||
--*/
|
||||
{
|
||||
return mStatus;
|
||||
}
|
||||
|
||||
void
|
||||
SetDebugMsgMask (
|
||||
UINT32 DebugMask
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Set the debug printing mask. This is used by the DebugMsg() function
|
||||
to determine when/if a debug message should be printed.
|
||||
|
||||
Arguments:
|
||||
DebugMask - bitmask, specific to the calling application
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
mDebugMsgMask = DebugMask;
|
||||
}
|
||||
|
||||
void
|
||||
SetPrintLimits (
|
||||
UINT32 MaxErrors,
|
||||
UINT32 MaxWarnings,
|
||||
UINT32 MaxWarningsPlusErrors
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Set the limits of how many errors, warnings, and errors+warnings
|
||||
we will print.
|
||||
|
||||
Arguments:
|
||||
MaxErrors - maximum number of error messages to print
|
||||
MaxWarnings - maximum number of warning messages to print
|
||||
MaxWarningsPlusErrors
|
||||
- maximum number of errors+warnings to print
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
mMaxErrors = MaxErrors;
|
||||
mMaxWarnings = MaxWarnings;
|
||||
mMaxWarningsPlusErrors = MaxWarningsPlusErrors;
|
||||
mPrintLimitsSet = 1;
|
||||
}
|
||||
|
||||
static
|
||||
void
|
||||
PrintLimitExceeded (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
static INT8 mPrintLimitExceeded = 0;
|
||||
//
|
||||
// If we've already printed the message, do nothing. Otherwise
|
||||
// temporarily increase our print limits so we can pass one
|
||||
// more message through.
|
||||
//
|
||||
if (mPrintLimitExceeded == 0) {
|
||||
mPrintLimitExceeded++;
|
||||
mMaxErrors++;
|
||||
mMaxWarnings++;
|
||||
mMaxWarningsPlusErrors++;
|
||||
Error (NULL, 0, 0, "error/warning print limit exceeded", NULL);
|
||||
mMaxErrors--;
|
||||
mMaxWarnings--;
|
||||
mMaxWarningsPlusErrors--;
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
void
|
||||
TestUtilityMessages (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
char *ArgStr = "ArgString";
|
||||
int ArgInt;
|
||||
|
||||
ArgInt = 0x12345678;
|
||||
//
|
||||
// Test without setting utility name
|
||||
//
|
||||
fprintf (stdout, "* Testing without setting utility name\n");
|
||||
fprintf (stdout, "** Test debug message not printed\n");
|
||||
DebugMsg (NULL, 0, 0x00000001, NULL, NULL);
|
||||
fprintf (stdout, "** Test warning with two strings and two args\n");
|
||||
Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
fprintf (stdout, "** Test error with two strings and two args\n");
|
||||
Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
fprintf (stdout, "** Test parser warning with nothing\n");
|
||||
ParserWarning (0, NULL, NULL);
|
||||
fprintf (stdout, "** Test parser error with nothing\n");
|
||||
ParserError (0, NULL, NULL);
|
||||
//
|
||||
// Test with utility name set now
|
||||
//
|
||||
fprintf (stdout, "** Testingin with utility name set\n");
|
||||
SetUtilityName ("MyUtilityName");
|
||||
//
|
||||
// Test debug prints
|
||||
//
|
||||
SetDebugMsgMask (2);
|
||||
fprintf (stdout, "** Test debug message with one string\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, "Text1", NULL);
|
||||
fprintf (stdout, "** Test debug message with one string\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, NULL, "Text2");
|
||||
fprintf (stdout, "** Test debug message with two strings\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, "Text1", "Text2");
|
||||
fprintf (stdout, "** Test debug message with two strings and two args\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
//
|
||||
// Test warning prints
|
||||
//
|
||||
fprintf (stdout, "** Test warning with no strings\n");
|
||||
Warning (NULL, 0, 1234, NULL, NULL);
|
||||
fprintf (stdout, "** Test warning with one string\n");
|
||||
Warning (NULL, 0, 1234, "Text1", NULL);
|
||||
fprintf (stdout, "** Test warning with one string\n");
|
||||
Warning (NULL, 0, 1234, NULL, "Text2");
|
||||
fprintf (stdout, "** Test warning with two strings and two args\n");
|
||||
Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
//
|
||||
// Test error prints
|
||||
//
|
||||
fprintf (stdout, "** Test error with no strings\n");
|
||||
Error (NULL, 0, 1234, NULL, NULL);
|
||||
fprintf (stdout, "** Test error with one string\n");
|
||||
Error (NULL, 0, 1234, "Text1", NULL);
|
||||
fprintf (stdout, "** Test error with one string\n");
|
||||
Error (NULL, 0, 1234, NULL, "Text2");
|
||||
fprintf (stdout, "** Test error with two strings and two args\n");
|
||||
Error (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
//
|
||||
// Test parser prints
|
||||
//
|
||||
fprintf (stdout, "** Test parser errors\n");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, NULL, NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, "Text1", NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, NULL, "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, "Text1", "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
|
||||
fprintf (stdout, "** Test parser warnings\n");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, NULL, NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, "Text1", NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, NULL, "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, "Text1", "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
}
|
||||
#endif
|
138
Tools/Source/TianoTools/Common/EfiUtilityMsgs.h
Normal file
138
Tools/Source/TianoTools/Common/EfiUtilityMsgs.h
Normal file
@@ -0,0 +1,138 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiUtilityMsgs.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Defines and prototypes for common EFI utility error and debug messages.
|
||||
|
||||
--*/
|
||||
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _EFI_UTILITY_MSGS_H_
|
||||
#define _EFI_UTILITY_MSGS_H_
|
||||
|
||||
//
|
||||
// Status codes returned by EFI utility programs and functions
|
||||
//
|
||||
#define STATUS_SUCCESS 0
|
||||
#define STATUS_WARNING 1
|
||||
#define STATUS_ERROR 2
|
||||
#define VOID void
|
||||
|
||||
typedef int STATUS;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
//
|
||||
// When we call Error() or Warning(), the module keeps track of the worst
|
||||
// case reported. GetUtilityStatus() will get the worst-case results, which
|
||||
// can be used as the return value from the app.
|
||||
//
|
||||
STATUS
|
||||
GetUtilityStatus (
|
||||
void
|
||||
);
|
||||
|
||||
//
|
||||
// If someone prints an error message and didn't specify a source file name,
|
||||
// then we print the utility name instead. However they must tell us the
|
||||
// utility name early on via this function.
|
||||
//
|
||||
void
|
||||
SetUtilityName (
|
||||
CHAR8 *ProgramName
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
Error (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
Warning (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
DebugMsg (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MsgLevel,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
SetDebugMsgMask (
|
||||
UINT32 MsgMask
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
ParserSetPosition (
|
||||
CHAR8 *SourceFileName,
|
||||
UINT32 LineNum
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
ParserError (
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
ParserWarning (
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
SetPrintLimits (
|
||||
UINT32 NumErrors,
|
||||
UINT32 NumWarnings,
|
||||
UINT32 NumWarningsPlusErrors
|
||||
)
|
||||
;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // #ifndef _EFI_UTILITY_MSGS_H_
|
788
Tools/Source/TianoTools/Common/FvLib.c
Normal file
788
Tools/Source/TianoTools/Common/FvLib.c
Normal file
@@ -0,0 +1,788 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
FvLib.c
|
||||
|
||||
Abstract:
|
||||
|
||||
These functions assist in parsing and manipulating a Firmware Volume.
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include files
|
||||
//
|
||||
#include "FvLib.h"
|
||||
#include "CommonLib.h"
|
||||
#include "EfiUtilityMsgs.h"
|
||||
#include "MultiPhase.h"
|
||||
/*
|
||||
#include <CommonBuild.h>
|
||||
*/
|
||||
|
||||
/*
|
||||
#include EFI_GUID_DEFINITION (FirmwareFileSystem)
|
||||
*/
|
||||
|
||||
//
|
||||
// Module global variables
|
||||
//
|
||||
EFI_FIRMWARE_VOLUME_HEADER *mFvHeader = NULL;
|
||||
UINT32 mFvLength = 0;
|
||||
|
||||
//
|
||||
// External function implementations
|
||||
//
|
||||
EFI_STATUS
|
||||
InitializeFvLib (
|
||||
IN VOID *Fv,
|
||||
IN UINT32 FvLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This initializes the FV lib with a pointer to the FV and length. It does not
|
||||
verify the FV in any way.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fv Buffer containing the FV.
|
||||
FvLength Length of the FV
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Function Completed successfully.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Verify input arguments
|
||||
//
|
||||
if (Fv == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
mFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) Fv;
|
||||
mFvLength = FvLength;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFvHeader (
|
||||
OUT EFI_FIRMWARE_VOLUME_HEADER **FvHeader,
|
||||
OUT UINT32 *FvLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns a pointer to the current FV and the size.
|
||||
|
||||
Arguments:
|
||||
|
||||
FvHeader Pointer to the FV buffer.
|
||||
FvLength Length of the FV
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Function Completed successfully.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL.
|
||||
EFI_ABORTED The library needs to be initialized.
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input arguments
|
||||
//
|
||||
if (FvHeader == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
*FvHeader = mFvHeader;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetNextFile (
|
||||
IN EFI_FFS_FILE_HEADER *CurrentFile,
|
||||
OUT EFI_FFS_FILE_HEADER **NextFile
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns the next file. If the current file is NULL, it returns
|
||||
the first file in the FV. If the function returns EFI_SUCCESS and the file
|
||||
pointer is NULL, then there are no more files in the FV.
|
||||
|
||||
Arguments:
|
||||
|
||||
CurrentFile Pointer to the current file, must be within the current FV.
|
||||
NextFile Pointer to the next file in the FV.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Function completed successfully.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL or is out of range.
|
||||
EFI_ABORTED The library needs to be initialized.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input arguments
|
||||
//
|
||||
if (NextFile == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get first file
|
||||
//
|
||||
if (CurrentFile == NULL) {
|
||||
CurrentFile = (EFI_FFS_FILE_HEADER *) ((UINTN) mFvHeader + mFvHeader->HeaderLength);
|
||||
|
||||
//
|
||||
// Verify file is valid
|
||||
//
|
||||
Status = VerifyFfsFile (CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// no files in this FV
|
||||
//
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
} else {
|
||||
//
|
||||
// Verify file is in this FV.
|
||||
//
|
||||
if ((UINTN) CurrentFile >= (UINTN) mFvHeader + mFvLength - sizeof (EFI_FFS_FILE_HEADER)) {
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
*NextFile = CurrentFile;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Verify current file is in range
|
||||
//
|
||||
if (((UINTN) CurrentFile < (UINTN) mFvHeader + sizeof (EFI_FIRMWARE_VOLUME_HEADER)) ||
|
||||
((UINTN) CurrentFile >= (UINTN) mFvHeader + mFvLength - sizeof (EFI_FIRMWARE_VOLUME_HEADER))
|
||||
) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Get next file, compensate for 8 byte alignment if necessary.
|
||||
//
|
||||
*NextFile = (EFI_FFS_FILE_HEADER *) (((UINTN) CurrentFile + GetLength (CurrentFile->Size) + 0x07) & (-1 << 3));
|
||||
|
||||
//
|
||||
// Verify file is in this FV.
|
||||
//
|
||||
if ((UINTN) *NextFile >= (UINTN) mFvHeader + mFvLength - sizeof (EFI_FFS_FILE_HEADER)) {
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
//
|
||||
// Verify file is valid
|
||||
//
|
||||
Status = VerifyFfsFile (*NextFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// no more files in this FV
|
||||
//
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByName (
|
||||
IN EFI_GUID *FileName,
|
||||
OUT EFI_FFS_FILE_HEADER **File
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Find a file by name. The function will return NULL if the file is not found.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileName The GUID file name of the file to search for.
|
||||
File Return pointer. In the case of an error, contents are undefined.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_ABORTED An error was encountered.
|
||||
EFI_INVALID_PARAMETER One of the parameters was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *CurrentFile;
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (FileName == NULL || File == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get the first file
|
||||
//
|
||||
Status = GetNextFile (NULL, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing the FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Loop as long as we have a valid file
|
||||
//
|
||||
while (CurrentFile) {
|
||||
if (!CompareGuid (&CurrentFile->Name, FileName)) {
|
||||
*File = CurrentFile;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Status = GetNextFile (CurrentFile, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing the FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
//
|
||||
// File not found in this FV.
|
||||
//
|
||||
*File = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByType (
|
||||
IN EFI_FV_FILETYPE FileType,
|
||||
IN UINTN Instance,
|
||||
OUT EFI_FFS_FILE_HEADER **File
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Find a file by type and instance. An instance of 1 is the first instance.
|
||||
The function will return NULL if a matching file cannot be found.
|
||||
File type EFI_FV_FILETYPE_ALL means any file type is valid.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileType Type of file to search for.
|
||||
Instance Instace of the file type to return.
|
||||
File Return pointer. In the case of an error, contents are undefined.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_ABORTED An error was encountered.
|
||||
EFI_INVALID_PARAMETER One of the parameters was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *CurrentFile;
|
||||
EFI_STATUS Status;
|
||||
UINTN FileCount;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (File == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Initialize the number of matching files found.
|
||||
//
|
||||
FileCount = 0;
|
||||
|
||||
//
|
||||
// Get the first file
|
||||
//
|
||||
Status = GetNextFile (NULL, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Loop as long as we have a valid file
|
||||
//
|
||||
while (CurrentFile) {
|
||||
if (FileType == EFI_FV_FILETYPE_ALL || CurrentFile->Type == FileType) {
|
||||
FileCount++;
|
||||
}
|
||||
|
||||
if (FileCount == Instance) {
|
||||
*File = CurrentFile;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Status = GetNextFile (CurrentFile, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing the FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
*File = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetSectionByType (
|
||||
IN EFI_FFS_FILE_HEADER *File,
|
||||
IN EFI_SECTION_TYPE SectionType,
|
||||
IN UINTN Instance,
|
||||
OUT EFI_FILE_SECTION_POINTER *Section
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Find a section in a file by type and instance. An instance of 1 is the first
|
||||
instance. The function will return NULL if a matching section cannot be found.
|
||||
The function will not handle encapsulating sections.
|
||||
|
||||
Arguments:
|
||||
|
||||
File The file to search.
|
||||
SectionType Type of file to search for.
|
||||
Instance Instace of the section to return.
|
||||
Section Return pointer. In the case of an error, contents are undefined.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_ABORTED An error was encountered.
|
||||
EFI_INVALID_PARAMETER One of the parameters was NULL.
|
||||
EFI_NOT_FOUND No found.
|
||||
--*/
|
||||
{
|
||||
EFI_FILE_SECTION_POINTER CurrentSection;
|
||||
EFI_STATUS Status;
|
||||
UINTN SectionCount;
|
||||
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (File == NULL || Instance == 0) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FFS header
|
||||
//
|
||||
Status = VerifyFfsFile (File);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "invalid FFS file", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Initialize the number of matching sections found.
|
||||
//
|
||||
SectionCount = 0;
|
||||
|
||||
//
|
||||
// Get the first section
|
||||
//
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + sizeof (EFI_FFS_FILE_HEADER));
|
||||
|
||||
//
|
||||
// Loop as long as we have a valid file
|
||||
//
|
||||
while ((UINTN) CurrentSection.CommonHeader < (UINTN) File + GetLength (File->Size)) {
|
||||
if (CurrentSection.CommonHeader->Type == SectionType) {
|
||||
SectionCount++;
|
||||
}
|
||||
|
||||
if (SectionCount == Instance) {
|
||||
*Section = CurrentSection;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
//
|
||||
// Find next section (including compensating for alignment issues.
|
||||
//
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetLength (CurrentSection.CommonHeader->Size) + 0x03) & (-1 << 2));
|
||||
}
|
||||
//
|
||||
// Section not found
|
||||
//
|
||||
(*Section).Code16Section = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
//
|
||||
// will not parse compressed sections
|
||||
//
|
||||
EFI_STATUS
|
||||
VerifyFv (
|
||||
IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Verify the current pointer points to a valid FV header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FvHeader Pointer to an alleged FV file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The FV header is valid.
|
||||
EFI_VOLUME_CORRUPTED The FV header is not valid.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL.
|
||||
EFI_ABORTED Operation aborted.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Checksum;
|
||||
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (FvHeader == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (FvHeader->Signature != EFI_FVH_SIGNATURE) {
|
||||
Error (NULL, 0, 0, "invalid FV header signature", NULL);
|
||||
return EFI_VOLUME_CORRUPTED;
|
||||
}
|
||||
//
|
||||
// Verify header checksum
|
||||
//
|
||||
Checksum = CalculateSum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
|
||||
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0, "invalid FV header checksum", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
VerifyFfsFile (
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Verify the current pointer points to a FFS file header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FfsHeader Pointer to an alleged FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The Ffs header is valid.
|
||||
EFI_NOT_FOUND This "file" is the beginning of free space.
|
||||
EFI_VOLUME_CORRUPTED The Ffs header is not valid.
|
||||
EFI_ABORTED The erase polarity is not known.
|
||||
|
||||
--*/
|
||||
{
|
||||
BOOLEAN ErasePolarity;
|
||||
EFI_STATUS Status;
|
||||
EFI_FFS_FILE_HEADER BlankHeader;
|
||||
UINT8 Checksum;
|
||||
UINT32 FileLength;
|
||||
UINT32 OccupiedFileLength;
|
||||
EFI_FFS_FILE_TAIL *Tail;
|
||||
UINT8 SavedChecksum;
|
||||
UINT8 SavedState;
|
||||
UINT8 FileGuidString[80];
|
||||
UINT32 TailSize;
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get the erase polarity.
|
||||
//
|
||||
Status = GetErasePolarity (&ErasePolarity);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Check if we have free space
|
||||
//
|
||||
if (ErasePolarity) {
|
||||
memset (&BlankHeader, -1, sizeof (EFI_FFS_FILE_HEADER));
|
||||
} else {
|
||||
memset (&BlankHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
|
||||
}
|
||||
|
||||
if (memcmp (&BlankHeader, FfsHeader, sizeof (EFI_FFS_FILE_HEADER)) == 0) {
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
//
|
||||
// Convert the GUID to a string so we can at least report which file
|
||||
// if we find an error.
|
||||
//
|
||||
PrintGuidToBuffer (&FfsHeader->Name, FileGuidString, sizeof (FileGuidString), TRUE);
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
|
||||
TailSize = sizeof (EFI_FFS_FILE_TAIL);
|
||||
} else {
|
||||
TailSize = 0;
|
||||
}
|
||||
//
|
||||
// Verify file header checksum
|
||||
//
|
||||
SavedState = FfsHeader->State;
|
||||
FfsHeader->State = 0;
|
||||
SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File;
|
||||
FfsHeader->IntegrityCheck.Checksum.File = 0;
|
||||
Checksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER));
|
||||
FfsHeader->State = SavedState;
|
||||
FfsHeader->IntegrityCheck.Checksum.File = SavedChecksum;
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid FFS file header checksum");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify file checksum
|
||||
//
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_CHECKSUM) {
|
||||
//
|
||||
// Verify file data checksum
|
||||
//
|
||||
FileLength = GetLength (FfsHeader->Size);
|
||||
OccupiedFileLength = (FileLength + 0x07) & (-1 << 3);
|
||||
Checksum = CalculateSum8 ((UINT8 *) FfsHeader, FileLength - TailSize);
|
||||
Checksum = (UINT8) (Checksum - FfsHeader->State);
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid FFS file checksum");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
} else {
|
||||
//
|
||||
// File does not have a checksum
|
||||
// Verify contents are 0x5A as spec'd
|
||||
//
|
||||
if (FfsHeader->IntegrityCheck.Checksum.File != FFS_FIXED_CHECKSUM) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid fixed FFS file header checksum");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Check if the tail is present and verify it if it is.
|
||||
//
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
|
||||
//
|
||||
// Verify tail is complement of integrity check field in the header.
|
||||
//
|
||||
Tail = (EFI_FFS_FILE_TAIL *) ((UINTN) FfsHeader + GetLength (FfsHeader->Size) - sizeof (EFI_FFS_FILE_TAIL));
|
||||
if (FfsHeader->IntegrityCheck.TailReference != (EFI_FFS_FILE_TAIL)~(*Tail)) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid FFS file tail");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetLength (
|
||||
UINT8 *ThreeByteLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a three byte length value into a UINT32.
|
||||
|
||||
Arguments:
|
||||
|
||||
ThreeByteLength Pointer to the first of the 3 byte length.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT32 Size of the section
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 Length;
|
||||
|
||||
if (ThreeByteLength == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Length = *((UINT32 *) ThreeByteLength);
|
||||
Length = Length & 0x00FFFFFF;
|
||||
|
||||
return Length;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetErasePolarity (
|
||||
OUT BOOLEAN *ErasePolarity
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns with the FV erase polarity. If the erase polarity
|
||||
for a bit is 1, the function return TRUE.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity A pointer to the erase polarity.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
||||
EFI_ABORTED Operation aborted.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input parameters.
|
||||
//
|
||||
if (ErasePolarity == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (mFvHeader->Attributes & EFI_FVB_ERASE_POLARITY) {
|
||||
*ErasePolarity = TRUE;
|
||||
} else {
|
||||
*ErasePolarity = FALSE;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT8
|
||||
GetFileState (
|
||||
IN BOOLEAN ErasePolarity,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns a the highest state bit in the FFS that is set.
|
||||
It in no way validate the FFS file.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity The erase polarity for the file state bits.
|
||||
FfsHeader Pointer to a FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT8 The hightest set state of the file.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 FileState;
|
||||
UINT8 HighestBit;
|
||||
|
||||
FileState = FfsHeader->State;
|
||||
|
||||
if (ErasePolarity) {
|
||||
FileState = (UINT8)~FileState;
|
||||
}
|
||||
|
||||
HighestBit = 0x80;
|
||||
while (HighestBit != 0 && (HighestBit & FileState) == 0) {
|
||||
HighestBit >>= 1;
|
||||
}
|
||||
|
||||
return HighestBit;
|
||||
}
|
185
Tools/Source/TianoTools/Common/FvLib.h
Normal file
185
Tools/Source/TianoTools/Common/FvLib.h
Normal file
@@ -0,0 +1,185 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
FvLib.h
|
||||
|
||||
Abstract:
|
||||
|
||||
These functions assist in parsing and manipulating a Firmware Volume.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_FV_LIB_H
|
||||
#define _EFI_FV_LIB_H
|
||||
|
||||
//
|
||||
// Include files
|
||||
//
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
#include <Common/EfiImage.h>
|
||||
#include <Common/FirmwareVolumeImageFormat.h>
|
||||
#include <Common/FirmwareFileSystem.h>
|
||||
#include <Common/FirmwareVolumeHeader.h>
|
||||
/*
|
||||
#include "TianoCommon.h"
|
||||
#include "EfiFirmwareVolumeHeader.h"
|
||||
#include "EfiFirmwareFileSystem.h"
|
||||
*/
|
||||
#include <string.h>
|
||||
|
||||
EFI_STATUS
|
||||
InitializeFvLib (
|
||||
IN VOID *Fv,
|
||||
IN UINT32 FvLength
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFvHeader (
|
||||
OUT EFI_FIRMWARE_VOLUME_HEADER **FvHeader,
|
||||
OUT UINT32 *FvLength
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetNextFile (
|
||||
IN EFI_FFS_FILE_HEADER *CurrentFile,
|
||||
OUT EFI_FFS_FILE_HEADER **NextFile
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByName (
|
||||
IN EFI_GUID *FileName,
|
||||
OUT EFI_FFS_FILE_HEADER **File
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByType (
|
||||
IN EFI_FV_FILETYPE FileType,
|
||||
IN UINTN Instance,
|
||||
OUT EFI_FFS_FILE_HEADER **File
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetSectionByType (
|
||||
IN EFI_FFS_FILE_HEADER *File,
|
||||
IN EFI_SECTION_TYPE SectionType,
|
||||
IN UINTN Instance,
|
||||
OUT EFI_FILE_SECTION_POINTER *Section
|
||||
)
|
||||
;
|
||||
//
|
||||
// will not parse compressed sections
|
||||
//
|
||||
EFI_STATUS
|
||||
VerifyFv (
|
||||
IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
VerifyFfsFile (
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Verify the current pointer points to a FFS file header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FfsHeader Pointer to an alleged FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The Ffs header is valid.
|
||||
EFI_NOT_FOUND This "file" is the beginning of free space.
|
||||
EFI_VOLUME_CORRUPTED The Ffs header is not valid.
|
||||
|
||||
--*/
|
||||
UINT32
|
||||
GetLength (
|
||||
UINT8 *ThreeByteLength
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a three byte length value into a UINT32.
|
||||
|
||||
Arguments:
|
||||
|
||||
ThreeByteLength Pointer to the first of the 3 byte length.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT32 Size of the section
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
GetErasePolarity (
|
||||
OUT BOOLEAN *ErasePolarity
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns with the FV erase polarity. If the erase polarity
|
||||
for a bit is 1, the function return TRUE.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity A pointer to the erase polarity.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
||||
|
||||
--*/
|
||||
UINT8
|
||||
GetFileState (
|
||||
IN BOOLEAN ErasePolarity,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns a the highest state bit in the FFS that is set.
|
||||
It in no way validate the FFS file.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity The erase polarity for the file state bits.
|
||||
FfsHeader Pointer to a FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT8 The hightest set state of the file.
|
||||
|
||||
--*/
|
||||
#endif
|
516
Tools/Source/TianoTools/Common/MyAlloc.c
Normal file
516
Tools/Source/TianoTools/Common/MyAlloc.c
Normal file
@@ -0,0 +1,516 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
MyAlloc.c
|
||||
|
||||
Abstract:
|
||||
|
||||
File for memory allocation tracking functions.
|
||||
|
||||
--*/
|
||||
|
||||
#include "MyAlloc.h"
|
||||
|
||||
#if USE_MYALLOC
|
||||
//
|
||||
// Get back to original alloc/free calls.
|
||||
//
|
||||
#undef malloc
|
||||
#undef calloc
|
||||
#undef realloc
|
||||
#undef free
|
||||
//
|
||||
// Start of allocation list.
|
||||
//
|
||||
static MY_ALLOC_STRUCT *MyAllocData = NULL;
|
||||
|
||||
//
|
||||
//
|
||||
//
|
||||
static UINT32 MyAllocHeadMagik = MYALLOC_HEAD_MAGIK;
|
||||
static UINT32 MyAllocTailMagik = MYALLOC_TAIL_MAGIK;
|
||||
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID
|
||||
MyCheck (
|
||||
BOOLEAN Final,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Check for corruptions in the allocated memory chain. If a corruption
|
||||
// is detection program operation stops w/ an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Final := When FALSE, MyCheck() returns if the allocated memory chain
|
||||
// has not been corrupted. When TRUE, MyCheck() returns if there
|
||||
// are no un-freed allocations. If there are un-freed allocations,
|
||||
// they are displayed and exit(1) is called.
|
||||
//
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
|
||||
//
|
||||
// Check parameters.
|
||||
//
|
||||
if (File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%xh, Line=%u)"
|
||||
"Invalid parameter(s).\n",
|
||||
Final,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
if (strlen (File) == 0) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%s, Line=%u)"
|
||||
"Invalid parameter.\n",
|
||||
Final,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Check structure contents.
|
||||
//
|
||||
for (Tmp = MyAllocData; Tmp != NULL; Tmp = Tmp->Next) {
|
||||
if (memcmp(Tmp->Buffer, &MyAllocHeadMagik, sizeof MyAllocHeadMagik) ||
|
||||
memcmp(&Tmp->Buffer[Tmp->Size + sizeof(UINT32)], &MyAllocTailMagik, sizeof MyAllocTailMagik)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
//
|
||||
// If Tmp is not NULL, the structure is corrupt.
|
||||
//
|
||||
if (Tmp != NULL) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%s, Line=%u)""\nStructure corrupted!"
|
||||
"\nFile=%s, Line=%u, nSize=%u, Head=%xh, Tail=%xh\n",
|
||||
Final,
|
||||
File,
|
||||
Line,
|
||||
Tmp->File,
|
||||
Tmp->Line,
|
||||
Tmp->Size,
|
||||
*(UINT32 *) (Tmp->Buffer),
|
||||
*(UINT32 *) (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)])
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// If Final is TRUE, display the state of the structure chain.
|
||||
//
|
||||
if (Final) {
|
||||
if (MyAllocData != NULL) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%s, Line=%u)"
|
||||
"\nSome allocated items have not been freed.\n",
|
||||
Final,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
for (Tmp = MyAllocData; Tmp != NULL; Tmp = Tmp->Next) {
|
||||
printf (
|
||||
"File=%s, Line=%u, nSize=%u, Head=%xh, Tail=%xh\n",
|
||||
Tmp->File,
|
||||
Tmp->Line,
|
||||
Tmp->Size,
|
||||
*(UINT32 *) (Tmp->Buffer),
|
||||
*(UINT32 *) (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)])
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID *
|
||||
MyAlloc (
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Allocate a new link in the allocation chain along with enough storage
|
||||
// for the File[] string, requested Size and alignment overhead. If
|
||||
// memory cannot be allocated or the allocation chain has been corrupted,
|
||||
// exit(1) will be called.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Size := Number of bytes (UINT8) requested by the called.
|
||||
// Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to the caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
UINTN Len;
|
||||
|
||||
//
|
||||
// Check for invalid parameters.
|
||||
//
|
||||
if (Size == 0 || File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyAlloc(Size=%u, File=%xh, Line=%u)"
|
||||
"\nInvalid parameter(s).\n",
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
Len = strlen (File);
|
||||
if (Len == 0) {
|
||||
printf (
|
||||
"\nMyAlloc(Size=%u, File=%s, Line=%u)"
|
||||
"\nInvalid parameter.\n",
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Check the allocation list for corruption.
|
||||
//
|
||||
MyCheck (0, __FILE__, __LINE__);
|
||||
|
||||
//
|
||||
// Allocate a new entry.
|
||||
//
|
||||
Tmp = calloc (
|
||||
1,
|
||||
sizeof (MY_ALLOC_STRUCT) + Len + 1 + sizeof (UINT64) + Size + (sizeof MyAllocHeadMagik) + (sizeof MyAllocTailMagik)
|
||||
);
|
||||
|
||||
if (Tmp == NULL) {
|
||||
printf (
|
||||
"\nMyAlloc(Size=%u, File=%s, Line=%u)"
|
||||
"\nOut of memory.\n",
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Fill in the new entry.
|
||||
//
|
||||
Tmp->File = ((UINT8 *) Tmp) + sizeof (MY_ALLOC_STRUCT);
|
||||
strcpy (Tmp->File, File);
|
||||
Tmp->Line = Line;
|
||||
Tmp->Size = Size;
|
||||
Tmp->Buffer = (UINT8 *) (((UINTN) Tmp + Len + 9) &~7);
|
||||
|
||||
memcpy (Tmp->Buffer, &MyAllocHeadMagik, sizeof MyAllocHeadMagik);
|
||||
|
||||
memcpy (
|
||||
&Tmp->Buffer[Size + sizeof (UINT32)],
|
||||
&MyAllocTailMagik,
|
||||
sizeof MyAllocTailMagik
|
||||
);
|
||||
|
||||
Tmp->Next = MyAllocData;
|
||||
Tmp->Cksum = (UINTN) Tmp + (UINTN) (Tmp->Next) + Tmp->Line + Tmp->Size + (UINTN) (Tmp->File) + (UINTN) (Tmp->Buffer);
|
||||
|
||||
MyAllocData = Tmp;
|
||||
|
||||
return Tmp->Buffer + sizeof (UINT32);
|
||||
}
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID *
|
||||
MyRealloc (
|
||||
VOID *Ptr,
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// This does a MyAlloc(), memcpy() and MyFree(). There is no optimization
|
||||
// for shrinking or expanding buffers. An invalid parameter will cause
|
||||
// MyRealloc() to fail with a call to exit(1).
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be re-allocated.
|
||||
//
|
||||
// Size := Size of new buffer. Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to new caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
VOID *Buffer;
|
||||
|
||||
//
|
||||
// Check for invalid parameter(s).
|
||||
//
|
||||
if (Size == 0 || File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyRealloc(Ptr=%xh, Size=%u, File=%xh, Line=%u)"
|
||||
"\nInvalid parameter(s).\n",
|
||||
Ptr,
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
if (strlen (File) == 0) {
|
||||
printf (
|
||||
"\nMyRealloc(Ptr=%xh, Size=%u, File=%s, Line=%u)"
|
||||
"\nInvalid parameter.\n",
|
||||
Ptr,
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Find existing buffer in allocation list.
|
||||
//
|
||||
if (Ptr == NULL) {
|
||||
Tmp = NULL;
|
||||
} else if (&MyAllocData->Buffer[sizeof (UINT32)] == Ptr) {
|
||||
Tmp = MyAllocData;
|
||||
} else {
|
||||
for (Tmp = MyAllocData;; Tmp = Tmp->Next) {
|
||||
if (Tmp->Next == NULL) {
|
||||
printf (
|
||||
"\nMyRealloc(Ptr=%xh, Size=%u, File=%s, Line=%u)"
|
||||
"\nCould not find buffer.\n",
|
||||
Ptr,
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
Tmp = Tmp->Next;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Allocate new buffer, copy old data, free old buffer.
|
||||
//
|
||||
Buffer = MyAlloc (Size, File, Line);
|
||||
|
||||
if (Buffer != NULL && Tmp != NULL) {
|
||||
memcpy (
|
||||
Buffer,
|
||||
&Tmp->Buffer[sizeof (UINT32)],
|
||||
((Size <= Tmp->Size) ? Size : Tmp->Size)
|
||||
);
|
||||
|
||||
MyFree (Ptr, __FILE__, __LINE__);
|
||||
}
|
||||
|
||||
return Buffer;
|
||||
}
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID
|
||||
MyFree (
|
||||
VOID *Ptr,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Release a previously allocated buffer. Invalid parameters will cause
|
||||
// MyFree() to fail with an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be freed.
|
||||
// A NULL pointer will be ignored.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
MY_ALLOC_STRUCT *Tmp2;
|
||||
|
||||
//
|
||||
// Check for invalid parameter(s).
|
||||
//
|
||||
if (File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%xh, Line=%u)"
|
||||
"\nInvalid parameter(s).\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
if (strlen (File) == 0) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%s, Line=%u)"
|
||||
"\nInvalid parameter.\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Freeing NULL is always valid.
|
||||
//
|
||||
if (Ptr == NULL) {
|
||||
return ;
|
||||
}
|
||||
//
|
||||
// Fail if nothing is allocated.
|
||||
//
|
||||
if (MyAllocData == NULL) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%s, Line=%u)"
|
||||
"\nCalled before memory allocated.\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Check for corrupted allocation list.
|
||||
//
|
||||
MyCheck (0, __FILE__, __LINE__);
|
||||
|
||||
//
|
||||
// Need special check for first item in list.
|
||||
//
|
||||
if (&MyAllocData->Buffer[sizeof (UINT32)] == Ptr) {
|
||||
//
|
||||
// Unlink first item in list.
|
||||
//
|
||||
Tmp = MyAllocData;
|
||||
MyAllocData = MyAllocData->Next;
|
||||
} else {
|
||||
//
|
||||
// Walk list looking for matching item.
|
||||
//
|
||||
for (Tmp = MyAllocData;; Tmp = Tmp->Next) {
|
||||
//
|
||||
// Fail if end of list is reached.
|
||||
//
|
||||
if (Tmp->Next == NULL) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%s, Line=%u)\n"
|
||||
"\nNot found.\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Leave loop when match is found.
|
||||
//
|
||||
if (&Tmp->Next->Buffer[sizeof (UINT32)] == Ptr) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Unlink item from list.
|
||||
//
|
||||
Tmp2 = Tmp->Next;
|
||||
Tmp->Next = Tmp->Next->Next;
|
||||
Tmp = Tmp2;
|
||||
}
|
||||
//
|
||||
// Release item.
|
||||
//
|
||||
free (Tmp);
|
||||
}
|
||||
|
||||
#endif /* USE_MYALLOC */
|
||||
|
||||
/* eof - MyAlloc.c */
|
225
Tools/Source/TianoTools/Common/MyAlloc.h
Normal file
225
Tools/Source/TianoTools/Common/MyAlloc.h
Normal file
@@ -0,0 +1,225 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
MyAlloc.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for memory allocation tracking functions.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _MYALLOC_H_
|
||||
#define _MYALLOC_H_
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <Base.h>
|
||||
|
||||
/*
|
||||
#include "Tiano.h"
|
||||
*/
|
||||
|
||||
//
|
||||
// Default operation is to use the memory allocation tracking functions.
|
||||
// To over-ride add "#define USE_MYALLOC 0" to your program header and/or
|
||||
// source files as needed. Or, just do not include this header file in
|
||||
// your project.
|
||||
//
|
||||
#ifndef USE_MYALLOC
|
||||
#define USE_MYALLOC 1
|
||||
#endif
|
||||
|
||||
#if USE_MYALLOC
|
||||
//
|
||||
// Replace C library allocation routines with MyAlloc routines.
|
||||
//
|
||||
#define malloc(size) MyAlloc ((size), __FILE__, __LINE__)
|
||||
#define calloc(count, size) MyAlloc ((count) * (size), __FILE__, __LINE__)
|
||||
#define realloc(ptr, size) MyRealloc ((ptr), (size), __FILE__, __LINE__)
|
||||
#define free(ptr) MyFree ((ptr), __FILE__, __LINE__)
|
||||
#define alloc_check(final) MyCheck ((final), __FILE__, __LINE__)
|
||||
|
||||
//
|
||||
// Structure for checking/tracking memory allocations.
|
||||
//
|
||||
typedef struct MyAllocStruct {
|
||||
UINTN Cksum;
|
||||
struct MyAllocStruct *Next;
|
||||
UINTN Line;
|
||||
UINTN Size;
|
||||
UINT8 *File;
|
||||
UINT8 *Buffer;
|
||||
} MY_ALLOC_STRUCT;
|
||||
//
|
||||
// Cksum := (UINTN)This + (UINTN)Next + Line + Size + (UINTN)File +
|
||||
// (UINTN)Buffer;
|
||||
//
|
||||
// Next := Pointer to next allocation structure in the list.
|
||||
//
|
||||
// Line := __LINE__
|
||||
//
|
||||
// Size := Size of allocation request.
|
||||
//
|
||||
// File := Pointer to __FILE__ string stored immediately following
|
||||
// MY_ALLOC_STRUCT in memory.
|
||||
//
|
||||
// Buffer := Pointer to UINT32 aligned storage immediately following
|
||||
// the NULL terminated __FILE__ string. This is UINT32
|
||||
// aligned because the underflow signature is 32-bits and
|
||||
// this will place the first caller address on a 64-bit
|
||||
// boundary.
|
||||
//
|
||||
//
|
||||
// Signatures used to check for buffer overflow/underflow conditions.
|
||||
//
|
||||
#define MYALLOC_HEAD_MAGIK 0xBADFACED
|
||||
#define MYALLOC_TAIL_MAGIK 0xDEADBEEF
|
||||
|
||||
VOID
|
||||
MyCheck (
|
||||
BOOLEAN Final,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Check for corruptions in the allocated memory chain. If a corruption
|
||||
// is detection program operation stops w/ an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Final := When FALSE, MyCheck() returns if the allocated memory chain
|
||||
// has not been corrupted. When TRUE, MyCheck() returns if there
|
||||
// are no un-freed allocations. If there are un-freed allocations,
|
||||
// they are displayed and exit(1) is called.
|
||||
//
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
VOID *
|
||||
MyAlloc (
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Allocate a new link in the allocation chain along with enough storage
|
||||
// for the File[] string, requested Size and alignment overhead. If
|
||||
// memory cannot be allocated or the allocation chain has been corrupted,
|
||||
// exit(1) will be called.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Size := Number of bytes (UINT8) requested by the called.
|
||||
// Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to the caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
VOID *
|
||||
MyRealloc (
|
||||
VOID *Ptr,
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// This does a MyAlloc(), memcpy() and MyFree(). There is no optimization
|
||||
// for shrinking or expanding buffers. An invalid parameter will cause
|
||||
// MyRealloc() to fail with a call to exit(1).
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be re-allocated.
|
||||
// Ptr cannot be NULL.
|
||||
//
|
||||
// Size := Size of new buffer. Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to new caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
VOID
|
||||
MyFree (
|
||||
VOID *Ptr,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Release a previously allocated buffer. Invalid parameters will cause
|
||||
// MyFree() to fail with an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be freed.
|
||||
// A NULL pointer will be ignored.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
#else /* USE_MYALLOC */
|
||||
|
||||
//
|
||||
// Nothing to do when USE_MYALLOC is zero.
|
||||
//
|
||||
#define alloc_check(final)
|
||||
|
||||
#endif /* USE_MYALLOC */
|
||||
#endif /* _MYALLOC_H_ */
|
||||
|
||||
/* eof - MyAlloc.h */
|
630
Tools/Source/TianoTools/Common/ParseInf.c
Normal file
630
Tools/Source/TianoTools/Common/ParseInf.c
Normal file
@@ -0,0 +1,630 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
ParseInf.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This contains some useful functions for parsing INF files.
|
||||
|
||||
--*/
|
||||
|
||||
#include "ParseInf.h"
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef _MAX_PATH
|
||||
#define _MAX_PATH 500
|
||||
#endif
|
||||
|
||||
CHAR8 *
|
||||
ReadLine (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer,
|
||||
IN UINTN MaxLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
The function reads a string from the input stream argument and stores it in
|
||||
the input string. ReadLine reads characters from the current file position
|
||||
to and including the first newline character, to the end of the stream, or
|
||||
until the number of characters read is equal to MaxLength - 1, whichever
|
||||
comes first. The newline character, if read, is replaced with a \0.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
MaxLength The maximum size of the input buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *CharPtr;
|
||||
CHAR8 *EndOfLine;
|
||||
UINTN CharsToCopy;
|
||||
|
||||
//
|
||||
// Verify input parameters are not null
|
||||
//
|
||||
assert (InputBuffer);
|
||||
assert (InputFile->FileImage);
|
||||
assert (InputFile->Eof);
|
||||
assert (InputFile->CurrentFilePointer);
|
||||
|
||||
//
|
||||
// Check for end of file condition
|
||||
//
|
||||
if (InputFile->CurrentFilePointer >= InputFile->Eof) {
|
||||
return NULL;
|
||||
}
|
||||
//
|
||||
// Find the next newline char
|
||||
//
|
||||
EndOfLine = strchr (InputFile->CurrentFilePointer, '\n');
|
||||
|
||||
//
|
||||
// Determine the number of characters to copy.
|
||||
//
|
||||
if (EndOfLine == 0) {
|
||||
//
|
||||
// If no newline found, copy to the end of the file.
|
||||
//
|
||||
CharsToCopy = InputFile->Eof - InputFile->CurrentFilePointer;
|
||||
} else if (EndOfLine >= InputFile->Eof) {
|
||||
//
|
||||
// If the newline found was beyond the end of file, copy to the eof.
|
||||
//
|
||||
CharsToCopy = InputFile->Eof - InputFile->CurrentFilePointer;
|
||||
} else {
|
||||
//
|
||||
// Newline found in the file.
|
||||
//
|
||||
CharsToCopy = EndOfLine - InputFile->CurrentFilePointer;
|
||||
}
|
||||
//
|
||||
// If the end of line is too big for the current buffer, set it to the max
|
||||
// size of the buffer (leaving room for the \0.
|
||||
//
|
||||
if (CharsToCopy > MaxLength - 1) {
|
||||
CharsToCopy = MaxLength - 1;
|
||||
}
|
||||
//
|
||||
// Copy the line.
|
||||
//
|
||||
memcpy (InputBuffer, InputFile->CurrentFilePointer, CharsToCopy);
|
||||
|
||||
//
|
||||
// Add the null termination over the 0x0D
|
||||
//
|
||||
InputBuffer[CharsToCopy - 1] = '\0';
|
||||
|
||||
//
|
||||
// Increment the current file pointer (include the 0x0A)
|
||||
//
|
||||
InputFile->CurrentFilePointer += CharsToCopy + 1;
|
||||
|
||||
//
|
||||
// Strip any comments
|
||||
//
|
||||
CharPtr = strstr (InputBuffer, "//");
|
||||
if (CharPtr != 0) {
|
||||
CharPtr[0] = 0;
|
||||
}
|
||||
//
|
||||
// Return the string
|
||||
//
|
||||
return InputBuffer;
|
||||
}
|
||||
|
||||
BOOLEAN
|
||||
FindSection (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 InputBuffer[_MAX_PATH];
|
||||
CHAR8 *CurrentToken;
|
||||
|
||||
//
|
||||
// Verify input is not NULL
|
||||
//
|
||||
assert (InputFile->FileImage);
|
||||
assert (InputFile->Eof);
|
||||
assert (InputFile->CurrentFilePointer);
|
||||
assert (Section);
|
||||
|
||||
//
|
||||
// Rewind to beginning of file
|
||||
//
|
||||
InputFile->CurrentFilePointer = InputFile->FileImage;
|
||||
|
||||
//
|
||||
// Read lines until the section is found
|
||||
//
|
||||
while (InputFile->CurrentFilePointer < InputFile->Eof) {
|
||||
//
|
||||
// Read a line
|
||||
//
|
||||
ReadLine (InputFile, InputBuffer, _MAX_PATH);
|
||||
|
||||
//
|
||||
// Check if the section is found
|
||||
//
|
||||
CurrentToken = strstr (InputBuffer, Section);
|
||||
if (CurrentToken != NULL) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
FindToken (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section,
|
||||
IN CHAR8 *Token,
|
||||
IN UINTN Instance,
|
||||
OUT CHAR8 *Value
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Finds a token value given the section and token to search for.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section The section to search for, a string within [].
|
||||
Token The token to search for, e.g. EFI_PEIM_RECOVERY, followed by an = in the INF file.
|
||||
Instance The instance of the token to search for. Zero is the first instance.
|
||||
Value The string that holds the value following the =. Must be _MAX_PATH in size.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Value found.
|
||||
EFI_ABORTED Format error detected in INF file.
|
||||
EFI_INVALID_PARAMETER Input argument was null.
|
||||
EFI_LOAD_ERROR Error reading from the file.
|
||||
EFI_NOT_FOUND Section/Token/Value not found.
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 InputBuffer[_MAX_PATH];
|
||||
CHAR8 *CurrentToken;
|
||||
BOOLEAN ParseError;
|
||||
BOOLEAN ReadError;
|
||||
UINTN Occurrance;
|
||||
|
||||
//
|
||||
// Check input parameters
|
||||
//
|
||||
if (InputFile->FileImage == NULL ||
|
||||
InputFile->Eof == NULL ||
|
||||
InputFile->CurrentFilePointer == NULL ||
|
||||
Section == NULL ||
|
||||
strlen (Section) == 0 ||
|
||||
Token == NULL ||
|
||||
strlen (Token) == 0 ||
|
||||
Value == NULL
|
||||
) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Initialize error codes
|
||||
//
|
||||
ParseError = FALSE;
|
||||
ReadError = FALSE;
|
||||
|
||||
//
|
||||
// Initialize our instance counter for the search token
|
||||
//
|
||||
Occurrance = 0;
|
||||
|
||||
if (FindSection (InputFile, Section)) {
|
||||
//
|
||||
// Found the desired section, find and read the desired token
|
||||
//
|
||||
do {
|
||||
//
|
||||
// Read a line from the file
|
||||
//
|
||||
if (ReadLine (InputFile, InputBuffer, _MAX_PATH) == NULL) {
|
||||
//
|
||||
// Error reading from input file
|
||||
//
|
||||
ReadError = TRUE;
|
||||
break;
|
||||
}
|
||||
//
|
||||
// Get the first non-whitespace string
|
||||
//
|
||||
CurrentToken = strtok (InputBuffer, " \t\n");
|
||||
if (CurrentToken == NULL) {
|
||||
//
|
||||
// Whitespace line found (or comment) so continue
|
||||
//
|
||||
CurrentToken = InputBuffer;
|
||||
continue;
|
||||
}
|
||||
//
|
||||
// Make sure we have not reached the end of the current section
|
||||
//
|
||||
if (CurrentToken[0] == '[') {
|
||||
break;
|
||||
}
|
||||
//
|
||||
// Compare the current token with the desired token
|
||||
//
|
||||
if (strcmp (CurrentToken, Token) == 0) {
|
||||
//
|
||||
// Found it
|
||||
//
|
||||
//
|
||||
// Check if it is the correct instance
|
||||
//
|
||||
if (Instance == Occurrance) {
|
||||
//
|
||||
// Copy the contents following the =
|
||||
//
|
||||
CurrentToken = strtok (NULL, "= \t\n");
|
||||
if (CurrentToken == NULL) {
|
||||
//
|
||||
// Nothing found, parsing error
|
||||
//
|
||||
ParseError = TRUE;
|
||||
} else {
|
||||
//
|
||||
// Copy the current token to the output value
|
||||
//
|
||||
strcpy (Value, CurrentToken);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
} else {
|
||||
//
|
||||
// Increment the occurrance found
|
||||
//
|
||||
Occurrance++;
|
||||
}
|
||||
}
|
||||
} while (
|
||||
!ParseError &&
|
||||
!ReadError &&
|
||||
InputFile->CurrentFilePointer < InputFile->Eof &&
|
||||
CurrentToken[0] != '[' &&
|
||||
Occurrance <= Instance
|
||||
);
|
||||
}
|
||||
//
|
||||
// Distinguish between read errors and INF file format errors.
|
||||
//
|
||||
if (ReadError) {
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
|
||||
if (ParseError) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
StringToGuid (
|
||||
IN CHAR8 *AsciiGuidBuffer,
|
||||
OUT EFI_GUID *GuidBuffer
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a string to an EFI_GUID. The string must be in the
|
||||
xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format.
|
||||
|
||||
Arguments:
|
||||
|
||||
AsciiGuidBuffer - pointer to ascii string
|
||||
GuidBuffer - pointer to destination Guid
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_ABORTED Could not convert the string
|
||||
EFI_SUCCESS The string was successfully converted
|
||||
EFI_INVALID_PARAMETER Input parameter is invalid.
|
||||
|
||||
--*/
|
||||
{
|
||||
INT32 Index;
|
||||
UINTN Data1;
|
||||
UINTN Data2;
|
||||
UINTN Data3;
|
||||
UINTN Data4[8];
|
||||
|
||||
if (AsciiGuidBuffer == NULL || GuidBuffer == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Scan the guid string into the buffer
|
||||
//
|
||||
Index = sscanf (
|
||||
AsciiGuidBuffer,
|
||||
"%08x-%04x-%04x-%02x%02x-%02hx%02hx%02hx%02hx%02hx%02hx",
|
||||
&Data1,
|
||||
&Data2,
|
||||
&Data3,
|
||||
&Data4[0],
|
||||
&Data4[1],
|
||||
&Data4[2],
|
||||
&Data4[3],
|
||||
&Data4[4],
|
||||
&Data4[5],
|
||||
&Data4[6],
|
||||
&Data4[7]
|
||||
);
|
||||
|
||||
//
|
||||
// Verify the correct number of items were scanned.
|
||||
//
|
||||
if (Index != 11) {
|
||||
printf ("ERROR: Malformed GUID \"%s\".\n\n", AsciiGuidBuffer);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Copy the data into our GUID.
|
||||
//
|
||||
GuidBuffer->Data1 = (UINT32) Data1;
|
||||
GuidBuffer->Data2 = (UINT16) Data2;
|
||||
GuidBuffer->Data3 = (UINT16) Data3;
|
||||
GuidBuffer->Data4[0] = (UINT8) Data4[0];
|
||||
GuidBuffer->Data4[1] = (UINT8) Data4[1];
|
||||
GuidBuffer->Data4[2] = (UINT8) Data4[2];
|
||||
GuidBuffer->Data4[3] = (UINT8) Data4[3];
|
||||
GuidBuffer->Data4[4] = (UINT8) Data4[4];
|
||||
GuidBuffer->Data4[5] = (UINT8) Data4[5];
|
||||
GuidBuffer->Data4[6] = (UINT8) Data4[6];
|
||||
GuidBuffer->Data4[7] = (UINT8) Data4[7];
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AsciiStringToUint64 (
|
||||
IN CONST CHAR8 *AsciiString,
|
||||
IN BOOLEAN IsHex,
|
||||
OUT UINT64 *ReturnValue
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a null terminated ascii string that represents a number into a
|
||||
UINT64 value. A hex number may be preceeded by a 0x, but may not be
|
||||
succeeded by an h. A number without 0x or 0X is considered to be base 10
|
||||
unless the IsHex input is true.
|
||||
|
||||
Arguments:
|
||||
|
||||
AsciiString The string to convert.
|
||||
IsHex Force the string to be treated as a hex number.
|
||||
ReturnValue The return value.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Number successfully converted.
|
||||
EFI_ABORTED Invalid character encountered.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 Index;
|
||||
UINT64 HexNumber;
|
||||
CHAR8 CurrentChar;
|
||||
|
||||
//
|
||||
// Initialize the result
|
||||
//
|
||||
HexNumber = 0;
|
||||
|
||||
//
|
||||
// Add each character to the result
|
||||
//
|
||||
if (IsHex || (AsciiString[0] == '0' && (AsciiString[1] == 'x' || AsciiString[1] == 'X'))) {
|
||||
//
|
||||
// Verify string is a hex number
|
||||
//
|
||||
for (Index = 2; Index < strlen (AsciiString); Index++) {
|
||||
if (isxdigit (AsciiString[Index]) == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Convert the hex string.
|
||||
//
|
||||
for (Index = 2; AsciiString[Index] != '\0'; Index++) {
|
||||
CurrentChar = AsciiString[Index];
|
||||
HexNumber *= 16;
|
||||
if (CurrentChar >= '0' && CurrentChar <= '9') {
|
||||
HexNumber += CurrentChar - '0';
|
||||
} else if (CurrentChar >= 'a' && CurrentChar <= 'f') {
|
||||
HexNumber += CurrentChar - 'a' + 10;
|
||||
} else if (CurrentChar >= 'A' && CurrentChar <= 'F') {
|
||||
HexNumber += CurrentChar - 'A' + 10;
|
||||
} else {
|
||||
//
|
||||
// Unrecognized character
|
||||
//
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
*ReturnValue = HexNumber;
|
||||
} else {
|
||||
//
|
||||
// Verify string is a number
|
||||
//
|
||||
for (Index = 0; Index < strlen (AsciiString); Index++) {
|
||||
if (isdigit (AsciiString[Index]) == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
*ReturnValue = atol (AsciiString);
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
};
|
||||
|
||||
CHAR8 *
|
||||
ReadLineInStream (
|
||||
IN FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
// BUGBUG: This is obsolete once genmake goes away...
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *CharPtr;
|
||||
|
||||
//
|
||||
// Verify input parameters are not null
|
||||
//
|
||||
assert (InputFile);
|
||||
assert (InputBuffer);
|
||||
|
||||
//
|
||||
// Read a line
|
||||
//
|
||||
if (fgets (InputBuffer, _MAX_PATH, InputFile) == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
//
|
||||
// Strip any comments
|
||||
//
|
||||
CharPtr = strstr (InputBuffer, "//");
|
||||
if (CharPtr != 0) {
|
||||
CharPtr[0] = 0;
|
||||
}
|
||||
|
||||
CharPtr = strstr (InputBuffer, "#");
|
||||
if (CharPtr != 0) {
|
||||
CharPtr[0] = 0;
|
||||
}
|
||||
//
|
||||
// Return the string
|
||||
//
|
||||
return InputBuffer;
|
||||
}
|
||||
|
||||
BOOLEAN
|
||||
FindSectionInStream (
|
||||
IN FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a stream file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
// BUGBUG: This is obsolete once genmake goes away...
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 InputBuffer[_MAX_PATH];
|
||||
CHAR8 *CurrentToken;
|
||||
|
||||
//
|
||||
// Verify input is not NULL
|
||||
//
|
||||
assert (InputFile);
|
||||
assert (Section);
|
||||
|
||||
//
|
||||
// Rewind to beginning of file
|
||||
//
|
||||
if (fseek (InputFile, 0, SEEK_SET) != 0) {
|
||||
return FALSE;
|
||||
}
|
||||
//
|
||||
// Read lines until the section is found
|
||||
//
|
||||
while (feof (InputFile) == 0) {
|
||||
//
|
||||
// Read a line
|
||||
//
|
||||
ReadLineInStream (InputFile, InputBuffer);
|
||||
|
||||
//
|
||||
// Check if the section is found
|
||||
//
|
||||
CurrentToken = strstr (InputBuffer, Section);
|
||||
if (CurrentToken != NULL) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
235
Tools/Source/TianoTools/Common/ParseInf.h
Normal file
235
Tools/Source/TianoTools/Common/ParseInf.h
Normal file
@@ -0,0 +1,235 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
ParseInf.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for helper functions useful for parsing INF files.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_PARSE_INF_H
|
||||
#define _EFI_PARSE_INF_H
|
||||
|
||||
/* #include "TianoCommon.h" */
|
||||
#include <Base.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
//
|
||||
// Common data structures
|
||||
//
|
||||
typedef struct {
|
||||
CHAR8 *FileImage;
|
||||
CHAR8 *Eof;
|
||||
CHAR8 *CurrentFilePointer;
|
||||
} MEMORY_FILE;
|
||||
|
||||
//
|
||||
// Functions declarations
|
||||
//
|
||||
CHAR8 *
|
||||
ReadLine (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer,
|
||||
IN UINT32 MaxLength
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
The function reads a string from the input stream argument and stores it in
|
||||
the input string. ReadLine reads characters from the current file position
|
||||
to and including the first newline character, to the end of the stream, or
|
||||
until the number of characters read is equal to MaxLength - 1, whichever
|
||||
comes first. The newline character, if read, is replaced with a \0.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
MaxLength The maximum size of the input buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
BOOLEAN
|
||||
FindSection (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
FindToken (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section,
|
||||
IN CHAR8 *Token,
|
||||
IN UINTN Instance,
|
||||
OUT CHAR8 *Value
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Finds a token value given the section and token to search for.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section The section to search for, a string within [].
|
||||
Token The token to search for, e.g. EFI_PEIM_RECOVERY, followed by an = in the INF file.
|
||||
Instance The instance of the token to search for. Zero is the first instance.
|
||||
Value The string that holds the value following the =. Must be _MAX_PATH in size.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Value found.
|
||||
EFI_ABORTED Format error detected in INF file.
|
||||
EFI_INVALID_PARAMETER Input argument was null.
|
||||
EFI_LOAD_ERROR Error reading from the file.
|
||||
EFI_NOT_FOUND Section/Token/Value not found.
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
StringToGuid (
|
||||
IN CHAR8 *AsciiGuidBuffer,
|
||||
OUT EFI_GUID *GuidBuffer
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a string to an EFI_GUID. The string must be in the
|
||||
xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format.
|
||||
|
||||
Arguments:
|
||||
|
||||
GuidBuffer - pointer to destination Guid
|
||||
AsciiGuidBuffer - pointer to ascii string
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_ABORTED Could not convert the string
|
||||
EFI_SUCCESS The string was successfully converted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
AsciiStringToUint64 (
|
||||
IN CONST CHAR8 *AsciiString,
|
||||
IN BOOLEAN IsHex,
|
||||
OUT UINT64 *ReturnValue
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a null terminated ascii string that represents a number into a
|
||||
UINT64 value. A hex number may be preceeded by a 0x, but may not be
|
||||
succeeded by an h. A number without 0x or 0X is considered to be base 10
|
||||
unless the IsHex input is true.
|
||||
|
||||
Arguments:
|
||||
|
||||
AsciiString The string to convert.
|
||||
IsHex Force the string to be treated as a hex number.
|
||||
ReturnValue The return value.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Number successfully converted.
|
||||
EFI_ABORTED Invalid character encountered.
|
||||
|
||||
--*/
|
||||
CHAR8 *
|
||||
ReadLineInStream (
|
||||
IN FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
BOOLEAN
|
||||
FindSectionInStream (
|
||||
IN FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a stream file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
#endif
|
131
Tools/Source/TianoTools/Common/PeiLib/Debug.c
Normal file
131
Tools/Source/TianoTools/Common/PeiLib/Debug.c
Normal file
@@ -0,0 +1,131 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004 - 2005, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Debug.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Support for Debug primatives.
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "Pei.h"
|
||||
#include "EfiPrintLib.h"
|
||||
#include "EfiStatusCode.h"
|
||||
#include "EfiCommonLib.h"
|
||||
#include EFI_GUID_DEFINITION (StatusCodeCallerId)
|
||||
#include EFI_GUID_DEFINITION (StatusCodeDataTypeId)
|
||||
|
||||
VOID
|
||||
PeiDebugAssert (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN CHAR8 *FileName,
|
||||
IN INTN LineNumber,
|
||||
IN CHAR8 *Description
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Worker function for ASSERT(). If Error Logging hub is loaded log ASSERT
|
||||
information. If Error Logging hub is not loaded DEADLOOP ().
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
FileName - File name of failing routine.
|
||||
|
||||
LineNumber - Line number of failing ASSERT().
|
||||
|
||||
Description - Description, usually the assertion,
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT64 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE];
|
||||
|
||||
EfiDebugAssertWorker (FileName, LineNumber, Description, sizeof (Buffer), Buffer);
|
||||
|
||||
//
|
||||
// We choose NOT to use PEI_REPORT_STATUS_CODE here, because when debug is enable,
|
||||
// we want get enough information if assert.
|
||||
//
|
||||
(**PeiServices).PeiReportStatusCode (
|
||||
PeiServices,
|
||||
(EFI_ERROR_CODE | EFI_ERROR_UNRECOVERED),
|
||||
(EFI_SOFTWARE_PEI_MODULE | EFI_SW_EC_ILLEGAL_SOFTWARE_STATE),
|
||||
0,
|
||||
&gEfiCallerIdGuid,
|
||||
(EFI_STATUS_CODE_DATA *) Buffer
|
||||
);
|
||||
|
||||
EFI_DEADLOOP ();
|
||||
}
|
||||
|
||||
|
||||
VOID
|
||||
PeiDebugPrint (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN UINTN ErrorLevel,
|
||||
IN CHAR8 *Format,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Worker function for DEBUG(). If Error Logging hub is loaded log ASSERT
|
||||
information. If Error Logging hub is not loaded do nothing.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
ErrorLevel - If error level is set do the debug print.
|
||||
|
||||
Format - String to use for the print, followed by Print arguments.
|
||||
|
||||
... - Print arguments
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
VA_LIST Marker;
|
||||
UINT64 Buffer[EFI_STATUS_CODE_DATA_MAX_SIZE];
|
||||
|
||||
VA_START (Marker, Format);
|
||||
EfiDebugVPrintWorker (ErrorLevel, Format, Marker, sizeof (Buffer), Buffer);
|
||||
|
||||
//
|
||||
// We choose NOT to use PEI_REPORT_STATUS_CODE here, because when debug is enable,
|
||||
// we want get enough information if assert.
|
||||
//
|
||||
(**PeiServices).PeiReportStatusCode (
|
||||
PeiServices,
|
||||
EFI_DEBUG_CODE,
|
||||
(EFI_SOFTWARE_PEI_MODULE | EFI_DC_UNSPECIFIED),
|
||||
0,
|
||||
&gEfiCallerIdGuid,
|
||||
(EFI_STATUS_CODE_DATA *) Buffer
|
||||
);
|
||||
|
||||
return ;
|
||||
}
|
1104
Tools/Source/TianoTools/Common/PeiLib/Decompress.c
Normal file
1104
Tools/Source/TianoTools/Common/PeiLib/Decompress.c
Normal file
File diff suppressed because it is too large
Load Diff
495
Tools/Source/TianoTools/Common/PeiLib/Hob/Hob.c
Normal file
495
Tools/Source/TianoTools/Common/PeiLib/Hob/Hob.c
Normal file
@@ -0,0 +1,495 @@
|
||||
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
hob.c
|
||||
|
||||
Abstract:
|
||||
|
||||
PEI Library Functions
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "Pei.h"
|
||||
#include "peilib.h"
|
||||
#include EFI_GUID_DEFINITION (MemoryAllocationHob)
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobModule (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_GUID *ModuleName,
|
||||
IN EFI_PHYSICAL_ADDRESS MemoryAllocationModule,
|
||||
IN UINT64 ModuleLength,
|
||||
IN EFI_PHYSICAL_ADDRESS EntryPoint
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for a loaded PE32 module
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
ModuleName - The GUID File Name of the module
|
||||
MemoryAllocationModule - The 64 bit physical address of the module
|
||||
ModuleLength - The length of the module in bytes
|
||||
EntryPoint - The 64 bit physical address of the entry point
|
||||
to the module
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_MEMORY_ALLOCATION_MODULE *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_GUID_EXTENSION,
|
||||
sizeof (EFI_HOB_MEMORY_ALLOCATION_MODULE),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob->MemoryAllocationHeader.Name = gEfiHobMemeryAllocModuleGuid;
|
||||
Hob->MemoryAllocationHeader.MemoryBaseAddress = MemoryAllocationModule;
|
||||
Hob->MemoryAllocationHeader.MemoryLength = ModuleLength;
|
||||
Hob->MemoryAllocationHeader.MemoryType = EfiBootServicesCode;
|
||||
|
||||
Hob->ModuleName = *ModuleName;
|
||||
Hob->EntryPoint = EntryPoint;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobResourceDescriptor (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_RESOURCE_TYPE ResourceType,
|
||||
IN EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute,
|
||||
IN EFI_PHYSICAL_ADDRESS PhysicalStart,
|
||||
IN UINT64 NumberOfBytes
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB that describes a chunck of system memory
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
ResourceType - The type of resource described by this HOB
|
||||
|
||||
ResourceAttribute - The resource attributes of the memory described by this HOB
|
||||
|
||||
PhysicalStart - The 64 bit physical address of memory described by this HOB
|
||||
|
||||
NumberOfBytes - The length of the memoty described by this HOB in bytes
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_RESOURCE_DESCRIPTOR *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_RESOURCE_DESCRIPTOR,
|
||||
sizeof (EFI_HOB_RESOURCE_DESCRIPTOR),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob->ResourceType = ResourceType;
|
||||
Hob->ResourceAttribute = ResourceAttribute;
|
||||
Hob->PhysicalStart = PhysicalStart;
|
||||
Hob->ResourceLength = NumberOfBytes;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobGuid (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_GUID *Guid,
|
||||
IN UINTN DataLength,
|
||||
IN OUT VOID **Hob
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a custom HOB that is tagged with a GUID for identification
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
Guid - The GUID of the custome HOB type
|
||||
|
||||
DataLength - The size of the data payload for the GUIDed HOB
|
||||
|
||||
Hob - Pointer to the Hob
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_GUID_EXTENSION,
|
||||
(UINT16) (sizeof (EFI_HOB_GUID_TYPE) + DataLength),
|
||||
Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
((EFI_HOB_GUID_TYPE *)(*Hob))->Name = *Guid;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobGuidData (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_GUID *Guid,
|
||||
IN VOID *Data,
|
||||
IN UINTN DataLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a custom HOB that is tagged with a GUID for identification
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
Guid - The GUID of the custome HOB type
|
||||
|
||||
Data - The data to be copied into the GUIDed HOB data field.
|
||||
|
||||
DataLength - The data field length.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
EFI_HOB_GUID_TYPE *Hob;
|
||||
|
||||
Status = PeiBuildHobGuid (
|
||||
PeiServices,
|
||||
Guid,
|
||||
DataLength,
|
||||
&Hob
|
||||
);
|
||||
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob++;
|
||||
(*PeiServices)->CopyMem (Hob, Data, DataLength);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobFv (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a Firmware Volume HOB
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The base address of the Firmware Volume
|
||||
|
||||
Length - The size of the Firmware Volume in bytes
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_FIRMWARE_VOLUME *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_FV,
|
||||
sizeof (EFI_HOB_FIRMWARE_VOLUME),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob->BaseAddress = BaseAddress;
|
||||
Hob->Length = Length;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobCpu (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN UINT8 SizeOfMemorySpace,
|
||||
IN UINT8 SizeOfIoSpace
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the CPU
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
SizeOfMemorySpace - Identifies the maximum
|
||||
physical memory addressibility of the processor.
|
||||
|
||||
SizeOfIoSpace - Identifies the maximum physical I/O addressibility
|
||||
of the processor.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_CPU *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_CPU,
|
||||
sizeof (EFI_HOB_CPU),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob->SizeOfMemorySpace = SizeOfMemorySpace;
|
||||
Hob->SizeOfIoSpace = SizeOfIoSpace;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobStack (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the Stack
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The 64 bit physical address of the Stack
|
||||
|
||||
Length - The length of the stack in bytes
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_MEMORY_ALLOCATION_STACK *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_MEMORY_ALLOCATION,
|
||||
sizeof (EFI_HOB_MEMORY_ALLOCATION_STACK),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob->AllocDescriptor.Name = gEfiHobMemeryAllocStackGuid;
|
||||
Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
|
||||
Hob->AllocDescriptor.MemoryLength = Length;
|
||||
Hob->AllocDescriptor.MemoryType = EfiConventionalMemory;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobBspStore (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN EFI_MEMORY_TYPE MemoryType
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the bsp store
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The 64 bit physical address of the bsp
|
||||
|
||||
Length - The length of the bsp store in bytes
|
||||
|
||||
MemoryType - Memory type
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_MEMORY_ALLOCATION_BSP_STORE *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_MEMORY_ALLOCATION,
|
||||
sizeof (EFI_HOB_MEMORY_ALLOCATION_BSP_STORE),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
Hob->AllocDescriptor.Name = gEfiHobMemeryAllocBspStoreGuid;
|
||||
Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
|
||||
Hob->AllocDescriptor.MemoryLength = Length;
|
||||
Hob->AllocDescriptor.MemoryType = MemoryType;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobMemoryAllocation (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN EFI_GUID *Name,
|
||||
IN EFI_MEMORY_TYPE MemoryType
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the memory allocation.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The 64 bit physical address of the memory
|
||||
|
||||
Length - The length of the memory allocation in bytes
|
||||
|
||||
Name - Name for Hob
|
||||
|
||||
MemoryType - Memory type
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_MEMORY_ALLOCATION *Hob;
|
||||
|
||||
Status = (*PeiServices)->CreateHob (
|
||||
PeiServices,
|
||||
EFI_HOB_TYPE_MEMORY_ALLOCATION,
|
||||
sizeof (EFI_HOB_MEMORY_ALLOCATION),
|
||||
&Hob
|
||||
);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return Status;
|
||||
}
|
||||
|
||||
if (Name != NULL) {
|
||||
Hob->AllocDescriptor.Name = *Name;
|
||||
} else {
|
||||
(*PeiServices)->SetMem(&(Hob->AllocDescriptor.Name), sizeof (EFI_GUID), 0);
|
||||
}
|
||||
|
||||
Hob->AllocDescriptor.MemoryBaseAddress = BaseAddress;
|
||||
Hob->AllocDescriptor.MemoryLength = Length;
|
||||
Hob->AllocDescriptor.MemoryType = MemoryType;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
244
Tools/Source/TianoTools/Common/PeiLib/Ipf/PeCoffLoaderEx.c
Normal file
244
Tools/Source/TianoTools/Common/PeiLib/Ipf/PeCoffLoaderEx.c
Normal file
@@ -0,0 +1,244 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PeCoffLoaderEx.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Fixes Intel Itanium(TM) specific relocation types
|
||||
|
||||
|
||||
Revision History
|
||||
|
||||
--*/
|
||||
|
||||
#include "TianoCommon.h"
|
||||
#include "EfiImage.h"
|
||||
|
||||
#define EXT_IMM64(Value, Address, Size, InstPos, ValPos) \
|
||||
Value |= (((UINT64)((*(Address) >> InstPos) & (((UINT64)1 << Size) - 1))) << ValPos)
|
||||
|
||||
#define INS_IMM64(Value, Address, Size, InstPos, ValPos) \
|
||||
*(UINT32*)Address = (*(UINT32*)Address & ~(((1 << Size) - 1) << InstPos)) | \
|
||||
((UINT32)((((UINT64)Value >> ValPos) & (((UINT64)1 << Size) - 1))) << InstPos)
|
||||
|
||||
#define IMM64_IMM7B_INST_WORD_X 3
|
||||
#define IMM64_IMM7B_SIZE_X 7
|
||||
#define IMM64_IMM7B_INST_WORD_POS_X 4
|
||||
#define IMM64_IMM7B_VAL_POS_X 0
|
||||
|
||||
#define IMM64_IMM9D_INST_WORD_X 3
|
||||
#define IMM64_IMM9D_SIZE_X 9
|
||||
#define IMM64_IMM9D_INST_WORD_POS_X 18
|
||||
#define IMM64_IMM9D_VAL_POS_X 7
|
||||
|
||||
#define IMM64_IMM5C_INST_WORD_X 3
|
||||
#define IMM64_IMM5C_SIZE_X 5
|
||||
#define IMM64_IMM5C_INST_WORD_POS_X 13
|
||||
#define IMM64_IMM5C_VAL_POS_X 16
|
||||
|
||||
#define IMM64_IC_INST_WORD_X 3
|
||||
#define IMM64_IC_SIZE_X 1
|
||||
#define IMM64_IC_INST_WORD_POS_X 12
|
||||
#define IMM64_IC_VAL_POS_X 21
|
||||
|
||||
#define IMM64_IMM41a_INST_WORD_X 1
|
||||
#define IMM64_IMM41a_SIZE_X 10
|
||||
#define IMM64_IMM41a_INST_WORD_POS_X 14
|
||||
#define IMM64_IMM41a_VAL_POS_X 22
|
||||
|
||||
#define IMM64_IMM41b_INST_WORD_X 1
|
||||
#define IMM64_IMM41b_SIZE_X 8
|
||||
#define IMM64_IMM41b_INST_WORD_POS_X 24
|
||||
#define IMM64_IMM41b_VAL_POS_X 32
|
||||
|
||||
#define IMM64_IMM41c_INST_WORD_X 2
|
||||
#define IMM64_IMM41c_SIZE_X 23
|
||||
#define IMM64_IMM41c_INST_WORD_POS_X 0
|
||||
#define IMM64_IMM41c_VAL_POS_X 40
|
||||
|
||||
#define IMM64_SIGN_INST_WORD_X 3
|
||||
#define IMM64_SIGN_SIZE_X 1
|
||||
#define IMM64_SIGN_INST_WORD_POS_X 27
|
||||
#define IMM64_SIGN_VAL_POS_X 63
|
||||
|
||||
EFI_STATUS
|
||||
PeCoffLoaderRelocateImageEx (
|
||||
IN UINT16 *Reloc,
|
||||
IN OUT CHAR8 *Fixup,
|
||||
IN OUT CHAR8 **FixupData,
|
||||
IN UINT64 Adjust
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Performs an Itanium-based specific relocation fixup
|
||||
|
||||
Arguments:
|
||||
|
||||
Reloc - Pointer to the relocation record
|
||||
|
||||
Fixup - Pointer to the address to fix up
|
||||
|
||||
FixupData - Pointer to a buffer to log the fixups
|
||||
|
||||
Adjust - The offset to adjust the fixup
|
||||
|
||||
Returns:
|
||||
|
||||
Status code
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT64 *F64;
|
||||
UINT64 FixupVal;
|
||||
|
||||
switch ((*Reloc) >> 12) {
|
||||
|
||||
case EFI_IMAGE_REL_BASED_DIR64:
|
||||
F64 = (UINT64 *) Fixup;
|
||||
*F64 = *F64 + (UINT64) Adjust;
|
||||
if (*FixupData != NULL) {
|
||||
*FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));
|
||||
*(UINT64 *)(*FixupData) = *F64;
|
||||
*FixupData = *FixupData + sizeof(UINT64);
|
||||
}
|
||||
break;
|
||||
|
||||
case EFI_IMAGE_REL_BASED_IA64_IMM64:
|
||||
|
||||
//
|
||||
// Align it to bundle address before fixing up the
|
||||
// 64-bit immediate value of the movl instruction.
|
||||
//
|
||||
|
||||
Fixup = (CHAR8 *)((UINTN) Fixup & (UINTN) ~(15));
|
||||
FixupVal = (UINT64)0;
|
||||
|
||||
//
|
||||
// Extract the lower 32 bits of IMM64 from bundle
|
||||
//
|
||||
EXT_IMM64(FixupVal,
|
||||
(UINT32 *)Fixup + IMM64_IMM7B_INST_WORD_X,
|
||||
IMM64_IMM7B_SIZE_X,
|
||||
IMM64_IMM7B_INST_WORD_POS_X,
|
||||
IMM64_IMM7B_VAL_POS_X
|
||||
);
|
||||
|
||||
EXT_IMM64(FixupVal,
|
||||
(UINT32 *)Fixup + IMM64_IMM9D_INST_WORD_X,
|
||||
IMM64_IMM9D_SIZE_X,
|
||||
IMM64_IMM9D_INST_WORD_POS_X,
|
||||
IMM64_IMM9D_VAL_POS_X
|
||||
);
|
||||
|
||||
EXT_IMM64(FixupVal,
|
||||
(UINT32 *)Fixup + IMM64_IMM5C_INST_WORD_X,
|
||||
IMM64_IMM5C_SIZE_X,
|
||||
IMM64_IMM5C_INST_WORD_POS_X,
|
||||
IMM64_IMM5C_VAL_POS_X
|
||||
);
|
||||
|
||||
EXT_IMM64(FixupVal,
|
||||
(UINT32 *)Fixup + IMM64_IC_INST_WORD_X,
|
||||
IMM64_IC_SIZE_X,
|
||||
IMM64_IC_INST_WORD_POS_X,
|
||||
IMM64_IC_VAL_POS_X
|
||||
);
|
||||
|
||||
EXT_IMM64(FixupVal,
|
||||
(UINT32 *)Fixup + IMM64_IMM41a_INST_WORD_X,
|
||||
IMM64_IMM41a_SIZE_X,
|
||||
IMM64_IMM41a_INST_WORD_POS_X,
|
||||
IMM64_IMM41a_VAL_POS_X
|
||||
);
|
||||
|
||||
//
|
||||
// Update 64-bit address
|
||||
//
|
||||
FixupVal += Adjust;
|
||||
|
||||
//
|
||||
// Insert IMM64 into bundle
|
||||
//
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IMM7B_INST_WORD_X),
|
||||
IMM64_IMM7B_SIZE_X,
|
||||
IMM64_IMM7B_INST_WORD_POS_X,
|
||||
IMM64_IMM7B_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IMM9D_INST_WORD_X),
|
||||
IMM64_IMM9D_SIZE_X,
|
||||
IMM64_IMM9D_INST_WORD_POS_X,
|
||||
IMM64_IMM9D_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IMM5C_INST_WORD_X),
|
||||
IMM64_IMM5C_SIZE_X,
|
||||
IMM64_IMM5C_INST_WORD_POS_X,
|
||||
IMM64_IMM5C_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IC_INST_WORD_X),
|
||||
IMM64_IC_SIZE_X,
|
||||
IMM64_IC_INST_WORD_POS_X,
|
||||
IMM64_IC_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IMM41a_INST_WORD_X),
|
||||
IMM64_IMM41a_SIZE_X,
|
||||
IMM64_IMM41a_INST_WORD_POS_X,
|
||||
IMM64_IMM41a_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IMM41b_INST_WORD_X),
|
||||
IMM64_IMM41b_SIZE_X,
|
||||
IMM64_IMM41b_INST_WORD_POS_X,
|
||||
IMM64_IMM41b_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_IMM41c_INST_WORD_X),
|
||||
IMM64_IMM41c_SIZE_X,
|
||||
IMM64_IMM41c_INST_WORD_POS_X,
|
||||
IMM64_IMM41c_VAL_POS_X
|
||||
);
|
||||
|
||||
INS_IMM64(FixupVal,
|
||||
((UINT32 *)Fixup + IMM64_SIGN_INST_WORD_X),
|
||||
IMM64_SIGN_SIZE_X,
|
||||
IMM64_SIGN_INST_WORD_POS_X,
|
||||
IMM64_SIGN_VAL_POS_X
|
||||
);
|
||||
|
||||
F64 = (UINT64 *) Fixup;
|
||||
if (*FixupData != NULL) {
|
||||
*FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64));
|
||||
*(UINT64 *)(*FixupData) = *F64;
|
||||
*FixupData = *FixupData + sizeof(UINT64);
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
67
Tools/Source/TianoTools/Common/PeiLib/Ipf/PeCoffLoaderEx.h
Normal file
67
Tools/Source/TianoTools/Common/PeiLib/Ipf/PeCoffLoaderEx.h
Normal file
@@ -0,0 +1,67 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PeCoffLoaderEx.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Fixes Intel Itanium(TM) specific relocation types
|
||||
|
||||
|
||||
Revision History
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _PE_COFF_LOADER_EX_H_
|
||||
#define _PE_COFF_LOADER_EX_H_
|
||||
|
||||
//
|
||||
// Define macro to determine if the machine type is supported.
|
||||
// Returns 0 if the machine is not supported, Not 0 otherwise.
|
||||
//
|
||||
#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
|
||||
((Machine) == EFI_IMAGE_MACHINE_IA64 || \
|
||||
(Machine) == EFI_IMAGE_MACHINE_EBC)
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
PeCoffLoaderRelocateImageEx (
|
||||
IN UINT16 *Reloc,
|
||||
IN OUT CHAR8 *Fixup,
|
||||
IN OUT CHAR8 **FixupData,
|
||||
IN UINT64 Adjust
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Performs an Itanium-based specific relocation fixup
|
||||
|
||||
Arguments:
|
||||
|
||||
Reloc - Pointer to the relocation record
|
||||
|
||||
Fixup - Pointer to the address to fix up
|
||||
|
||||
FixupData - Pointer to a buffer to log the fixups
|
||||
|
||||
Adjust - The offset to adjust the fixup
|
||||
|
||||
Returns:
|
||||
|
||||
Status code
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#endif
|
@@ -0,0 +1,61 @@
|
||||
//++
|
||||
// Copyright (c) 2004, Intel Corporation
|
||||
// All rights reserved. This program and the accompanying materials
|
||||
// are licensed and made available under the terms and conditions of the BSD License
|
||||
// which accompanies this distribution. The full text of the license may be found at
|
||||
// http://opensource.org/licenses/bsd-license.php
|
||||
//
|
||||
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
//
|
||||
// Module Name:
|
||||
//
|
||||
// PerformancePrimitives.s
|
||||
//
|
||||
// Abstract:
|
||||
//
|
||||
//
|
||||
// Revision History:
|
||||
//
|
||||
//--
|
||||
|
||||
.file "PerformancePrimitives.s"
|
||||
|
||||
#include "IpfMacro.i"
|
||||
|
||||
//-----------------------------------------------------------------------------
|
||||
//++
|
||||
// GetTimerValue
|
||||
//
|
||||
// Implementation of CPU-based time service
|
||||
//
|
||||
// On Entry :
|
||||
// EFI_STATUS
|
||||
// GetTimerValue (
|
||||
// OUT UINT64 *TimerValue
|
||||
// )
|
||||
//
|
||||
// Return Value:
|
||||
// r8 = Status
|
||||
// r9 = 0
|
||||
// r10 = 0
|
||||
// r11 = 0
|
||||
//
|
||||
// As per static calling conventions.
|
||||
//
|
||||
//--
|
||||
//---------------------------------------------------------------------------
|
||||
PROCEDURE_ENTRY (GetTimerValue)
|
||||
|
||||
NESTED_SETUP (1,8,0,0)
|
||||
mov r8 = ar.itc;;
|
||||
st8 [r32]= r8
|
||||
mov r8 = r0
|
||||
mov r9 = r0
|
||||
mov r10 = r0
|
||||
mov r11 = r0
|
||||
NESTED_RETURN
|
||||
|
||||
PROCEDURE_EXIT (GetTimerValue)
|
||||
//---------------------------------------------------------------------------
|
||||
|
122
Tools/Source/TianoTools/Common/PeiLib/Ipf/SwitchStack.s
Normal file
122
Tools/Source/TianoTools/Common/PeiLib/Ipf/SwitchStack.s
Normal file
@@ -0,0 +1,122 @@
|
||||
//++
|
||||
// Copyright (c) 2004, Intel Corporation
|
||||
// All rights reserved. This program and the accompanying materials
|
||||
// are licensed and made available under the terms and conditions of the BSD License
|
||||
// which accompanies this distribution. The full text of the license may be found at
|
||||
// http://opensource.org/licenses/bsd-license.php
|
||||
//
|
||||
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
//
|
||||
// Module Name:
|
||||
//
|
||||
// SwitchStack.s
|
||||
//
|
||||
// Abstract:
|
||||
//
|
||||
// Contains an implementation of a stack switch for the Itanium-based architecture.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Revision History:
|
||||
//
|
||||
//--
|
||||
|
||||
.file "SwitchStack.s"
|
||||
|
||||
#include <asm.h>
|
||||
#include <ia_64gen.h>
|
||||
|
||||
// Define hardware RSE Configuration Register
|
||||
//
|
||||
// RS Configuration (RSC) bit field positions
|
||||
|
||||
#define RSC_MODE 0
|
||||
#define RSC_PL 2
|
||||
#define RSC_BE 4
|
||||
// RSC bits 5-15 reserved
|
||||
#define RSC_MBZ0 5
|
||||
#define RSC_MBZ0_V 0x3ff
|
||||
#define RSC_LOADRS 16
|
||||
#define RSC_LOADRS_LEN 14
|
||||
// RSC bits 30-63 reserved
|
||||
#define RSC_MBZ1 30
|
||||
#define RSC_MBZ1_V 0x3ffffffffULL
|
||||
|
||||
// RSC modes
|
||||
// Lazy
|
||||
#define RSC_MODE_LY (0x0)
|
||||
// Store intensive
|
||||
#define RSC_MODE_SI (0x1)
|
||||
// Load intensive
|
||||
#define RSC_MODE_LI (0x2)
|
||||
// Eager
|
||||
#define RSC_MODE_EA (0x3)
|
||||
|
||||
// RSC Endian bit values
|
||||
#define RSC_BE_LITTLE 0
|
||||
#define RSC_BE_BIG 1
|
||||
|
||||
// RSC while in kernel: enabled, little endian, pl = 0, eager mode
|
||||
#define RSC_KERNEL ((RSC_MODE_EA<<RSC_MODE) | (RSC_BE_LITTLE<<RSC_BE))
|
||||
// Lazy RSC in kernel: enabled, little endian, pl = 0, lazy mode
|
||||
#define RSC_KERNEL_LAZ ((RSC_MODE_LY<<RSC_MODE) | (RSC_BE_LITTLE<<RSC_BE))
|
||||
// RSE disabled: disabled, pl = 0, little endian, eager mode
|
||||
#define RSC_KERNEL_DISABLED ((RSC_MODE_LY<<RSC_MODE) | (RSC_BE_LITTLE<<RSC_BE))
|
||||
|
||||
|
||||
//VOID
|
||||
//SwitchStacks (
|
||||
// VOID *ContinuationFunction,
|
||||
// UINTN Parameter,
|
||||
// UINTN NewTopOfStack,
|
||||
// UINTN NewBSPStore OPTIONAL
|
||||
//)
|
||||
///*++
|
||||
//
|
||||
//Input Arguments
|
||||
//
|
||||
// ContinuationFunction - This is a pointer to the PLABEL of the function that should be called once the
|
||||
// new stack has been created.
|
||||
// Parameter - The parameter to pass to the continuation function
|
||||
// NewTopOfStack - This is the new top of the memory stack for ensuing code. This is mandatory and
|
||||
// should be non-zero
|
||||
// NewBSPStore - This is the new BSP store for the ensuing code. It is optional on IA-32 and mandatory on Itanium-based platform.
|
||||
//
|
||||
//--*/
|
||||
|
||||
PROCEDURE_ENTRY(SwitchStacks)
|
||||
|
||||
mov r16 = -0x10;;
|
||||
and r16 = r34, r16;; // get new stack value in R16, 0 the last nibble.
|
||||
mov r15 = r35;; // Get new BspStore into R15
|
||||
mov r13 = r32;; // this is a pointer to the PLABEL of the continuation function.
|
||||
mov r17 = r33;; // this is the parameter to pass to the continuation function
|
||||
|
||||
alloc r11=0,0,0,0 // Set 0-size frame
|
||||
;;
|
||||
flushrs;;
|
||||
|
||||
mov r21 = RSC_KERNEL_DISABLED // for rse disable
|
||||
;;
|
||||
mov ar.rsc = r21 // turn off RSE
|
||||
|
||||
add sp = r0, r16;; // transfer to the EFI stack
|
||||
mov ar.bspstore = r15 // switch to EFI BSP
|
||||
invala // change of ar.bspstore needs invala.
|
||||
|
||||
mov r18 = RSC_KERNEL_LAZ // RSC enabled, Lazy mode
|
||||
;;
|
||||
mov ar.rsc = r18 // turn rse on, in kernel mode
|
||||
;;
|
||||
alloc r11=0,0,1,0;; // alloc 0 outs going to ensuing DXE IPL service
|
||||
mov out0 = r17
|
||||
ld8 r16 = [r13],8;; // r16 = address of continuation function from the PLABEL
|
||||
ld8 gp = [r13] // gp = gp of continuation function from the PLABEL
|
||||
mov b6 = r16
|
||||
;;
|
||||
br.call.sptk.few b0=b6;; // Call the continuation function
|
||||
;;
|
||||
PROCEDURE_EXIT(SwitchStacks)
|
||||
|
||||
|
35
Tools/Source/TianoTools/Common/PeiLib/Ipf/asm.h
Normal file
35
Tools/Source/TianoTools/Common/PeiLib/Ipf/asm.h
Normal file
@@ -0,0 +1,35 @@
|
||||
//
|
||||
//
|
||||
// Copyright (c) 2004, Intel Corporation
|
||||
// All rights reserved. This program and the accompanying materials
|
||||
// are licensed and made available under the terms and conditions of the BSD License
|
||||
// which accompanies this distribution. The full text of the license may be found at
|
||||
// http://opensource.org/licenses/bsd-license.php
|
||||
//
|
||||
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
//
|
||||
// Module Name:
|
||||
//
|
||||
// asm.h
|
||||
//
|
||||
// Abstract:
|
||||
//
|
||||
// This module contains generic macros for an assembly writer.
|
||||
//
|
||||
//
|
||||
// Revision History
|
||||
//
|
||||
#ifndef _ASM_H
|
||||
#define _ASM_H
|
||||
|
||||
#define TRUE 1
|
||||
#define FALSE 0
|
||||
#define PROCEDURE_ENTRY(name) .##text; \
|
||||
.##type name, @function; \
|
||||
.##proc name; \
|
||||
name::
|
||||
|
||||
#define PROCEDURE_EXIT(name) .##endp name
|
||||
|
||||
#endif // _ASM_H
|
112
Tools/Source/TianoTools/Common/PeiLib/Ipf/efijump.h
Normal file
112
Tools/Source/TianoTools/Common/PeiLib/Ipf/efijump.h
Normal file
@@ -0,0 +1,112 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiJump.h
|
||||
|
||||
Abstract:
|
||||
|
||||
This is the Setjump/Longjump pair for an IA32 processor.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_JUMP_H_
|
||||
#define _EFI_JUMP_H_
|
||||
|
||||
#include EFI_GUID_DEFINITION (PeiTransferControl)
|
||||
|
||||
//
|
||||
// NOTE:Set/LongJump needs to have this buffer start
|
||||
// at 16 byte boundary. Either fix the structure
|
||||
// which call this buffer or fix inside SetJump/LongJump
|
||||
// Choosing 1K buffer storage for now
|
||||
//
|
||||
typedef struct {
|
||||
CHAR8 Buffer[1024];
|
||||
} EFI_JUMP_BUFFER;
|
||||
|
||||
EFI_STATUS
|
||||
SetJump (
|
||||
IN EFI_PEI_TRANSFER_CONTROL_PROTOCOL *This,
|
||||
IN EFI_JUMP_BUFFER *Jump
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
SetJump stores the current register set in the area pointed to
|
||||
by "save". It returns zero. Subsequent calls to "LongJump" will
|
||||
restore the registers and return non-zero to the same location.
|
||||
On entry, r32 contains the pointer to the jmp_buffer
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Calling context
|
||||
Jump - Jump buffer
|
||||
|
||||
Returns:
|
||||
|
||||
Status code
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
LongJump (
|
||||
IN EFI_PEI_TRANSFER_CONTROL_PROTOCOL *This,
|
||||
IN EFI_JUMP_BUFFER *Jump
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
LongJump initializes the register set to the values saved by a
|
||||
previous 'SetJump' and jumps to the return location saved by that
|
||||
'SetJump'. This has the effect of unwinding the stack and returning
|
||||
for a second time to the 'SetJump'.
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Calling context
|
||||
Jump - Jump buffer
|
||||
|
||||
Returns:
|
||||
|
||||
Status code
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
VOID
|
||||
RtPioICacheFlush (
|
||||
IN VOID *StartAddress,
|
||||
IN UINTN SizeInBytes
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Flushing the CPU instruction cache.
|
||||
|
||||
Arguments:
|
||||
|
||||
StartAddress - Start address to flush
|
||||
SizeInBytes - Length in bytes to flush
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#endif
|
214
Tools/Source/TianoTools/Common/PeiLib/Ipf/ia_64gen.h
Normal file
214
Tools/Source/TianoTools/Common/PeiLib/Ipf/ia_64gen.h
Normal file
@@ -0,0 +1,214 @@
|
||||
//
|
||||
//
|
||||
//
|
||||
// Copyright (c) 2004, Intel Corporation
|
||||
// All rights reserved. This program and the accompanying materials
|
||||
// are licensed and made available under the terms and conditions of the BSD License
|
||||
// which accompanies this distribution. The full text of the license may be found at
|
||||
// http://opensource.org/licenses/bsd-license.php
|
||||
//
|
||||
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
//
|
||||
//Module Name: ia_64gen.h
|
||||
//
|
||||
//
|
||||
//Abstract:
|
||||
//
|
||||
//
|
||||
//
|
||||
//
|
||||
//Revision History
|
||||
//
|
||||
//
|
||||
#ifndef _IA64GEN_H
|
||||
#define _IA64GEN_H
|
||||
|
||||
#define TT_UNAT 0
|
||||
#define C_PSR 0
|
||||
#define J_UNAT 0
|
||||
#define T_TYPE 0
|
||||
#define T_IPSR 0x8
|
||||
#define T_ISR 0x10
|
||||
#define T_IIP 0x18
|
||||
#define T_IFA 0x20
|
||||
#define T_IIPA 0x28
|
||||
#define T_IFS 0x30
|
||||
#define T_IIM 0x38
|
||||
#define T_RSC 0x40
|
||||
#define T_BSP 0x48
|
||||
#define T_BSPSTORE 0x50
|
||||
#define T_RNAT 0x58
|
||||
#define T_PFS 0x60
|
||||
#define T_KBSPSTORE 0x68
|
||||
#define T_UNAT 0x70
|
||||
#define T_CCV 0x78
|
||||
#define T_DCR 0x80
|
||||
#define T_PREDS 0x88
|
||||
#define T_NATS 0x90
|
||||
#define T_R1 0x98
|
||||
#define T_GP 0x98
|
||||
#define T_R2 0xa0
|
||||
#define T_R3 0xa8
|
||||
#define T_R4 0xb0
|
||||
#define T_R5 0xb8
|
||||
#define T_R6 0xc0
|
||||
#define T_R7 0xc8
|
||||
#define T_R8 0xd0
|
||||
#define T_R9 0xd8
|
||||
#define T_R10 0xe0
|
||||
#define T_R11 0xe8
|
||||
#define T_R12 0xf0
|
||||
#define T_SP 0xf0
|
||||
#define T_R13 0xf8
|
||||
#define T_R14 0x100
|
||||
#define T_R15 0x108
|
||||
#define T_R16 0x110
|
||||
#define T_R17 0x118
|
||||
#define T_R18 0x120
|
||||
#define T_R19 0x128
|
||||
#define T_R20 0x130
|
||||
#define T_R21 0x138
|
||||
#define T_R22 0x140
|
||||
#define T_R23 0x148
|
||||
#define T_R24 0x150
|
||||
#define T_R25 0x158
|
||||
#define T_R26 0x160
|
||||
#define T_R27 0x168
|
||||
#define T_R28 0x170
|
||||
#define T_R29 0x178
|
||||
#define T_R30 0x180
|
||||
#define T_R31 0x188
|
||||
#define T_F2 0x1f0
|
||||
#define T_F3 0x200
|
||||
#define T_F4 0x210
|
||||
#define T_F5 0x220
|
||||
#define T_F6 0x230
|
||||
#define T_F7 0x240
|
||||
#define T_F8 0x250
|
||||
#define T_F9 0x260
|
||||
#define T_F10 0x270
|
||||
#define T_F11 0x280
|
||||
#define T_F12 0x290
|
||||
#define T_F13 0x2a0
|
||||
#define T_F14 0x2b0
|
||||
#define T_F15 0x2c0
|
||||
#define T_F16 0x2d0
|
||||
#define T_F17 0x2e0
|
||||
#define T_F18 0x2f0
|
||||
#define T_F19 0x300
|
||||
#define T_F20 0x310
|
||||
#define T_F21 0x320
|
||||
#define T_F22 0x330
|
||||
#define T_F23 0x340
|
||||
#define T_F24 0x350
|
||||
#define T_F25 0x360
|
||||
#define T_F26 0x370
|
||||
#define T_F27 0x380
|
||||
#define T_F28 0x390
|
||||
#define T_F29 0x3a0
|
||||
#define T_F30 0x3b0
|
||||
#define T_F31 0x3c0
|
||||
#define T_FPSR 0x1e0
|
||||
#define T_B0 0x190
|
||||
#define T_B1 0x198
|
||||
#define T_B2 0x1a0
|
||||
#define T_B3 0x1a8
|
||||
#define T_B4 0x1b0
|
||||
#define T_B5 0x1b8
|
||||
#define T_B6 0x1c0
|
||||
#define T_B7 0x1c8
|
||||
#define T_EC 0x1d0
|
||||
#define T_LC 0x1d8
|
||||
#define J_NATS 0x8
|
||||
#define J_PFS 0x10
|
||||
#define J_BSP 0x18
|
||||
#define J_RNAT 0x20
|
||||
#define J_PREDS 0x28
|
||||
#define J_LC 0x30
|
||||
#define J_R4 0x38
|
||||
#define J_R5 0x40
|
||||
#define J_R6 0x48
|
||||
#define J_R7 0x50
|
||||
#define J_SP 0x58
|
||||
#define J_F2 0x60
|
||||
#define J_F3 0x70
|
||||
#define J_F4 0x80
|
||||
#define J_F5 0x90
|
||||
#define J_F16 0xa0
|
||||
#define J_F17 0xb0
|
||||
#define J_F18 0xc0
|
||||
#define J_F19 0xd0
|
||||
#define J_F20 0xe0
|
||||
#define J_F21 0xf0
|
||||
#define J_F22 0x100
|
||||
#define J_F23 0x110
|
||||
#define J_F24 0x120
|
||||
#define J_F25 0x130
|
||||
#define J_F26 0x140
|
||||
#define J_F27 0x150
|
||||
#define J_F28 0x160
|
||||
#define J_F29 0x170
|
||||
#define J_F30 0x180
|
||||
#define J_F31 0x190
|
||||
#define J_FPSR 0x1a0
|
||||
#define J_B0 0x1a8
|
||||
#define J_B1 0x1b0
|
||||
#define J_B2 0x1b8
|
||||
#define J_B3 0x1c0
|
||||
#define J_B4 0x1c8
|
||||
#define J_B5 0x1d0
|
||||
#define TRAP_FRAME_LENGTH 0x3d0
|
||||
#define C_UNAT 0x28
|
||||
#define C_NATS 0x30
|
||||
#define C_PFS 0x8
|
||||
#define C_BSPSTORE 0x10
|
||||
#define C_RNAT 0x18
|
||||
#define C_RSC 0x20
|
||||
#define C_PREDS 0x38
|
||||
#define C_LC 0x40
|
||||
#define C_DCR 0x48
|
||||
#define C_R1 0x50
|
||||
#define C_GP 0x50
|
||||
#define C_R4 0x58
|
||||
#define C_R5 0x60
|
||||
#define C_R6 0x68
|
||||
#define C_R7 0x70
|
||||
#define C_SP 0x78
|
||||
#define C_R13 0x80
|
||||
#define C_F2 0x90
|
||||
#define C_F3 0xa0
|
||||
#define C_F4 0xb0
|
||||
#define C_F5 0xc0
|
||||
#define C_F16 0xd0
|
||||
#define C_F17 0xe0
|
||||
#define C_F18 0xf0
|
||||
#define C_F19 0x100
|
||||
#define C_F20 0x110
|
||||
#define C_F21 0x120
|
||||
#define C_F22 0x130
|
||||
#define C_F23 0x140
|
||||
#define C_F24 0x150
|
||||
#define C_F25 0x160
|
||||
#define C_F26 0x170
|
||||
#define C_F27 0x180
|
||||
#define C_F28 0x190
|
||||
#define C_F29 0x1a0
|
||||
#define C_F30 0x1b0
|
||||
#define C_F31 0x1c0
|
||||
#define C_FPSR 0x1d0
|
||||
#define C_B0 0x1d8
|
||||
#define C_B1 0x1e0
|
||||
#define C_B2 0x1e8
|
||||
#define C_B3 0x1f0
|
||||
#define C_B4 0x1f8
|
||||
#define C_B5 0x200
|
||||
#define TT_R2 0x8
|
||||
#define TT_R3 0x10
|
||||
#define TT_R8 0x18
|
||||
#define TT_R9 0x20
|
||||
#define TT_R10 0x28
|
||||
#define TT_R11 0x30
|
||||
#define TT_R14 0x38
|
||||
|
||||
#endif _IA64GEN_H
|
139
Tools/Source/TianoTools/Common/PeiLib/Ipf/math.c
Normal file
139
Tools/Source/TianoTools/Common/PeiLib/Ipf/math.c
Normal file
@@ -0,0 +1,139 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
math.c
|
||||
|
||||
Abstract:
|
||||
|
||||
64-bit Math worker functions for Intel Itanium(TM) processors.
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "Pei.h"
|
||||
#include "PeiLib.h"
|
||||
|
||||
UINT64
|
||||
LShiftU64 (
|
||||
IN UINT64 Operand,
|
||||
IN UINTN Count
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be left shifted by 32 bits and
|
||||
returns the shifted value.
|
||||
Count is valid up 63. (Only Bits 0-5 is valid for Count)
|
||||
|
||||
Arguments:
|
||||
|
||||
Operand - Value to be shifted
|
||||
Count - Number of times to shift left.
|
||||
|
||||
Returns:
|
||||
|
||||
Value shifted left identified by the Count.
|
||||
|
||||
--*/
|
||||
{
|
||||
return Operand << Count;
|
||||
}
|
||||
|
||||
UINT64
|
||||
RShiftU64 (
|
||||
IN UINT64 Operand,
|
||||
IN UINTN Count
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be right shifted by 32 bits and returns the
|
||||
shifted value.
|
||||
Count is valid up 63. (Only Bits 0-5 is valid for Count)
|
||||
|
||||
Arguments:
|
||||
|
||||
Operand - Value to be shifted
|
||||
Count - Number of times to shift right.
|
||||
|
||||
Returns:
|
||||
|
||||
Value shifted right identified by the Count.
|
||||
|
||||
--*/
|
||||
{
|
||||
return Operand >> Count;
|
||||
}
|
||||
|
||||
UINT64
|
||||
MultU64x32 (
|
||||
IN UINT64 Multiplicand,
|
||||
IN UINTN Multiplier
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be multiplied with a 32 bit
|
||||
value returns 64bit result.
|
||||
No checking if the result is greater than 64bits
|
||||
|
||||
Arguments:
|
||||
|
||||
Multiplicand - multiplicand
|
||||
Multiplier - multiplier
|
||||
|
||||
Returns:
|
||||
|
||||
Multiplicand * Multiplier
|
||||
|
||||
--*/
|
||||
{
|
||||
return Multiplicand * Multiplier;
|
||||
}
|
||||
|
||||
UINT64
|
||||
DivU64x32 (
|
||||
IN UINT64 Dividend,
|
||||
IN UINTN Divisor,
|
||||
OUT UINTN *Remainder OPTIONAL
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be divided with a 32 bit value returns
|
||||
64bit result and the Remainder.
|
||||
N.B. only works for 31bit divisors!!
|
||||
|
||||
Arguments:
|
||||
|
||||
Dividend - dividend
|
||||
Divisor - divisor
|
||||
Remainder - buffer for remainder
|
||||
|
||||
Returns:
|
||||
|
||||
Dividend / Divisor
|
||||
Remainder = Dividend mod Divisor
|
||||
|
||||
--*/
|
||||
{
|
||||
if (Remainder) {
|
||||
*Remainder = Dividend % Divisor;
|
||||
}
|
||||
|
||||
return Dividend / Divisor;
|
||||
}
|
106
Tools/Source/TianoTools/Common/PeiLib/Ipf/pioflush.s
Normal file
106
Tools/Source/TianoTools/Common/PeiLib/Ipf/pioflush.s
Normal file
@@ -0,0 +1,106 @@
|
||||
//++
|
||||
// Copyright (c) 2004, Intel Corporation
|
||||
// All rights reserved. This program and the accompanying materials
|
||||
// are licensed and made available under the terms and conditions of the BSD License
|
||||
// which accompanies this distribution. The full text of the license may be found at
|
||||
// http://opensource.org/licenses/bsd-license.php
|
||||
//
|
||||
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
//
|
||||
// Module Name:
|
||||
//
|
||||
// pioflush.s
|
||||
//
|
||||
// Abstract:
|
||||
//
|
||||
//
|
||||
// Revision History:
|
||||
//
|
||||
//--
|
||||
|
||||
.file "pioflush.c"
|
||||
.radix D
|
||||
.section .text, "ax", "progbits"
|
||||
.align 32
|
||||
.section .pdata, "a", "progbits"
|
||||
.align 4
|
||||
.section .xdata, "a", "progbits"
|
||||
.align 8
|
||||
.section .data, "wa", "progbits"
|
||||
.align 16
|
||||
.section .rdata, "a", "progbits"
|
||||
.align 16
|
||||
.section .bss, "wa", "nobits"
|
||||
.align 16
|
||||
.section .tls$, "was", "progbits"
|
||||
.align 16
|
||||
.section .sdata, "was", "progbits"
|
||||
.align 16
|
||||
.section .sbss, "was", "nobits"
|
||||
.align 16
|
||||
.section .srdata, "as", "progbits"
|
||||
.align 16
|
||||
.section .rdata, "a", "progbits"
|
||||
.align 16
|
||||
.section .rtcode, "ax", "progbits"
|
||||
.align 32
|
||||
.type RtPioICacheFlush# ,@function
|
||||
.global RtPioICacheFlush#
|
||||
// Function compile flags: /Ogsy
|
||||
.section .rtcode
|
||||
|
||||
// Begin code for function: RtPioICacheFlush:
|
||||
.proc RtPioICacheFlush#
|
||||
.align 32
|
||||
RtPioICacheFlush:
|
||||
// File e:\tmp\pioflush.c
|
||||
{ .mii //R-Addr: 0X00
|
||||
alloc r3=2, 0, 0, 0 //11, 00000002H
|
||||
cmp4.leu p0,p6=32, r33;; //15, 00000020H
|
||||
(p6) mov r33=32;; //16, 00000020H
|
||||
}
|
||||
{ .mii //R-Addr: 0X010
|
||||
nop.m 0
|
||||
zxt4 r29=r33;; //21
|
||||
dep.z r30=r29, 0, 5;; //21, 00000005H
|
||||
}
|
||||
{ .mii //R-Addr: 0X020
|
||||
cmp4.eq p0,p7=r0, r30 //21
|
||||
shr.u r28=r29, 5;; //19, 00000005H
|
||||
(p7) adds r28=1, r28;; //22, 00000001H
|
||||
}
|
||||
{ .mii //R-Addr: 0X030
|
||||
nop.m 0
|
||||
shl r27=r28, 5;; //25, 00000005H
|
||||
zxt4 r26=r27;; //25
|
||||
}
|
||||
{ .mfb //R-Addr: 0X040
|
||||
add r31=r26, r32 //25
|
||||
nop.f 0
|
||||
nop.b 0
|
||||
}
|
||||
$L143:
|
||||
{ .mii //R-Addr: 0X050
|
||||
fc r32 //27
|
||||
adds r32=32, r32;; //28, 00000020H
|
||||
cmp.ltu p14,p15=r32, r31 //29
|
||||
}
|
||||
{ .mfb //R-Addr: 0X060
|
||||
nop.m 0
|
||||
nop.f 0
|
||||
(p14) br.cond.dptk.few $L143#;; //29, 880000/120000
|
||||
}
|
||||
{ .mmi
|
||||
sync.i;;
|
||||
srlz.i
|
||||
nop.i 0;;
|
||||
}
|
||||
{ .mfb //R-Addr: 0X070
|
||||
nop.m 0
|
||||
nop.f 0
|
||||
br.ret.sptk.few b0;; //31
|
||||
}
|
||||
// End code for function:
|
||||
.endp RtPioICacheFlush#
|
||||
// END
|
118
Tools/Source/TianoTools/Common/PeiLib/Ipf/processor.c
Normal file
118
Tools/Source/TianoTools/Common/PeiLib/Ipf/processor.c
Normal file
@@ -0,0 +1,118 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Processor.c
|
||||
|
||||
Abstract:
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "EfiJump.h"
|
||||
#include "PeiHob.h"
|
||||
#include EFI_GUID_DEFINITION (PeiFlushInstructionCache)
|
||||
#include EFI_GUID_DEFINITION (PeiTransferControl)
|
||||
|
||||
EFI_STATUS
|
||||
WinNtFlushInstructionCacheFlush (
|
||||
IN EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL *This,
|
||||
IN EFI_PHYSICAL_ADDRESS Start,
|
||||
IN UINT64 Length
|
||||
);
|
||||
|
||||
EFI_PEI_TRANSFER_CONTROL_PROTOCOL mTransferControl = {
|
||||
SetJump,
|
||||
LongJump,
|
||||
sizeof (EFI_JUMP_BUFFER)
|
||||
};
|
||||
|
||||
EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL mFlushInstructionCache = {
|
||||
WinNtFlushInstructionCacheFlush
|
||||
};
|
||||
|
||||
EFI_STATUS
|
||||
InstallEfiPeiTransferControl (
|
||||
IN OUT EFI_PEI_TRANSFER_CONTROL_PROTOCOL **This
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Installs the pointer to the transfer control mechanism
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to transfer control mechanism.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Successfully installed.
|
||||
|
||||
--*/
|
||||
{
|
||||
*This = &mTransferControl;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
InstallEfiPeiFlushInstructionCache (
|
||||
IN OUT EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL **This
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Installs the pointer to the flush instruction cache mechanism
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to flush instruction cache mechanism.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Successfully installed
|
||||
|
||||
--*/
|
||||
{
|
||||
*This = &mFlushInstructionCache;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
WinNtFlushInstructionCacheFlush (
|
||||
IN EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL *This,
|
||||
IN EFI_PHYSICAL_ADDRESS Start,
|
||||
IN UINT64 Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine would provide support for flushing the CPU instruction cache.
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to CPU Architectural Protocol interface
|
||||
Start - Start adddress in memory to flush
|
||||
Length - Length of memory to flush
|
||||
|
||||
Returns:
|
||||
|
||||
Status
|
||||
EFI_SUCCESS
|
||||
|
||||
--*/
|
||||
{
|
||||
RtPioICacheFlush ((UINT8 *) Start, (UINTN) Length);
|
||||
return EFI_SUCCESS;
|
||||
}
|
325
Tools/Source/TianoTools/Common/PeiLib/Ipf/setjmp.s
Normal file
325
Tools/Source/TianoTools/Common/PeiLib/Ipf/setjmp.s
Normal file
@@ -0,0 +1,325 @@
|
||||
//++
|
||||
// Copyright (c) 2004, Intel Corporation
|
||||
// All rights reserved. This program and the accompanying materials
|
||||
// are licensed and made available under the terms and conditions of the BSD License
|
||||
// which accompanies this distribution. The full text of the license may be found at
|
||||
// http://opensource.org/licenses/bsd-license.php
|
||||
//
|
||||
// THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
//
|
||||
// Module Name:
|
||||
//
|
||||
// setjmp.s
|
||||
//
|
||||
// Abstract:
|
||||
//
|
||||
// Contains an implementation of setjmp and longjmp for the
|
||||
// Itanium-based architecture.
|
||||
//
|
||||
//
|
||||
//
|
||||
// Revision History:
|
||||
//
|
||||
//--
|
||||
|
||||
.file "setjmp.s"
|
||||
|
||||
#include <asm.h>
|
||||
#include <ia_64gen.h>
|
||||
|
||||
// int SetJump(struct jmp_buffer save)
|
||||
//
|
||||
// Setup a non-local goto.
|
||||
//
|
||||
// Description:
|
||||
//
|
||||
// SetJump stores the current register set in the area pointed to
|
||||
// by "save". It returns zero. Subsequent calls to "LongJump" will
|
||||
// restore the registers and return non-zero to the same location.
|
||||
//
|
||||
// On entry, r32 contains the pointer to the jmp_buffer
|
||||
//
|
||||
|
||||
PROCEDURE_ENTRY(SetJump)
|
||||
//
|
||||
// Make sure buffer is aligned at 16byte boundary
|
||||
//
|
||||
mov r32 = r33
|
||||
|
||||
add r10 = -0x10,r0 ;; // mask the lower 4 bits
|
||||
and r32 = r32, r10;;
|
||||
add r32 = 0x10, r32;; // move to next 16 byte boundary
|
||||
|
||||
add r10 = J_PREDS, r32 // skip Unats & pfs save area
|
||||
add r11 = J_BSP, r32
|
||||
//
|
||||
// save immediate context
|
||||
//
|
||||
mov r2 = ar.bsp // save backing store pointer
|
||||
mov r3 = pr // save predicates
|
||||
;;
|
||||
//
|
||||
// save user Unat register
|
||||
//
|
||||
mov r16 = ar.lc // save loop count register
|
||||
mov r14 = ar.unat // save user Unat register
|
||||
|
||||
st8 [r10] = r3, J_LC-J_PREDS
|
||||
st8 [r11] = r2, J_R4-J_BSP
|
||||
;;
|
||||
st8 [r10] = r16, J_R5-J_LC
|
||||
st8 [r32] = r14, J_NATS // Note: Unat at the
|
||||
// beginning of the save area
|
||||
mov r15 = ar.pfs
|
||||
;;
|
||||
//
|
||||
// save preserved general registers & NaT's
|
||||
//
|
||||
st8.spill [r11] = r4, J_R6-J_R4
|
||||
;;
|
||||
st8.spill [r10] = r5, J_R7-J_R5
|
||||
;;
|
||||
st8.spill [r11] = r6, J_SP-J_R6
|
||||
;;
|
||||
st8.spill [r10] = r7, J_F3-J_R7
|
||||
;;
|
||||
st8.spill [r11] = sp, J_F2-J_SP
|
||||
;;
|
||||
//
|
||||
// save spilled Unat and pfs registers
|
||||
//
|
||||
mov r2 = ar.unat // save Unat register after spill
|
||||
;;
|
||||
st8 [r32] = r2, J_PFS-J_NATS // save unat for spilled regs
|
||||
;;
|
||||
st8 [r32] = r15 // save pfs
|
||||
//
|
||||
// save floating registers
|
||||
//
|
||||
stf.spill [r11] = f2, J_F4-J_F2
|
||||
stf.spill [r10] = f3, J_F5-J_F3
|
||||
;;
|
||||
stf.spill [r11] = f4, J_F16-J_F4
|
||||
stf.spill [r10] = f5, J_F17-J_F5
|
||||
;;
|
||||
stf.spill [r11] = f16, J_F18-J_F16
|
||||
stf.spill [r10] = f17, J_F19-J_F17
|
||||
;;
|
||||
stf.spill [r11] = f18, J_F20-J_F18
|
||||
stf.spill [r10] = f19, J_F21-J_F19
|
||||
;;
|
||||
stf.spill [r11] = f20, J_F22-J_F20
|
||||
stf.spill [r10] = f21, J_F23-J_F21
|
||||
;;
|
||||
stf.spill [r11] = f22, J_F24-J_F22
|
||||
stf.spill [r10] = f23, J_F25-J_F23
|
||||
;;
|
||||
stf.spill [r11] = f24, J_F26-J_F24
|
||||
stf.spill [r10] = f25, J_F27-J_F25
|
||||
;;
|
||||
stf.spill [r11] = f26, J_F28-J_F26
|
||||
stf.spill [r10] = f27, J_F29-J_F27
|
||||
;;
|
||||
stf.spill [r11] = f28, J_F30-J_F28
|
||||
stf.spill [r10] = f29, J_F31-J_F29
|
||||
;;
|
||||
stf.spill [r11] = f30, J_FPSR-J_F30
|
||||
stf.spill [r10] = f31, J_B0-J_F31 // size of f31 + fpsr
|
||||
//
|
||||
// save FPSR register & branch registers
|
||||
//
|
||||
mov r2 = ar.fpsr // save fpsr register
|
||||
mov r3 = b0
|
||||
;;
|
||||
st8 [r11] = r2, J_B1-J_FPSR
|
||||
st8 [r10] = r3, J_B2-J_B0
|
||||
mov r2 = b1
|
||||
mov r3 = b2
|
||||
;;
|
||||
st8 [r11] = r2, J_B3-J_B1
|
||||
st8 [r10] = r3, J_B4-J_B2
|
||||
mov r2 = b3
|
||||
mov r3 = b4
|
||||
;;
|
||||
st8 [r11] = r2, J_B5-J_B3
|
||||
st8 [r10] = r3
|
||||
mov r2 = b5
|
||||
;;
|
||||
st8 [r11] = r2
|
||||
;;
|
||||
//
|
||||
// return
|
||||
//
|
||||
mov r8 = r0 // return 0 from setjmp
|
||||
mov ar.unat = r14 // restore unat
|
||||
br.ret.sptk b0
|
||||
|
||||
PROCEDURE_EXIT(SetJump)
|
||||
|
||||
|
||||
//
|
||||
// void LongJump(struct jmp_buffer *)
|
||||
//
|
||||
// Perform a non-local goto.
|
||||
//
|
||||
// Description:
|
||||
//
|
||||
// LongJump initializes the register set to the values saved by a
|
||||
// previous 'SetJump' and jumps to the return location saved by that
|
||||
// 'SetJump'. This has the effect of unwinding the stack and returning
|
||||
// for a second time to the 'SetJump'.
|
||||
//
|
||||
|
||||
PROCEDURE_ENTRY(LongJump)
|
||||
//
|
||||
// Make sure buffer is aligned at 16byte boundary
|
||||
//
|
||||
mov r32 = r33
|
||||
|
||||
add r10 = -0x10,r0 ;; // mask the lower 4 bits
|
||||
and r32 = r32, r10;;
|
||||
add r32 = 0x10, r32;; // move to next 16 byte boundary
|
||||
|
||||
//
|
||||
// caching the return value as we do invala in the end
|
||||
//
|
||||
/// mov r8 = r33 // return value
|
||||
mov r8 = 1 // For now return hard coded 1
|
||||
|
||||
//
|
||||
// get immediate context
|
||||
//
|
||||
mov r14 = ar.rsc // get user RSC conf
|
||||
add r10 = J_PFS, r32 // get address of pfs
|
||||
add r11 = J_NATS, r32
|
||||
;;
|
||||
ld8 r15 = [r10], J_BSP-J_PFS // get pfs
|
||||
ld8 r2 = [r11], J_LC-J_NATS // get unat for spilled regs
|
||||
;;
|
||||
mov ar.unat = r2
|
||||
;;
|
||||
ld8 r16 = [r10], J_PREDS-J_BSP // get backing store pointer
|
||||
mov ar.rsc = r0 // put RSE in enforced lazy
|
||||
mov ar.pfs = r15
|
||||
;;
|
||||
|
||||
//
|
||||
// while returning from longjmp the BSPSTORE and BSP needs to be
|
||||
// same and discard all the registers allocated after we did
|
||||
// setjmp. Also, we need to generate the RNAT register since we
|
||||
// did not flushed the RSE on setjmp.
|
||||
//
|
||||
mov r17 = ar.bspstore // get current BSPSTORE
|
||||
;;
|
||||
cmp.ltu p6,p7 = r17, r16 // is it less than BSP of
|
||||
(p6) br.spnt.few .flush_rse
|
||||
mov r19 = ar.rnat // get current RNAT
|
||||
;;
|
||||
loadrs // invalidate dirty regs
|
||||
br.sptk.many .restore_rnat // restore RNAT
|
||||
|
||||
.flush_rse:
|
||||
flushrs
|
||||
;;
|
||||
mov r19 = ar.rnat // get current RNAT
|
||||
mov r17 = r16 // current BSPSTORE
|
||||
;;
|
||||
.restore_rnat:
|
||||
//
|
||||
// check if RNAT is saved between saved BSP and curr BSPSTORE
|
||||
//
|
||||
dep r18 = 1,r16,3,6 // get RNAT address
|
||||
;;
|
||||
cmp.ltu p8,p9 = r18, r17 // RNAT saved on RSE
|
||||
;;
|
||||
(p8) ld8 r19 = [r18] // get RNAT from RSE
|
||||
;;
|
||||
mov ar.bspstore = r16 // set new BSPSTORE
|
||||
;;
|
||||
mov ar.rnat = r19 // restore RNAT
|
||||
mov ar.rsc = r14 // restore RSC conf
|
||||
|
||||
|
||||
ld8 r3 = [r11], J_R4-J_LC // get lc register
|
||||
ld8 r2 = [r10], J_R5-J_PREDS // get predicates
|
||||
;;
|
||||
mov pr = r2, -1
|
||||
mov ar.lc = r3
|
||||
//
|
||||
// restore preserved general registers & NaT's
|
||||
//
|
||||
ld8.fill r4 = [r11], J_R6-J_R4
|
||||
;;
|
||||
ld8.fill r5 = [r10], J_R7-J_R5
|
||||
ld8.fill r6 = [r11], J_SP-J_R6
|
||||
;;
|
||||
ld8.fill r7 = [r10], J_F2-J_R7
|
||||
ld8.fill sp = [r11], J_F3-J_SP
|
||||
;;
|
||||
//
|
||||
// restore floating registers
|
||||
//
|
||||
ldf.fill f2 = [r10], J_F4-J_F2
|
||||
ldf.fill f3 = [r11], J_F5-J_F3
|
||||
;;
|
||||
ldf.fill f4 = [r10], J_F16-J_F4
|
||||
ldf.fill f5 = [r11], J_F17-J_F5
|
||||
;;
|
||||
ldf.fill f16 = [r10], J_F18-J_F16
|
||||
ldf.fill f17 = [r11], J_F19-J_F17
|
||||
;;
|
||||
ldf.fill f18 = [r10], J_F20-J_F18
|
||||
ldf.fill f19 = [r11], J_F21-J_F19
|
||||
;;
|
||||
ldf.fill f20 = [r10], J_F22-J_F20
|
||||
ldf.fill f21 = [r11], J_F23-J_F21
|
||||
;;
|
||||
ldf.fill f22 = [r10], J_F24-J_F22
|
||||
ldf.fill f23 = [r11], J_F25-J_F23
|
||||
;;
|
||||
ldf.fill f24 = [r10], J_F26-J_F24
|
||||
ldf.fill f25 = [r11], J_F27-J_F25
|
||||
;;
|
||||
ldf.fill f26 = [r10], J_F28-J_F26
|
||||
ldf.fill f27 = [r11], J_F29-J_F27
|
||||
;;
|
||||
ldf.fill f28 = [r10], J_F30-J_F28
|
||||
ldf.fill f29 = [r11], J_F31-J_F29
|
||||
;;
|
||||
ldf.fill f30 = [r10], J_FPSR-J_F30
|
||||
ldf.fill f31 = [r11], J_B0-J_F31 ;;
|
||||
|
||||
//
|
||||
// restore branch registers and fpsr
|
||||
//
|
||||
ld8 r16 = [r10], J_B1-J_FPSR // get fpsr
|
||||
ld8 r17 = [r11], J_B2-J_B0 // get return pointer
|
||||
;;
|
||||
mov ar.fpsr = r16
|
||||
mov b0 = r17
|
||||
ld8 r2 = [r10], J_B3-J_B1
|
||||
ld8 r3 = [r11], J_B4-J_B2
|
||||
;;
|
||||
mov b1 = r2
|
||||
mov b2 = r3
|
||||
ld8 r2 = [r10], J_B5-J_B3
|
||||
ld8 r3 = [r11]
|
||||
;;
|
||||
mov b3 = r2
|
||||
mov b4 = r3
|
||||
ld8 r2 = [r10]
|
||||
ld8 r21 = [r32] // get user unat
|
||||
;;
|
||||
mov b5 = r2
|
||||
mov ar.unat = r21
|
||||
|
||||
//
|
||||
// invalidate ALAT
|
||||
//
|
||||
invala ;;
|
||||
|
||||
br.ret.sptk b0
|
||||
PROCEDURE_EXIT(LongJump)
|
||||
|
||||
|
1249
Tools/Source/TianoTools/Common/PeiLib/PeCoffLoader.c
Normal file
1249
Tools/Source/TianoTools/Common/PeiLib/PeCoffLoader.c
Normal file
File diff suppressed because it is too large
Load Diff
169
Tools/Source/TianoTools/Common/PeiLib/PeiLib.c
Normal file
169
Tools/Source/TianoTools/Common/PeiLib/PeiLib.c
Normal file
@@ -0,0 +1,169 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PeiLib.c
|
||||
|
||||
Abstract:
|
||||
|
||||
PEI Library Functions
|
||||
|
||||
--*/
|
||||
|
||||
#include "TianoCommon.h"
|
||||
#include "PeiHob.h"
|
||||
#include "Pei.h"
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
);
|
||||
|
||||
VOID
|
||||
ZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Set Buffer to zero for Size bytes.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Memory to set.
|
||||
|
||||
Size - Number of bytes to set
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
INT8 *Ptr;
|
||||
|
||||
Ptr = Buffer;
|
||||
while (Size--) {
|
||||
*(Ptr++) = 0;
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Copy Length bytes from Source to Destination.
|
||||
|
||||
Arguments:
|
||||
|
||||
Destination - Target of copy
|
||||
|
||||
Source - Place to copy from
|
||||
|
||||
Length - Number of bytes to copy
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *Destination8;
|
||||
CHAR8 *Source8;
|
||||
|
||||
Destination8 = Destination;
|
||||
Source8 = Source;
|
||||
while (Length--) {
|
||||
*(Destination8++) = *(Source8++);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
CopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Copy Length bytes from Source to Destination.
|
||||
|
||||
Arguments:
|
||||
|
||||
Destination - Target of copy
|
||||
|
||||
Source - Place to copy from
|
||||
|
||||
Length - Number of bytes to copy
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *Destination8;
|
||||
CHAR8 *Source8;
|
||||
|
||||
Destination8 = Destination;
|
||||
Source8 = Source;
|
||||
while (Length--) {
|
||||
*(Destination8++) = *(Source8++);
|
||||
}
|
||||
}
|
||||
|
||||
BOOLEAN
|
||||
CompareGuid (
|
||||
IN EFI_GUID *Guid1,
|
||||
IN EFI_GUID *Guid2
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Compares two GUIDs
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid1 - guid to compare
|
||||
Guid2 - guid to compare
|
||||
|
||||
Returns:
|
||||
= TRUE if Guid1 == Guid2
|
||||
= FALSE if Guid1 != Guid2
|
||||
|
||||
--*/
|
||||
{
|
||||
if ((((INT32 *) Guid1)[0] - ((INT32 *) Guid2)[0]) == 0) {
|
||||
if ((((INT32 *) Guid1)[1] - ((INT32 *) Guid2)[1]) == 0) {
|
||||
if ((((INT32 *) Guid1)[2] - ((INT32 *) Guid2)[2]) == 0) {
|
||||
if ((((INT32 *) Guid1)[3] - ((INT32 *) Guid2)[3]) == 0) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
798
Tools/Source/TianoTools/Common/PeiLib/PeiLib.h
Normal file
798
Tools/Source/TianoTools/Common/PeiLib/PeiLib.h
Normal file
@@ -0,0 +1,798 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PeiLib.h
|
||||
|
||||
Abstract:
|
||||
|
||||
PEI Library Functions
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _PEI_LIB_H_
|
||||
#define _PEI_LIB_H_
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "Pei.h"
|
||||
#include "peiHobLib.h"
|
||||
#include EFI_PROTOCOL_DEFINITION (Decompress)
|
||||
#include EFI_PROTOCOL_DEFINITION (TianoDecompress)
|
||||
#include EFI_GUID_DEFINITION (PeiPeCoffLoader)
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Copy Length bytes from Source to Destination.
|
||||
|
||||
Arguments:
|
||||
|
||||
Destination - Target of copy
|
||||
|
||||
Source - Place to copy from
|
||||
|
||||
Length - Number of bytes to copy
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
VOID
|
||||
ZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Set Buffer to zero for Size bytes.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Memory to set.
|
||||
|
||||
Size - Number of bytes to set
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
VOID
|
||||
CopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Copy Length bytes from Source to Destination.
|
||||
|
||||
Arguments:
|
||||
|
||||
Destination - Target of copy
|
||||
|
||||
Source - Place to copy from
|
||||
|
||||
Length - Number of bytes to copy
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
CompareGuid (
|
||||
IN EFI_GUID *Guid1,
|
||||
IN EFI_GUID *Guid2
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Compares two GUIDs
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid1 - guid to compare
|
||||
Guid2 - guid to compare
|
||||
|
||||
Returns:
|
||||
= TRUE if Guid1 == Guid2
|
||||
= FALSE if Guid1 != Guid2
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
InstallEfiPeiPeCoffLoader (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PEI_PE_COFF_LOADER_PROTOCOL **This,
|
||||
IN EFI_PEI_PPI_DESCRIPTOR *ThisPpi
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Install EFI Pei PE coff loader protocol.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
This - Pointer to get Pei PE coff loader protocol as output
|
||||
|
||||
ThisPpi - Passed in as EFI_NT_LOAD_AS_DLL_PPI on NT_EMULATOR platform
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
InstallEfiDecompress (
|
||||
EFI_DECOMPRESS_PROTOCOL **This
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Install EFI decompress protocol.
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to get decompress protocol as output
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - EFI decompress protocol successfully installed.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
InstallTianoDecompress (
|
||||
EFI_TIANO_DECOMPRESS_PROTOCOL **This
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Install Tiano decompress protocol.
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to get decompress protocol as output
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Tiano decompress protocol successfully installed.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
VOID
|
||||
PeiPerfMeasure (
|
||||
EFI_PEI_SERVICES **PeiServices,
|
||||
IN UINT16 *Token,
|
||||
IN EFI_FFS_FILE_HEADER *FileHeader,
|
||||
IN BOOLEAN EntryExit,
|
||||
IN UINT64 Value
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Log a timestamp count.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - Pointer to the PEI Core Services table
|
||||
|
||||
Token - Pointer to Token Name
|
||||
|
||||
FileHeader - Pointer to the file header
|
||||
|
||||
EntryExit - Indicates start or stop measurement
|
||||
|
||||
Value - The start time or the stop time
|
||||
|
||||
Returns:
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetTimerValue (
|
||||
OUT UINT64 *TimerValue
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Get timer value.
|
||||
|
||||
Arguments:
|
||||
|
||||
TimerValue - Pointer to the returned timer value
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Successfully got timer value
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#ifdef EFI_PEI_PERFORMANCE
|
||||
#define PEI_PERF_START(Ps, Token, FileHeader, Value) PeiPerfMeasure (Ps, Token, FileHeader, FALSE, Value)
|
||||
#define PEI_PERF_END(Ps, Token, FileHeader, Value) PeiPerfMeasure (Ps, Token, FileHeader, TRUE, Value)
|
||||
#else
|
||||
#define PEI_PERF_START(Ps, Token, FileHeader, Value)
|
||||
#define PEI_PERF_END(Ps, Token, FileHeader, Value)
|
||||
#endif
|
||||
|
||||
#ifdef EFI_NT_EMULATOR
|
||||
EFI_STATUS
|
||||
PeCoffLoaderWinNtLoadAsDll (
|
||||
IN CHAR8 *PdbFileName,
|
||||
IN VOID **ImageEntryPoint,
|
||||
OUT VOID **ModHandle
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Loads the .DLL file is present when a PE/COFF file is loaded. This provides source level
|
||||
debugging for drivers that have cooresponding .DLL files on the local system.
|
||||
|
||||
Arguments:
|
||||
|
||||
PdbFileName - The name of the .PDB file. This was found from the PE/COFF
|
||||
file's debug directory entry.
|
||||
|
||||
ImageEntryPoint - A pointer to the DLL entry point of the .DLL file was loaded.
|
||||
|
||||
ModHandle - Pointer to loaded library.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The .DLL file was loaded, and the DLL entry point is returned in ImageEntryPoint
|
||||
|
||||
EFI_NOT_FOUND - The .DLL file could not be found
|
||||
|
||||
EFI_UNSUPPORTED - The .DLL file was loaded, but the entry point to the .DLL file could not
|
||||
determined.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#endif
|
||||
//
|
||||
// hob.c
|
||||
//
|
||||
EFI_STATUS
|
||||
PeiBuildHobModule (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_GUID *ModuleName,
|
||||
IN EFI_PHYSICAL_ADDRESS Module,
|
||||
IN UINT64 ModuleLength,
|
||||
IN EFI_PHYSICAL_ADDRESS EntryPoint
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for a loaded PE32 module
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
ModuleName - The GUID File Name of the module
|
||||
Memory - The 64 bit physical address of the module
|
||||
ModuleLength - The length of the module in bytes
|
||||
EntryPoint - The 64 bit physical address of the entry point
|
||||
to the module
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobResourceDescriptor (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_RESOURCE_TYPE ResourceType,
|
||||
IN EFI_RESOURCE_ATTRIBUTE_TYPE ResourceAttribute,
|
||||
IN EFI_PHYSICAL_ADDRESS PhysicalStart,
|
||||
IN UINT64 NumberOfBytes
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB that describes a chunck of system memory
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
ResourceType - The type of resource described by this HOB
|
||||
|
||||
ResourceAttribute - The resource attributes of the memory described by this HOB
|
||||
|
||||
PhysicalStart - The 64 bit physical address of memory described by this HOB
|
||||
|
||||
NumberOfBytes - The length of the memoty described by this HOB in bytes
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobGuid (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_GUID *Guid,
|
||||
IN UINTN DataLength,
|
||||
IN OUT VOID **Hob
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a custom HOB that is tagged with a GUID for identification
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
Guid - The GUID of the custome HOB type
|
||||
|
||||
DataLength - The size of the data payload for the GUIDed HOB
|
||||
|
||||
Hob - Pointer to the Hob
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobGuidData (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_GUID *Guid,
|
||||
IN VOID *Data,
|
||||
IN UINTN DataLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a custom HOB that is tagged with a GUID for identification
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
Guid - The GUID of the custome HOB type
|
||||
|
||||
Data - The data to be copied into the GUIDed HOB data field.
|
||||
|
||||
DataLength - The data field length.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobFv (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a Firmware Volume HOB
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The base address of the Firmware Volume
|
||||
|
||||
Length - The size of the Firmware Volume in bytes
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobCpu (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN UINT8 SizeOfMemorySpace,
|
||||
IN UINT8 SizeOfIoSpace
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the CPU
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
SizeOfMemorySpace - Identifies the maximum
|
||||
physical memory addressibility of the processor.
|
||||
|
||||
SizeOfIoSpace - Identifies the maximum physical I/O addressibility
|
||||
of the processor.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobStack (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the Stack
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The 64 bit physical address of the Stack
|
||||
|
||||
Length - The length of the stack in bytes
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobBspStore (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN EFI_MEMORY_TYPE MemoryType
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the bsp store
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The 64 bit physical address of the bsp store
|
||||
|
||||
Length - The length of the bsp store in bytes
|
||||
|
||||
MemoryType - Memory type
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PeiBuildHobMemoryAllocation (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN EFI_PHYSICAL_ADDRESS BaseAddress,
|
||||
IN UINT64 Length,
|
||||
IN EFI_GUID *Name,
|
||||
IN EFI_MEMORY_TYPE MemoryType
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Builds a HOB for the memory allocation
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - The PEI core services table.
|
||||
|
||||
BaseAddress - The 64 bit physical address of the memory
|
||||
|
||||
Length - The length of the memory allocation in bytes
|
||||
|
||||
Name - Name for Hob
|
||||
|
||||
MemoryType - Memory type
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Hob is successfully built.
|
||||
Others - Errors occur while creating new Hob
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
//
|
||||
// print.c
|
||||
//
|
||||
UINTN
|
||||
AvSPrint (
|
||||
OUT CHAR8 *StartOfBuffer,
|
||||
IN UINTN StrSize,
|
||||
IN CONST CHAR8 *Format,
|
||||
IN VA_LIST Marker
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint function to process format and place the results in Buffer. Since a
|
||||
VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
|
||||
this is the main print working routine
|
||||
|
||||
Arguments:
|
||||
|
||||
StartOfBuffer - Ascii buffer to print the results of the parsing of Format into.
|
||||
|
||||
StrSize - Maximum number of characters to put into buffer. Zero means
|
||||
no limit.
|
||||
|
||||
FormatString - Ascii format string see file header for more details.
|
||||
|
||||
Marker - Vararg list consumed by processing Format.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
UINTN
|
||||
ASPrint (
|
||||
OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize,
|
||||
IN CONST CHAR8 *Format,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
ASPrint function to process format and place the results in Buffer.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Ascii buffer to print the results of the parsing of Format into.
|
||||
|
||||
BufferSize - Maximum number of characters to put into buffer. Zero means no
|
||||
limit.
|
||||
|
||||
Format - Ascii format string see file header for more details.
|
||||
|
||||
... - Vararg list consumed by processing Format.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
//
|
||||
// math.c
|
||||
//
|
||||
UINT64
|
||||
MultU64x32 (
|
||||
IN UINT64 Multiplicand,
|
||||
IN UINTN Multiplier
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be multiplied with a 32 bit
|
||||
value returns 64bit result.
|
||||
No checking if the result is greater than 64bits
|
||||
|
||||
Arguments:
|
||||
|
||||
Multiplicand - multiplicand
|
||||
Multiplier - multiplier
|
||||
|
||||
Returns:
|
||||
|
||||
Multiplicand * Multiplier
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
UINT64
|
||||
DivU64x32 (
|
||||
IN UINT64 Dividend,
|
||||
IN UINTN Divisor,
|
||||
OUT UINTN *Remainder OPTIONAL
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be divided with a 32 bit value returns
|
||||
64bit result and the Remainder.
|
||||
N.B. only works for 31bit divisors!!
|
||||
|
||||
Arguments:
|
||||
|
||||
Dividend - dividend
|
||||
Divisor - divisor
|
||||
Remainder - buffer for remainder
|
||||
|
||||
Returns:
|
||||
|
||||
Dividend / Divisor
|
||||
Remainder = Dividend mod Divisor
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
UINT64
|
||||
RShiftU64 (
|
||||
IN UINT64 Operand,
|
||||
IN UINTN Count
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be right shifted by 32 bits and returns the
|
||||
shifted value.
|
||||
Count is valid up 63. (Only Bits 0-5 is valid for Count)
|
||||
|
||||
Arguments:
|
||||
|
||||
Operand - Value to be shifted
|
||||
Count - Number of times to shift right.
|
||||
|
||||
Returns:
|
||||
|
||||
Value shifted right identified by the Count.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
UINT64
|
||||
LShiftU64 (
|
||||
IN UINT64 Operand,
|
||||
IN UINTN Count
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine allows a 64 bit value to be left shifted by 32 bits and
|
||||
returns the shifted value.
|
||||
Count is valid up 63. (Only Bits 0-5 is valid for Count)
|
||||
|
||||
Arguments:
|
||||
|
||||
Operand - Value to be shifted
|
||||
Count - Number of times to shift left.
|
||||
|
||||
Returns:
|
||||
|
||||
Value shifted left identified by the Count.
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
VOID
|
||||
RegisterNativeCpuIo (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
IN VOID *CpuIo
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Register a native Cpu IO
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - Calling context
|
||||
CpuIo - CpuIo instance to register
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
VOID
|
||||
GetNativeCpuIo (
|
||||
IN EFI_PEI_SERVICES **PeiServices,
|
||||
OUT VOID **CpuIo
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Get registered Cpu IO.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - Calling context
|
||||
CpuIo - CpuIo instance registered before
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#endif
|
233
Tools/Source/TianoTools/Common/PeiLib/Perf.c
Normal file
233
Tools/Source/TianoTools/Common/PeiLib/Perf.c
Normal file
@@ -0,0 +1,233 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004 - 2005, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Perf.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Support for performance primitives.
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "Pei.h"
|
||||
#include "PeiLib.h"
|
||||
#include "PeiHob.h"
|
||||
|
||||
#include EFI_GUID_DEFINITION (PeiPerformanceHob)
|
||||
|
||||
//
|
||||
// Perfomance HOB data definitions
|
||||
//
|
||||
|
||||
#define MAX_PEI_PERF_LOG_ENTRIES 28
|
||||
|
||||
//
|
||||
// Prototype functions
|
||||
//
|
||||
EFI_STATUS
|
||||
GetTimerValue (
|
||||
OUT UINT64 *TimerValue
|
||||
);
|
||||
|
||||
|
||||
VOID
|
||||
PeiPerfMeasure (
|
||||
EFI_PEI_SERVICES **PeiServices,
|
||||
IN UINT16 *Token,
|
||||
IN EFI_FFS_FILE_HEADER *FileHeader,
|
||||
IN BOOLEAN EntryExit,
|
||||
IN UINT64 Value
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Log a timestamp count.
|
||||
|
||||
Arguments:
|
||||
|
||||
PeiServices - Pointer to the PEI Core Services table
|
||||
|
||||
Token - Pointer to Token Name
|
||||
|
||||
FileHeader - Pointer to the file header
|
||||
|
||||
EntryExit - Indicates start or stop measurement
|
||||
|
||||
Value - The start time or the stop time
|
||||
|
||||
Returns:
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
EFI_HOB_GUID_TYPE *Hob;
|
||||
EFI_HOB_GUID_DATA_PERFORMANCE_LOG *PerfHobData;
|
||||
PEI_PERFORMANCE_MEASURE_LOG_ENTRY *Log;
|
||||
EFI_PEI_PPI_DESCRIPTOR *PerfHobDescriptor;
|
||||
UINT64 TimeCount;
|
||||
INTN Index;
|
||||
UINTN Index2;
|
||||
EFI_GUID *Guid;
|
||||
EFI_GUID *CheckGuid;
|
||||
|
||||
TimeCount = 0;
|
||||
//
|
||||
// Get the END time as early as possible to make it more accurate.
|
||||
//
|
||||
if (EntryExit) {
|
||||
GetTimerValue (&TimeCount);
|
||||
}
|
||||
|
||||
//
|
||||
// Locate the Pei Performance Log Hob.
|
||||
//
|
||||
Status = (*PeiServices)->LocatePpi (
|
||||
PeiServices,
|
||||
&gEfiPeiPerformanceHobGuid,
|
||||
0,
|
||||
&PerfHobDescriptor,
|
||||
NULL
|
||||
);
|
||||
|
||||
//
|
||||
// If the Performance Hob was not found, build and install one.
|
||||
//
|
||||
if (EFI_ERROR(Status)) {
|
||||
Status = PeiBuildHobGuid (
|
||||
PeiServices,
|
||||
&gEfiPeiPerformanceHobGuid,
|
||||
(sizeof(EFI_HOB_GUID_DATA_PERFORMANCE_LOG) +
|
||||
((MAX_PEI_PERF_LOG_ENTRIES-1) *
|
||||
sizeof(PEI_PERFORMANCE_MEASURE_LOG_ENTRY)) +
|
||||
sizeof(EFI_PEI_PPI_DESCRIPTOR)
|
||||
),
|
||||
&Hob
|
||||
);
|
||||
ASSERT_PEI_ERROR(PeiServices, Status);
|
||||
|
||||
PerfHobData = (EFI_HOB_GUID_DATA_PERFORMANCE_LOG *)(Hob+1);
|
||||
PerfHobData->NumberOfEntries = 0;
|
||||
|
||||
PerfHobDescriptor = (EFI_PEI_PPI_DESCRIPTOR *)((UINT8 *)(PerfHobData+1) +
|
||||
(sizeof(PEI_PERFORMANCE_MEASURE_LOG_ENTRY) *
|
||||
(MAX_PEI_PERF_LOG_ENTRIES-1)
|
||||
)
|
||||
);
|
||||
PerfHobDescriptor->Flags = (EFI_PEI_PPI_DESCRIPTOR_PPI | EFI_PEI_PPI_DESCRIPTOR_TERMINATE_LIST);
|
||||
PerfHobDescriptor->Guid = &gEfiPeiPerformanceHobGuid;
|
||||
PerfHobDescriptor->Ppi = NULL;
|
||||
|
||||
(*PeiServices)->InstallPpi (
|
||||
PeiServices,
|
||||
PerfHobDescriptor
|
||||
);
|
||||
}
|
||||
|
||||
PerfHobData = (EFI_HOB_GUID_DATA_PERFORMANCE_LOG *)(((UINT8 *)(PerfHobDescriptor)) -
|
||||
((sizeof(PEI_PERFORMANCE_MEASURE_LOG_ENTRY) *
|
||||
(MAX_PEI_PERF_LOG_ENTRIES-1)
|
||||
)
|
||||
+ sizeof(EFI_HOB_GUID_DATA_PERFORMANCE_LOG)
|
||||
)
|
||||
);
|
||||
|
||||
if (PerfHobData->NumberOfEntries >= MAX_PEI_PERF_LOG_ENTRIES) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!EntryExit) {
|
||||
Log = &(PerfHobData->Log[PerfHobData->NumberOfEntries]);
|
||||
(*PeiServices)->SetMem (Log, sizeof(PEI_PERFORMANCE_MEASURE_LOG_ENTRY), 0);
|
||||
|
||||
//
|
||||
// If not NULL pointer, copy the file name
|
||||
//
|
||||
if (FileHeader != NULL) {
|
||||
Log->Name = FileHeader->Name;
|
||||
}
|
||||
|
||||
//
|
||||
// Copy the description string
|
||||
//
|
||||
(*PeiServices)->CopyMem (
|
||||
&(Log->DescriptionString),
|
||||
Token,
|
||||
(PEI_PERF_MAX_DESC_STRING-1) * sizeof(UINT16)
|
||||
);
|
||||
|
||||
//
|
||||
// Get the start time as late as possible to make it more accurate.
|
||||
//
|
||||
GetTimerValue (&TimeCount);
|
||||
|
||||
//
|
||||
// Record the time stamp.
|
||||
//
|
||||
if (Value != 0) {
|
||||
Log->StartTimeCount = Value;
|
||||
} else {
|
||||
Log->StartTimeCount = TimeCount;
|
||||
}
|
||||
Log->StopTimeCount = 0;
|
||||
|
||||
//
|
||||
// Increment the number of valid log entries.
|
||||
//
|
||||
PerfHobData->NumberOfEntries++;
|
||||
|
||||
} else {
|
||||
|
||||
for (Index = PerfHobData->NumberOfEntries-1; Index >= 0; Index--) {
|
||||
Log = NULL;
|
||||
for (Index2 = 0; Index2 < PEI_PERF_MAX_DESC_STRING; Index2++) {
|
||||
if (PerfHobData->Log[Index].DescriptionString[Index2] == 0) {
|
||||
Log = &(PerfHobData->Log[Index]);
|
||||
break;
|
||||
}
|
||||
if (PerfHobData->Log[Index].DescriptionString[Index2] !=
|
||||
Token[Index2]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (Log != NULL) {
|
||||
if (FileHeader != NULL) {
|
||||
Guid = &(Log->Name);
|
||||
CheckGuid = &(FileHeader->Name);
|
||||
if ((((INT32 *)Guid)[0] == ((INT32 *)CheckGuid)[0]) &&
|
||||
(((INT32 *)Guid)[1] == ((INT32 *)CheckGuid)[1]) &&
|
||||
(((INT32 *)Guid)[2] == ((INT32 *)CheckGuid)[2]) &&
|
||||
(((INT32 *)Guid)[3] == ((INT32 *)CheckGuid)[3])) {
|
||||
if (Value != 0) {
|
||||
Log->StopTimeCount = Value;
|
||||
} else {
|
||||
Log->StopTimeCount = TimeCount;
|
||||
}
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (Value != 0) {
|
||||
Log->StopTimeCount = Value;
|
||||
} else {
|
||||
Log->StopTimeCount = TimeCount;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
736
Tools/Source/TianoTools/Common/PeiLib/Print/Print.c
Normal file
736
Tools/Source/TianoTools/Common/PeiLib/Print/Print.c
Normal file
@@ -0,0 +1,736 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Print.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Basic Ascii AvSPrintf() function named AvSPrint(). AvSPrint() enables very
|
||||
simple implemenation of debug prints.
|
||||
|
||||
You can not Print more than PEI_LIB_MAX_PRINT_BUFFER characters at a
|
||||
time. This makes the implementation very simple.
|
||||
|
||||
AvSPrint format specification has the follwoing form
|
||||
|
||||
%[flags][width]type
|
||||
|
||||
flags:
|
||||
'-' - Left justify
|
||||
'+' - Prefix a sign
|
||||
' ' - Prefix a blank
|
||||
',' - Place commas in numberss
|
||||
'0' - Prefix for width with zeros
|
||||
'l' - UINT64
|
||||
'L' - UINT64
|
||||
|
||||
width:
|
||||
'*' - Get width from a UINTN argumnet from the argument list
|
||||
Decimal number that represents width of print
|
||||
|
||||
type:
|
||||
'X' - argument is a UINTN hex number, prefix '0'
|
||||
'x' - argument is a hex number
|
||||
'd' - argument is a decimal number
|
||||
'a' - argument is an ascii string
|
||||
'S', 's' - argument is an Unicode string
|
||||
'g' - argument is a pointer to an EFI_GUID
|
||||
't' - argument is a pointer to an EFI_TIME structure
|
||||
'c' - argument is an ascii character
|
||||
'r' - argument is EFI_STATUS
|
||||
'%' - Print a %
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "Pei.h"
|
||||
#include "PeiLib.h"
|
||||
#include "Print.h"
|
||||
|
||||
|
||||
STATIC
|
||||
CHAR8 *
|
||||
GetFlagsAndWidth (
|
||||
IN CHAR8 *Format,
|
||||
OUT UINTN *Flags,
|
||||
OUT UINTN *Width,
|
||||
IN OUT VA_LIST *Marker
|
||||
);
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
ValueToString (
|
||||
IN OUT CHAR8 *Buffer,
|
||||
IN INT64 Value,
|
||||
IN UINTN Flags,
|
||||
IN UINTN Width
|
||||
);
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
ValueTomHexStr (
|
||||
IN OUT CHAR8 *Buffer,
|
||||
IN UINT64 Value,
|
||||
IN UINTN Flags,
|
||||
IN UINTN Width
|
||||
);
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
GuidToString (
|
||||
IN EFI_GUID *Guid,
|
||||
IN OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize
|
||||
);
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
TimeToString (
|
||||
IN EFI_TIME *Time,
|
||||
IN OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize
|
||||
);
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
EfiStatusToString (
|
||||
IN EFI_STATUS Status,
|
||||
OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize
|
||||
);
|
||||
|
||||
|
||||
UINTN
|
||||
ASPrint (
|
||||
OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize,
|
||||
IN CONST CHAR8 *Format,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
ASPrint function to process format and place the results in Buffer.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Ascii buffer to print the results of the parsing of Format into.
|
||||
|
||||
BufferSize - Maximum number of characters to put into buffer. Zero means no
|
||||
limit.
|
||||
|
||||
Format - Ascii format string see file header for more details.
|
||||
|
||||
... - Vararg list consumed by processing Format.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Return;
|
||||
VA_LIST Marker;
|
||||
|
||||
VA_START(Marker, Format);
|
||||
Return = AvSPrint(Buffer, BufferSize, Format, Marker);
|
||||
VA_END (Marker);
|
||||
|
||||
return Return;
|
||||
}
|
||||
|
||||
|
||||
UINTN
|
||||
AvSPrint (
|
||||
OUT CHAR8 *StartOfBuffer,
|
||||
IN UINTN BufferSize,
|
||||
IN CONST CHAR8 *FormatString,
|
||||
IN VA_LIST Marker
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint function to process format and place the results in Buffer. Since a
|
||||
VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
|
||||
this is the main print working routine
|
||||
|
||||
Arguments:
|
||||
|
||||
StartOfBuffer - Ascii buffer to print the results of the parsing of Format into.
|
||||
|
||||
BufferSize - Maximum number of characters to put into buffer. Zero means
|
||||
no limit.
|
||||
|
||||
FormatString - Ascii format string see file header for more details.
|
||||
|
||||
Marker - Vararg list consumed by processing Format.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *Buffer;
|
||||
CHAR8 *AsciiStr;
|
||||
CHAR16 *UnicodeStr;
|
||||
CHAR8 *Format;
|
||||
UINTN Index;
|
||||
UINTN Flags;
|
||||
UINTN Width;
|
||||
UINT64 Value;
|
||||
|
||||
//
|
||||
// Process the format string. Stop if Buffer is over run.
|
||||
//
|
||||
|
||||
Buffer = StartOfBuffer;
|
||||
Format = (CHAR8 *)FormatString;
|
||||
for (Index = 0; (*Format != '\0') && (Index < BufferSize); Format++) {
|
||||
if (*Format != '%') {
|
||||
if (*Format == '\n') {
|
||||
//
|
||||
// If carage return add line feed
|
||||
//
|
||||
Buffer[Index++] = '\r';
|
||||
}
|
||||
Buffer[Index++] = *Format;
|
||||
} else {
|
||||
|
||||
//
|
||||
// Now it's time to parse what follows after %
|
||||
//
|
||||
Format = GetFlagsAndWidth (Format, &Flags, &Width, &Marker);
|
||||
switch (*Format) {
|
||||
case 'X':
|
||||
Flags |= PREFIX_ZERO;
|
||||
Width = sizeof (UINT64) * 2;
|
||||
//
|
||||
// break skiped on purpose
|
||||
//
|
||||
case 'x':
|
||||
if ((Flags & LONG_TYPE) == LONG_TYPE) {
|
||||
Value = VA_ARG (Marker, UINT64);
|
||||
} else {
|
||||
Value = VA_ARG (Marker, UINTN);
|
||||
}
|
||||
Index += ValueTomHexStr (&Buffer[Index], Value, Flags, Width);
|
||||
break;
|
||||
|
||||
case 'd':
|
||||
if ((Flags & LONG_TYPE) == LONG_TYPE) {
|
||||
Value = VA_ARG (Marker, UINT64);
|
||||
} else {
|
||||
Value = (UINTN)VA_ARG (Marker, UINTN);
|
||||
}
|
||||
Index += ValueToString (&Buffer[Index], Value, Flags, Width);
|
||||
break;
|
||||
|
||||
case 's':
|
||||
case 'S':
|
||||
UnicodeStr = (CHAR16 *)VA_ARG (Marker, CHAR16 *);
|
||||
if (UnicodeStr == NULL) {
|
||||
UnicodeStr = L"<null string>";
|
||||
}
|
||||
for ( ;*UnicodeStr != '\0'; UnicodeStr++) {
|
||||
Buffer[Index++] = (CHAR8)*UnicodeStr;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'a':
|
||||
AsciiStr = (CHAR8 *)VA_ARG (Marker, CHAR8 *);
|
||||
if (AsciiStr == NULL) {
|
||||
AsciiStr = "<null string>";
|
||||
}
|
||||
while (*AsciiStr != '\0') {
|
||||
Buffer[Index++] = *AsciiStr++;
|
||||
}
|
||||
break;
|
||||
|
||||
case 'c':
|
||||
Buffer[Index++] = (CHAR8)VA_ARG (Marker, UINTN);
|
||||
break;
|
||||
|
||||
case 'g':
|
||||
Index += GuidToString (
|
||||
VA_ARG (Marker, EFI_GUID *),
|
||||
&Buffer[Index],
|
||||
BufferSize
|
||||
);
|
||||
break;
|
||||
|
||||
case 't':
|
||||
Index += TimeToString (
|
||||
VA_ARG (Marker, EFI_TIME *),
|
||||
&Buffer[Index],
|
||||
BufferSize
|
||||
);
|
||||
break;
|
||||
|
||||
case 'r':
|
||||
Index += EfiStatusToString (
|
||||
VA_ARG (Marker, EFI_STATUS),
|
||||
&Buffer[Index],
|
||||
BufferSize
|
||||
);
|
||||
break;
|
||||
|
||||
case '%':
|
||||
Buffer[Index++] = *Format;
|
||||
break;
|
||||
|
||||
default:
|
||||
//
|
||||
// if the type is unknown print it to the screen
|
||||
//
|
||||
Buffer[Index++] = *Format;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Buffer[Index++] = '\0';
|
||||
|
||||
return &Buffer[Index] - StartOfBuffer;
|
||||
}
|
||||
|
||||
|
||||
|
||||
STATIC
|
||||
CHAR8 *
|
||||
GetFlagsAndWidth (
|
||||
IN CHAR8 *Format,
|
||||
OUT UINTN *Flags,
|
||||
OUT UINTN *Width,
|
||||
IN OUT VA_LIST *Marker
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint worker function that parses flag and width information from the
|
||||
Format string and returns the next index into the Format string that needs
|
||||
to be parsed. See file headed for details of Flag and Width.
|
||||
|
||||
Arguments:
|
||||
|
||||
Format - Current location in the AvSPrint format string.
|
||||
|
||||
Flags - Returns flags
|
||||
|
||||
Width - Returns width of element
|
||||
|
||||
Marker - Vararg list that may be paritally consumed and returned.
|
||||
|
||||
Returns:
|
||||
|
||||
Pointer indexed into the Format string for all the information parsed
|
||||
by this routine.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Count;
|
||||
BOOLEAN Done;
|
||||
|
||||
*Flags = 0;
|
||||
*Width = 0;
|
||||
for (Done = FALSE; !Done; ) {
|
||||
Format++;
|
||||
|
||||
switch (*Format) {
|
||||
|
||||
case '-': *Flags |= LEFT_JUSTIFY; break;
|
||||
case '+': *Flags |= PREFIX_SIGN; break;
|
||||
case ' ': *Flags |= PREFIX_BLANK; break;
|
||||
case ',': *Flags |= COMMA_TYPE; break;
|
||||
case 'L':
|
||||
case 'l': *Flags |= LONG_TYPE; break;
|
||||
|
||||
case '*':
|
||||
*Width = VA_ARG (*Marker, UINTN);
|
||||
break;
|
||||
|
||||
case '0':
|
||||
*Flags |= PREFIX_ZERO;
|
||||
case '1':
|
||||
case '2':
|
||||
case '3':
|
||||
case '4':
|
||||
case '5':
|
||||
case '6':
|
||||
case '7':
|
||||
case '8':
|
||||
case '9':
|
||||
Count = 0;
|
||||
do {
|
||||
Count = (Count * 10) + *Format - '0';
|
||||
Format++;
|
||||
} while ((*Format >= '0') && (*Format <= '9'));
|
||||
Format--;
|
||||
*Width = Count;
|
||||
break;
|
||||
|
||||
default:
|
||||
Done = TRUE;
|
||||
}
|
||||
}
|
||||
return Format;
|
||||
}
|
||||
|
||||
static CHAR8 mHexStr[] = { '0','1','2','3','4','5','6','7',
|
||||
'8','9','A','B','C','D','E','F' };
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
ValueTomHexStr (
|
||||
IN OUT CHAR8 *Buffer,
|
||||
IN UINT64 Value,
|
||||
IN UINTN Flags,
|
||||
IN UINTN Width
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint worker function that prints a Value as a hex number in Buffer
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Location to place ascii hex string of Value.
|
||||
|
||||
Value - Hex value to convert to a string in Buffer.
|
||||
|
||||
Flags - Flags to use in printing Hex string, see file header for details.
|
||||
|
||||
Width - Width of hex value.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 TempBuffer[30];
|
||||
CHAR8 *TempStr;
|
||||
CHAR8 Prefix;
|
||||
CHAR8 *BufferPtr;
|
||||
UINTN Count;
|
||||
UINTN Index;
|
||||
|
||||
TempStr = TempBuffer;
|
||||
BufferPtr = Buffer;
|
||||
|
||||
//
|
||||
// Count starts at one since we will null terminate. Each iteration of the
|
||||
// loop picks off one nibble. Oh yea TempStr ends up backwards
|
||||
//
|
||||
Count = 0;
|
||||
do {
|
||||
*(TempStr++) = mHexStr[Value & 0x0f];
|
||||
Value = RShiftU64 (Value, 4);
|
||||
Count++;
|
||||
} while (Value != 0);
|
||||
|
||||
if (Flags & PREFIX_ZERO) {
|
||||
Prefix = '0';
|
||||
} else if (!(Flags & LEFT_JUSTIFY)) {
|
||||
Prefix = ' ';
|
||||
} else {
|
||||
Prefix = 0x00;
|
||||
}
|
||||
for (Index = Count; Index < Width; Index++) {
|
||||
*(TempStr++) = Prefix;
|
||||
}
|
||||
|
||||
//
|
||||
// Reverse temp string into Buffer.
|
||||
//
|
||||
while (TempStr != TempBuffer) {
|
||||
*(BufferPtr++) = *(--TempStr);
|
||||
}
|
||||
|
||||
*BufferPtr = 0;
|
||||
return Index;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
ValueToString (
|
||||
IN OUT CHAR8 *Buffer,
|
||||
IN INT64 Value,
|
||||
IN UINTN Flags,
|
||||
IN UINTN Width
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint worker function that prints a Value as a decimal number in Buffer
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Location to place ascii decimal number string of Value.
|
||||
|
||||
Value - Decimal value to convert to a string in Buffer.
|
||||
|
||||
Flags - Flags to use in printing decimal string, see file header for details.
|
||||
|
||||
Width - Width of hex value.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 TempBuffer[30];
|
||||
CHAR8 *TempStr;
|
||||
CHAR8 *BufferPtr;
|
||||
UINTN Count;
|
||||
UINTN Remainder;
|
||||
|
||||
TempStr = TempBuffer;
|
||||
BufferPtr = Buffer;
|
||||
Count = 0;
|
||||
|
||||
if (Value < 0) {
|
||||
*(BufferPtr++) = '-';
|
||||
Value = -Value;
|
||||
Count++;
|
||||
}
|
||||
|
||||
do {
|
||||
Value = (INT64)DivU64x32 ((UINT64)Value, 10, &Remainder);
|
||||
*(TempStr++) = (CHAR8)(Remainder + '0');
|
||||
Count++;
|
||||
if ((Flags & COMMA_TYPE) == COMMA_TYPE) {
|
||||
if (Count % 3 == 0) {
|
||||
*(TempStr++) = ',';
|
||||
}
|
||||
}
|
||||
} while (Value != 0);
|
||||
|
||||
//
|
||||
// Reverse temp string into Buffer.
|
||||
//
|
||||
while (TempStr != TempBuffer) {
|
||||
*(BufferPtr++) = *(--TempStr);
|
||||
}
|
||||
|
||||
*BufferPtr = 0;
|
||||
return Count;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
GuidToString (
|
||||
IN EFI_GUID *Guid,
|
||||
IN CHAR8 *Buffer,
|
||||
IN UINTN BufferSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint worker function that prints an EFI_GUID.
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid - Pointer to GUID to print.
|
||||
|
||||
Buffer - Buffe to print Guid into.
|
||||
|
||||
BufferSize - Size of Buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Size;
|
||||
|
||||
Size = ASPrint (
|
||||
Buffer,
|
||||
BufferSize,
|
||||
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
|
||||
//
|
||||
// ASPrint will null terminate the string. The -1 skips the null
|
||||
//
|
||||
return Size - 1;
|
||||
}
|
||||
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
TimeToString (
|
||||
IN EFI_TIME *Time,
|
||||
OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint worker function that prints EFI_TIME.
|
||||
|
||||
Arguments:
|
||||
|
||||
Time - Pointer to EFI_TIME sturcture to print.
|
||||
|
||||
Buffer - Buffer to print Time into.
|
||||
|
||||
BufferSize - Size of Buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Size;
|
||||
|
||||
Size = ASPrint (
|
||||
Buffer,
|
||||
BufferSize,
|
||||
"%02d/%02d/%04d %02d:%02d",
|
||||
Time->Month,
|
||||
Time->Day,
|
||||
Time->Year,
|
||||
Time->Hour,
|
||||
Time->Minute
|
||||
);
|
||||
|
||||
//
|
||||
// ASPrint will null terminate the string. The -1 skips the null
|
||||
//
|
||||
return Size - 1;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINTN
|
||||
EfiStatusToString (
|
||||
IN EFI_STATUS Status,
|
||||
OUT CHAR8 *Buffer,
|
||||
IN UINTN BufferSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
AvSPrint worker function that prints EFI_STATUS as a string. If string is
|
||||
not known a hex value will be printed.
|
||||
|
||||
Arguments:
|
||||
|
||||
Status - EFI_STATUS sturcture to print.
|
||||
|
||||
Buffer - Buffer to print EFI_STATUS message string into.
|
||||
|
||||
BufferSize - Size of Buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
Number of characters printed.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Size;
|
||||
CHAR8 *Desc;
|
||||
|
||||
if (Status == EFI_SUCCESS) {
|
||||
Desc = "Success";
|
||||
} else if (Status == EFI_LOAD_ERROR) {
|
||||
Desc = "Load Error";
|
||||
} else if (Status == EFI_INVALID_PARAMETER) {
|
||||
Desc = "Invalid Parameter";
|
||||
} else if (Status == EFI_UNSUPPORTED) {
|
||||
Desc = "Unsupported";
|
||||
} else if (Status == EFI_BAD_BUFFER_SIZE) {
|
||||
Desc = "Bad Buffer Size";
|
||||
} else if (Status == EFI_BUFFER_TOO_SMALL) {
|
||||
Desc = "Buffer Too Small";
|
||||
} else if (Status == EFI_NOT_READY) {
|
||||
Desc = "Not Ready";
|
||||
} else if (Status == EFI_DEVICE_ERROR) {
|
||||
Desc = "Device Error";
|
||||
} else if (Status == EFI_WRITE_PROTECTED) {
|
||||
Desc = "Write Protected";
|
||||
} else if (Status == EFI_OUT_OF_RESOURCES) {
|
||||
Desc = "Out of Resources";
|
||||
} else if (Status == EFI_VOLUME_CORRUPTED) {
|
||||
Desc = "Volume Corrupt";
|
||||
} else if (Status == EFI_VOLUME_FULL) {
|
||||
Desc = "Volume Full";
|
||||
} else if (Status == EFI_NO_MEDIA) {
|
||||
Desc = "No Media";
|
||||
} else if (Status == EFI_MEDIA_CHANGED) {
|
||||
Desc = "Media changed";
|
||||
} else if (Status == EFI_NOT_FOUND) {
|
||||
Desc = "Not Found";
|
||||
} else if (Status == EFI_ACCESS_DENIED) {
|
||||
Desc = "Access Denied";
|
||||
} else if (Status == EFI_NO_RESPONSE) {
|
||||
Desc = "No Response";
|
||||
} else if (Status == EFI_NO_MAPPING) {
|
||||
Desc = "No mapping";
|
||||
} else if (Status == EFI_TIMEOUT) {
|
||||
Desc = "Time out";
|
||||
} else if (Status == EFI_NOT_STARTED) {
|
||||
Desc = "Not started";
|
||||
} else if (Status == EFI_ALREADY_STARTED) {
|
||||
Desc = "Already started";
|
||||
} else if (Status == EFI_ABORTED) {
|
||||
Desc = "Aborted";
|
||||
} else if (Status == EFI_ICMP_ERROR) {
|
||||
Desc = "ICMP Error";
|
||||
} else if (Status == EFI_TFTP_ERROR) {
|
||||
Desc = "TFTP Error";
|
||||
} else if (Status == EFI_PROTOCOL_ERROR) {
|
||||
Desc = "Protocol Error";
|
||||
} else if (Status == EFI_WARN_UNKNOWN_GLYPH) {
|
||||
Desc = "Warning Unknown Glyph";
|
||||
} else if (Status == EFI_WARN_DELETE_FAILURE) {
|
||||
Desc = "Warning Delete Failure";
|
||||
} else if (Status == EFI_WARN_WRITE_FAILURE) {
|
||||
Desc = "Warning Write Failure";
|
||||
} else if (Status == EFI_WARN_BUFFER_TOO_SMALL) {
|
||||
Desc = "Warning Buffer Too Small";
|
||||
} else {
|
||||
Desc = NULL;
|
||||
}
|
||||
//
|
||||
// If we found a match, copy the message to the user's buffer. Otherwise
|
||||
// sprint the hex status code to their buffer.
|
||||
//
|
||||
if (Desc != NULL) {
|
||||
Size = ASPrint (Buffer, BufferSize, "%a", Desc);
|
||||
} else {
|
||||
Size = ASPrint (Buffer, BufferSize, "%X", Status);
|
||||
}
|
||||
return Size - 1;
|
||||
}
|
37
Tools/Source/TianoTools/Common/PeiLib/Print/Print.h
Normal file
37
Tools/Source/TianoTools/Common/PeiLib/Print/Print.h
Normal file
@@ -0,0 +1,37 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Print.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Private data for Print.c
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _PRINT_H_
|
||||
#define _PRINT_H_
|
||||
|
||||
#define LEFT_JUSTIFY 0x01
|
||||
#define PREFIX_SIGN 0x02
|
||||
#define PREFIX_BLANK 0x04
|
||||
#define COMMA_TYPE 0x08
|
||||
#define LONG_TYPE 0x10
|
||||
#define PREFIX_ZERO 0x20
|
||||
|
||||
//
|
||||
// Largest number of characters that can be printed out.
|
||||
//
|
||||
#define PEI_LIB_MAX_PRINT_BUFFER (80 * 4)
|
||||
|
||||
#endif
|
56
Tools/Source/TianoTools/Common/PeiLib/ia32/PeCoffLoaderEx.c
Normal file
56
Tools/Source/TianoTools/Common/PeiLib/ia32/PeCoffLoaderEx.c
Normal file
@@ -0,0 +1,56 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PeCoffLoaderEx.c
|
||||
|
||||
Abstract:
|
||||
|
||||
IA-32 Specific relocation fixups
|
||||
|
||||
Revision History
|
||||
|
||||
--*/
|
||||
|
||||
#include "TianoCommon.h"
|
||||
|
||||
EFI_STATUS
|
||||
PeCoffLoaderRelocateImageEx (
|
||||
IN UINT16 *Reloc,
|
||||
IN OUT CHAR8 *Fixup,
|
||||
IN OUT CHAR8 **FixupData,
|
||||
IN UINT64 Adjust
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Performs an IA-32 specific relocation fixup
|
||||
|
||||
Arguments:
|
||||
|
||||
Reloc - Pointer to the relocation record
|
||||
|
||||
Fixup - Pointer to the address to fix up
|
||||
|
||||
FixupData - Pointer to a buffer to log the fixups
|
||||
|
||||
Adjust - The offset to adjust the fixup
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_UNSUPPORTED - Unsupported now
|
||||
|
||||
--*/
|
||||
{
|
||||
return EFI_UNSUPPORTED;
|
||||
}
|
65
Tools/Source/TianoTools/Common/PeiLib/ia32/PeCoffLoaderEx.h
Normal file
65
Tools/Source/TianoTools/Common/PeiLib/ia32/PeCoffLoaderEx.h
Normal file
@@ -0,0 +1,65 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PeCoffLoaderEx.h
|
||||
|
||||
Abstract:
|
||||
|
||||
IA-32 Specific relocation fixups
|
||||
|
||||
Revision History
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _PE_COFF_LOADER_EX_H_
|
||||
#define _PE_COFF_LOADER_EX_H_
|
||||
|
||||
//
|
||||
// Define macro to determine if the machine type is supported.
|
||||
// Returns 0 if the machine is not supported, Not 0 otherwise.
|
||||
//
|
||||
#define EFI_IMAGE_MACHINE_TYPE_SUPPORTED(Machine) \
|
||||
((Machine) == EFI_IMAGE_MACHINE_IA32 || \
|
||||
(Machine) == EFI_IMAGE_MACHINE_EBC)
|
||||
|
||||
EFI_STATUS
|
||||
PeCoffLoaderRelocateImageEx (
|
||||
IN UINT16 *Reloc,
|
||||
IN OUT CHAR8 *Fixup,
|
||||
IN OUT CHAR8 **FixupData,
|
||||
IN UINT64 Adjust
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Performs an IA-32 specific relocation fixup
|
||||
|
||||
Arguments:
|
||||
|
||||
Reloc - Pointer to the relocation record
|
||||
|
||||
Fixup - Pointer to the address to fix up
|
||||
|
||||
FixupData - Pointer to a buffer to log the fixups
|
||||
|
||||
Adjust - The offset to adjust the fixup
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_UNSUPPORTED - Unsupported now
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#endif
|
@@ -0,0 +1,47 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
PerformancePrimitives.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Support for Performance library
|
||||
|
||||
--*/
|
||||
|
||||
#include "TianoCommon.h"
|
||||
#include "CpuIA32.h"
|
||||
|
||||
EFI_STATUS
|
||||
GetTimerValue (
|
||||
OUT UINT64 *TimerValue
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Get timer value.
|
||||
|
||||
Arguments:
|
||||
|
||||
TimerValue - Pointer to the returned timer value
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Successfully got timer value
|
||||
|
||||
--*/
|
||||
{
|
||||
*TimerValue = EfiReadTsc ();
|
||||
return EFI_SUCCESS;
|
||||
}
|
140
Tools/Source/TianoTools/Common/PeiLib/ia32/Processor.c
Normal file
140
Tools/Source/TianoTools/Common/PeiLib/ia32/Processor.c
Normal file
@@ -0,0 +1,140 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004 - 2005, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Processor.c
|
||||
|
||||
Abstract:
|
||||
|
||||
--*/
|
||||
|
||||
#include "Tiano.h"
|
||||
#include "EfiJump.h"
|
||||
#include EFI_GUID_DEFINITION (PeiFlushInstructionCache)
|
||||
#include EFI_GUID_DEFINITION (PeiTransferControl)
|
||||
|
||||
//
|
||||
// Prototypes
|
||||
//
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
TransferControlSetJump (
|
||||
IN EFI_PEI_TRANSFER_CONTROL_PROTOCOL *This,
|
||||
IN EFI_JUMP_BUFFER *Jump
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
TransferControlLongJump (
|
||||
IN EFI_PEI_TRANSFER_CONTROL_PROTOCOL *This,
|
||||
IN EFI_JUMP_BUFFER *Jump
|
||||
);
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FlushInstructionCacheFlush (
|
||||
IN EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL *This,
|
||||
IN EFI_PHYSICAL_ADDRESS Start,
|
||||
IN UINT64 Length
|
||||
);
|
||||
|
||||
//
|
||||
// Table declarations
|
||||
//
|
||||
EFI_PEI_TRANSFER_CONTROL_PROTOCOL mTransferControl = {
|
||||
TransferControlSetJump,
|
||||
TransferControlLongJump,
|
||||
sizeof (EFI_JUMP_BUFFER)
|
||||
};
|
||||
|
||||
EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL mFlushInstructionCache = {
|
||||
FlushInstructionCacheFlush
|
||||
};
|
||||
|
||||
|
||||
EFI_STATUS
|
||||
InstallEfiPeiTransferControl (
|
||||
IN OUT EFI_PEI_TRANSFER_CONTROL_PROTOCOL **This
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Installs the pointer to the transfer control mechanism
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to transfer control mechanism.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Successfully installed.
|
||||
|
||||
--*/
|
||||
{
|
||||
*This = &mTransferControl;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
InstallEfiPeiFlushInstructionCache (
|
||||
IN OUT EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL **This
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Installs the pointer to the flush instruction cache mechanism
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to flush instruction cache mechanism.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Successfully installed
|
||||
|
||||
--*/
|
||||
{
|
||||
*This = &mFlushInstructionCache;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
EFIAPI
|
||||
FlushInstructionCacheFlush (
|
||||
IN EFI_PEI_FLUSH_INSTRUCTION_CACHE_PROTOCOL *This,
|
||||
IN EFI_PHYSICAL_ADDRESS Start,
|
||||
IN UINT64 Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This routine would provide support for flushing the CPU instruction cache.
|
||||
In the case of IA32, this flushing is not necessary and is thus not implemented.
|
||||
|
||||
Arguments:
|
||||
|
||||
This - Pointer to CPU Architectural Protocol interface
|
||||
Start - Start adddress in memory to flush
|
||||
Length - Length of memory to flush
|
||||
|
||||
Returns:
|
||||
|
||||
Status
|
||||
EFI_SUCCESS
|
||||
|
||||
--*/
|
||||
{
|
||||
return EFI_SUCCESS;
|
||||
}
|
223
Tools/Source/TianoTools/Common/PeiLib/ia32/ProcessorAsms.Asm
Normal file
223
Tools/Source/TianoTools/Common/PeiLib/ia32/ProcessorAsms.Asm
Normal file
@@ -0,0 +1,223 @@
|
||||
;
|
||||
; Copyright (c) 2004, Intel Corporation
|
||||
; All rights reserved. This program and the accompanying materials
|
||||
; are licensed and made available under the terms and conditions of the BSD License
|
||||
; which accompanies this distribution. The full text of the license may be found at
|
||||
; http://opensource.org/licenses/bsd-license.php
|
||||
;
|
||||
; THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
; WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
;
|
||||
; Module Name:
|
||||
;
|
||||
; ProcessorAsms.Asm
|
||||
;
|
||||
; Abstract:
|
||||
; This is separated from processor.c to allow this functions to be built with /O1
|
||||
;
|
||||
; Notes:
|
||||
; - Masm uses "This", "ebx", etc as a directive.
|
||||
; - H2INC is still not embedded in our build process so I translated the struc manually.
|
||||
; - Unreferenced variables/arguments (This, NewBsp, NewStack) were causing compile errors and
|
||||
; did not know of "pragma" mechanism in MASM and I did not want to reduce the warning level.
|
||||
; Instead, I did a dummy referenced.
|
||||
;
|
||||
|
||||
.686P
|
||||
.MMX
|
||||
.MODEL SMALL
|
||||
.CODE
|
||||
|
||||
EFI_SUCCESS equ 0
|
||||
EFI_WARN_RETURN_FROM_LONG_JUMP equ 5
|
||||
|
||||
;
|
||||
; Generated by h2inc run manually
|
||||
;
|
||||
_EFI_JUMP_BUFFER STRUCT 2t
|
||||
_ebx DWORD ?
|
||||
_esi DWORD ?
|
||||
_edi DWORD ?
|
||||
_ebp DWORD ?
|
||||
_esp DWORD ?
|
||||
_eip DWORD ?
|
||||
_EFI_JUMP_BUFFER ENDS
|
||||
|
||||
EFI_JUMP_BUFFER TYPEDEF _EFI_JUMP_BUFFER
|
||||
|
||||
TransferControlSetJump PROTO C \
|
||||
_This:PTR EFI_PEI_TRANSFER_CONTROL_PROTOCOL, \
|
||||
Jump:PTR EFI_JUMP_BUFFER
|
||||
|
||||
TransferControlLongJump PROTO C \
|
||||
_This:PTR EFI_PEI_TRANSFER_CONTROL_PROTOCOL, \
|
||||
Jump:PTR EFI_JUMP_BUFFER
|
||||
|
||||
SwitchStacks PROTO C \
|
||||
EntryPoint:PTR DWORD, \
|
||||
Parameter:DWORD, \
|
||||
NewStack:PTR DWORD, \
|
||||
NewBsp:PTR DWORD
|
||||
|
||||
SwitchIplStacks PROTO C \
|
||||
EntryPoint:PTR DWORD, \
|
||||
Parameter1:DWORD, \
|
||||
Parameter2:DWORD, \
|
||||
NewStack:PTR DWORD, \
|
||||
NewBsp:PTR DWORD
|
||||
|
||||
;
|
||||
;Routine Description:
|
||||
;
|
||||
; This routine implements the IA32 variant of the SetJump call. Its
|
||||
; responsibility is to store system state information for a possible
|
||||
; subsequent LongJump.
|
||||
;
|
||||
;Arguments:
|
||||
;
|
||||
; Pointer to CPU context save buffer.
|
||||
;
|
||||
;Returns:
|
||||
;
|
||||
; EFI_SUCCESS
|
||||
;
|
||||
TransferControlSetJump PROC C \
|
||||
_This:PTR EFI_PEI_TRANSFER_CONTROL_PROTOCOL, \
|
||||
Jump:PTR EFI_JUMP_BUFFER
|
||||
|
||||
mov eax, _This
|
||||
mov ecx, Jump
|
||||
mov (EFI_JUMP_BUFFER PTR [ecx])._ebx, ebx
|
||||
mov (EFI_JUMP_BUFFER PTR [ecx])._esi, esi
|
||||
mov (EFI_JUMP_BUFFER PTR [ecx])._edi, edi
|
||||
mov eax, [ebp]
|
||||
mov (EFI_JUMP_BUFFER PTR [ecx])._ebp, eax
|
||||
lea eax, [ebp+4]
|
||||
mov (EFI_JUMP_BUFFER PTR [ecx])._esp, eax
|
||||
mov eax, [ebp+4]
|
||||
mov (EFI_JUMP_BUFFER PTR [ecx])._eip, eax
|
||||
mov eax, EFI_SUCCESS
|
||||
|
||||
ret
|
||||
|
||||
TransferControlSetJump ENDP
|
||||
|
||||
;
|
||||
; Routine Description:
|
||||
;
|
||||
; This routine implements the IA32 variant of the LongJump call. Its
|
||||
; responsibility is restore the system state to the Context Buffer and
|
||||
; pass control back.
|
||||
;
|
||||
; Arguments:
|
||||
;
|
||||
; Pointer to CPU context save buffer.
|
||||
;
|
||||
; Returns:
|
||||
;
|
||||
; EFI_WARN_RETURN_FROM_LONG_JUMP
|
||||
;
|
||||
|
||||
TransferControlLongJump PROC C \
|
||||
_This:PTR EFI_PEI_TRANSFER_CONTROL_PROTOCOL, \
|
||||
Jump:PTR EFI_JUMP_BUFFER
|
||||
|
||||
push ebx
|
||||
push esi
|
||||
push edi
|
||||
|
||||
mov eax, _This
|
||||
; set return from SetJump to EFI_WARN_RETURN_FROM_LONG_JUMP
|
||||
mov eax, EFI_WARN_RETURN_FROM_LONG_JUMP
|
||||
mov ecx, Jump
|
||||
mov ebx, (EFI_JUMP_BUFFER PTR [ecx])._ebx
|
||||
mov esi, (EFI_JUMP_BUFFER PTR [ecx])._esi
|
||||
mov edi, (EFI_JUMP_BUFFER PTR [ecx])._edi
|
||||
mov ebp, (EFI_JUMP_BUFFER PTR [ecx])._ebp
|
||||
mov esp, (EFI_JUMP_BUFFER PTR [ecx])._esp
|
||||
add esp, 4 ;pop the eip
|
||||
jmp DWORD PTR (EFI_JUMP_BUFFER PTR [ecx])._eip
|
||||
mov eax, EFI_WARN_RETURN_FROM_LONG_JUMP
|
||||
|
||||
pop edi
|
||||
pop esi
|
||||
pop ebx
|
||||
ret
|
||||
|
||||
TransferControlLongJump ENDP
|
||||
|
||||
;
|
||||
; Routine Description:
|
||||
; This allows the caller to switch the stack and goes to the new entry point
|
||||
;
|
||||
; Arguments:
|
||||
; EntryPoint - Pointer to the location to enter
|
||||
; Parameter - Parameter to pass in
|
||||
; NewStack - New Location of the stack
|
||||
; NewBsp - New BSP
|
||||
;
|
||||
; Returns:
|
||||
;
|
||||
; Nothing. Goes to the Entry Point passing in the new parameters
|
||||
;
|
||||
SwitchStacks PROC C \
|
||||
EntryPoint:PTR DWORD, \
|
||||
Parameter:DWORD, \
|
||||
NewStack:PTR DWORD, \
|
||||
NewBsp:PTR DWORD
|
||||
|
||||
push ebx
|
||||
mov eax, NewBsp
|
||||
mov ebx, Parameter
|
||||
mov ecx, EntryPoint
|
||||
mov eax, NewStack
|
||||
mov esp, eax
|
||||
push ebx
|
||||
push 0
|
||||
jmp ecx
|
||||
|
||||
pop ebx
|
||||
ret
|
||||
|
||||
SwitchStacks ENDP
|
||||
|
||||
;
|
||||
; Routine Description:
|
||||
; This allows the caller to switch the stack and goes to the new entry point
|
||||
;
|
||||
; Arguments:
|
||||
; EntryPoint - Pointer to the location to enter
|
||||
; Parameter1/Parameter2 - Parameter to pass in
|
||||
; NewStack - New Location of the stack
|
||||
; NewBsp - New BSP
|
||||
;
|
||||
; Returns:
|
||||
;
|
||||
; Nothing. Goes to the Entry Point passing in the new parameters
|
||||
;
|
||||
SwitchIplStacks PROC C \
|
||||
EntryPoint:PTR DWORD, \
|
||||
Parameter1:DWORD, \
|
||||
Parameter2:DWORD, \
|
||||
NewStack:PTR DWORD, \
|
||||
NewBsp:PTR DWORD
|
||||
|
||||
push ebx
|
||||
mov eax, NewBsp
|
||||
mov ebx, Parameter1
|
||||
mov edx, Parameter2
|
||||
mov ecx, EntryPoint
|
||||
mov eax, NewStack
|
||||
mov esp, eax
|
||||
|
||||
push edx
|
||||
push ebx
|
||||
call ecx
|
||||
|
||||
pop ebx
|
||||
ret
|
||||
|
||||
SwitchIplStacks ENDP
|
||||
|
||||
END
|
||||
|
34
Tools/Source/TianoTools/Common/PeiLib/ia32/efijump.h
Normal file
34
Tools/Source/TianoTools/Common/PeiLib/ia32/efijump.h
Normal file
@@ -0,0 +1,34 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiJump.h
|
||||
|
||||
Abstract:
|
||||
|
||||
This is the Setjump/Longjump pair for an IA32 processor.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_JUMP_H_
|
||||
#define _EFI_JUMP_H_
|
||||
|
||||
typedef struct {
|
||||
UINT32 ebx;
|
||||
UINT32 esi;
|
||||
UINT32 edi;
|
||||
UINT32 ebp;
|
||||
UINT32 esp;
|
||||
UINT32 eip;
|
||||
} EFI_JUMP_BUFFER;
|
||||
|
||||
#endif
|
1460
Tools/Source/TianoTools/Common/SimpleFileParsing.c
Normal file
1460
Tools/Source/TianoTools/Common/SimpleFileParsing.c
Normal file
File diff suppressed because it is too large
Load Diff
121
Tools/Source/TianoTools/Common/SimpleFileParsing.h
Normal file
121
Tools/Source/TianoTools/Common/SimpleFileParsing.h
Normal file
@@ -0,0 +1,121 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
SimpleFileParsing.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Function prototypes and defines for the simple file parsing routines.
|
||||
|
||||
--*/
|
||||
|
||||
#include <Base.h>
|
||||
#include <UefiBaseTypes.h>
|
||||
|
||||
#ifndef _SIMPLE_FILE_PARSING_H_
|
||||
#define _SIMPLE_FILE_PARSING_H_
|
||||
|
||||
#define T_CHAR char
|
||||
|
||||
STATUS
|
||||
SFPInit (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
STATUS
|
||||
SFPOpenFile (
|
||||
char *FileName
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPIsKeyword (
|
||||
T_CHAR *Str
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPIsToken (
|
||||
T_CHAR *Str
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetNextToken (
|
||||
T_CHAR *Str,
|
||||
unsigned int Len
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetGuidToken (
|
||||
T_CHAR *Str,
|
||||
UINT32 Len
|
||||
)
|
||||
;
|
||||
|
||||
#define PARSE_GUID_STYLE_5_FIELDS 0
|
||||
|
||||
BOOLEAN
|
||||
SFPGetGuid (
|
||||
int GuidStyle,
|
||||
EFI_GUID *Value
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPSkipToToken (
|
||||
T_CHAR *Str
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetNumber (
|
||||
unsigned int *Value
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetQuotedString (
|
||||
T_CHAR *Str,
|
||||
int Length
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPIsEOF (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
STATUS
|
||||
SFPCloseFile (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
unsigned
|
||||
int
|
||||
SFPGetLineNumber (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
T_CHAR *
|
||||
SFPGetFileName (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
#endif // #ifndef _SIMPLE_FILE_PARSING_H_
|
73
Tools/Source/TianoTools/Common/WinNtInclude.h
Normal file
73
Tools/Source/TianoTools/Common/WinNtInclude.h
Normal file
@@ -0,0 +1,73 @@
|
||||
/*--
|
||||
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
WinNtInclude.h
|
||||
|
||||
Abstract:
|
||||
Include file for the WinNt Library
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef __WIN_NT_INCLUDE_H__
|
||||
#define __WIN_NT_INCLUDE_H__
|
||||
|
||||
//
|
||||
// Win32 include files do not compile clean with /W4, so we use the warning
|
||||
// pragma to suppress the warnings for Win32 only. This way our code can stil
|
||||
// compile at /W4 (highest warning level) with /WX (warnings cause build
|
||||
// errors).
|
||||
//
|
||||
#pragma warning(disable : 4115)
|
||||
#pragma warning(disable : 4201)
|
||||
#pragma warning(disable : 4214)
|
||||
#pragma warning(disable : 4028)
|
||||
#pragma warning(disable : 4133)
|
||||
|
||||
#define GUID _WINNT_DUP_GUID_____
|
||||
#define _LIST_ENTRY _WINNT_DUP_LIST_ENTRY_FORWARD
|
||||
#define LIST_ENTRY _WINNT_DUP_LIST_ENTRY
|
||||
#define InterlockedIncrement _WINNT_DUP_InterlockedIncrement
|
||||
#define InterlockedDecrement _WINNT_DUP_InterlockedDecrement
|
||||
#define InterlockedCompareExchange64 _WINNT_DUP_InterlockedCompareExchange64
|
||||
#undef UNALIGNED
|
||||
#undef CONST
|
||||
#undef VOID
|
||||
|
||||
#ifndef __GNUC__
|
||||
#include "windows.h"
|
||||
#endif
|
||||
|
||||
#undef GUID
|
||||
#undef _LIST_ENTRY
|
||||
#undef LIST_ENTRY
|
||||
#undef InterlockedIncrement
|
||||
#undef InterlockedDecrement
|
||||
#undef InterlockedCompareExchange64
|
||||
#undef InterlockedCompareExchangePointer
|
||||
|
||||
#define VOID void
|
||||
|
||||
//
|
||||
// Prevent collisions with Windows API name macros that deal with Unicode/Not issues
|
||||
//
|
||||
#undef LoadImage
|
||||
#undef CreateEvent
|
||||
|
||||
//
|
||||
// Set the warnings back on as the EFI code must be /W4.
|
||||
//
|
||||
#pragma warning(default : 4115)
|
||||
#pragma warning(default : 4201)
|
||||
#pragma warning(default : 4214)
|
||||
|
||||
|
||||
#endif
|
8
Tools/Source/TianoTools/Common/build.gcc
Normal file
8
Tools/Source/TianoTools/Common/build.gcc
Normal file
@@ -0,0 +1,8 @@
|
||||
mkdir -p ../Library-mingw
|
||||
mkdir -p ../Library-cygwin
|
||||
rm *.o
|
||||
gcc -c -I "$WORKSPACE/MdePkg/Include/" -I"$WORKSPACE/MdePkg/Include/Ia32/" -I"../Common/" -I$WORKSPACE/MdePkg/Include/Protocol/ -I$WORKSPACE/MdePkg/Include/Common/ *.c
|
||||
ar cr ../Library-cygwin/libCommon.a *.o
|
||||
rm *.o
|
||||
gcc -mno-cygwin -c -I "$WORKSPACE/MdePkg/Include/" -I"$WORKSPACE/MdePkg/Include/Ia32/" -I"../Common/" -I$WORKSPACE/MdePkg/Include/Protocol/ -I$WORKSPACE/MdePkg/Include/Common/ *.c
|
||||
ar cr ../Library-mingw/libCommon.a *.o
|
120
Tools/Source/TianoTools/Common/build.xml
Normal file
120
Tools/Source/TianoTools/Common/build.xml
Normal file
@@ -0,0 +1,120 @@
|
||||
<?xml version="1.0" ?>
|
||||
<!--
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
-->
|
||||
<project default="CommonTools.lib" basedir=".">
|
||||
<!--
|
||||
EDK Common Tools Library
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
-->
|
||||
|
||||
<taskdef resource="cpptasks.tasks"/>
|
||||
<typedef resource="cpptasks.types"/>
|
||||
<taskdef resource="net/sf/antcontrib/antlib.xml"/>
|
||||
|
||||
<property environment="env"/>
|
||||
<property name="tmp" value="tmp"/>
|
||||
|
||||
<property name="LINK_OUTPUT_TYPE" value="static"/>
|
||||
<property name="BUILD_DIR" value="${PACKAGE_DIR}/Common/tmp"/>
|
||||
|
||||
<target name="CommonTools.lib" depends="init, ToolsLibrary">
|
||||
<echo message="Building the EDK CommonTools Library"/>
|
||||
</target>
|
||||
|
||||
<target name="init">
|
||||
<echo message="The EDK CommonTools Library"/>
|
||||
<mkdir dir="${BUILD_DIR}"/>
|
||||
<if>
|
||||
<equals arg1="${GCC}" arg2="cygwin"/>
|
||||
<then>
|
||||
<echo message="Cygwin Family"/>
|
||||
<property name="ToolChain" value="gcc"/>
|
||||
</then>
|
||||
<elseif>
|
||||
<os family="dos"/>
|
||||
<then>
|
||||
<echo message="Windows Family"/>
|
||||
<property name="ToolChain" value="msvc"/>
|
||||
</then>
|
||||
</elseif>
|
||||
<elseif>
|
||||
<os family="unix"/>
|
||||
<then>
|
||||
<echo message="UNIX Family"/>
|
||||
<property name="ToolChain" value="gcc"/>
|
||||
</then>
|
||||
</elseif>
|
||||
|
||||
<else>
|
||||
<echo>
|
||||
Unsupported Operating System
|
||||
Please Contact Intel Corporation
|
||||
</echo>
|
||||
</else>
|
||||
</if>
|
||||
<if>
|
||||
<equals arg1="${ToolChain}" arg2="msvc"/>
|
||||
<then>
|
||||
<property name="ext_static" value=".lib"/>
|
||||
<property name="ext_dynamic" value=".dll"/>
|
||||
</then>
|
||||
<elseif>
|
||||
<equals arg1="${ToolChain}" arg2="gcc"/>
|
||||
<then>
|
||||
<property name="ext_static" value=".a"/>
|
||||
<property name="ext_dynamic" value=".so"/>
|
||||
</then>
|
||||
</elseif>
|
||||
</if>
|
||||
</target>
|
||||
|
||||
<target name="ToolsLibrary" depends="init">
|
||||
<cc name="${ToolChain}" objdir="${BUILD_DIR}"
|
||||
outfile="${LIB_DIR}/CommonTools"
|
||||
outtype="static"
|
||||
libtool="${haveLibtool}"
|
||||
optimize="speed">
|
||||
|
||||
<includepath path="${env.WORKSPACE}/MdePkg/Include"/>
|
||||
<includepath path="${env.WORKSPACE}/MdePkg/Include/Common"/>
|
||||
<includepath path="${env.WORKSPACE}/MdePkg/Include/Ia32"/>
|
||||
|
||||
<fileset dir="${basedir}/Common"
|
||||
includes="*.h *.c"
|
||||
defaultexcludes="TRUE"
|
||||
excludes="*.xml *.inf"/>
|
||||
|
||||
</cc>
|
||||
<if>
|
||||
<os family="dos"/>
|
||||
<then>
|
||||
<exec dir="${BUILD_DIR}" executable="lib" failonerror="false">
|
||||
<arg line="/NOLOGO *.lib /OUT:${LIB_DIR}/CommonTools${ext_static}"/>
|
||||
</exec>
|
||||
</then>
|
||||
</if>
|
||||
</target>
|
||||
|
||||
<target name="clean" depends="init">
|
||||
<echo message="Removing Intermediate Files Only from ${BUILD_DIR}"/>
|
||||
<delete>
|
||||
<fileset dir="${BUILD_DIR}" includes="*.obj"/>
|
||||
</delete>
|
||||
</target>
|
||||
|
||||
<target name="cleanall" depends="init">
|
||||
<echo message="Removing Object Files and the Library: CommonTools${ext_static}"/>
|
||||
<delete dir="${BUILD_DIR}">
|
||||
<fileset dir="${LIB_DIR}" includes="CommonTools${ext_static}"/>
|
||||
</delete>
|
||||
</target>
|
||||
|
||||
</project>
|
Reference in New Issue
Block a user