sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

More renames for Tool Packages

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@1675 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lhauch
2006-10-05 23:16:50 +00:00
parent feccee87a7
commit 28305207ea
277 changed files with 3 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2788
Tools/CodeTools/Source/FlashMap/FlashDefFile.c Normal file
View File

File diff suppressed because it is too large Load Diff

281
Tools/CodeTools/Source/FlashMap/FlashDefFile.h Normal file
View File

@ -0,0 +1,281 @@
/*++
Copyright (c) 2004-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:
FlashDefFile.h
Abstract:
Header file for flash management utility in the Intel Platform
Innovation Framework for EFI build environment.
--*/
#ifndef _FLASH_DEF_FILE_H_
#define _FLASH_DEF_FILE_H_
#ifdef __cplusplus
extern "C"
{
#endif
void
FDFConstructor (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
;
void
FDFDestructor (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFParseFile (
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFCreateCIncludeFile (
char *FlashDeviceName,
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FlashDeviceName - GC_TODO: add argument description
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFCreateCFlashMapDataFile (
char *FlashDeviceName,
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FlashDeviceName - GC_TODO: add argument description
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFCreateAsmIncludeFile (
char *FlashDeviceName,
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FlashDeviceName - GC_TODO: add argument description
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFParseFile (
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFCreateImage (
char *FlashDeviceName,
char *ImageName,
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FlashDeviceName - GC_TODO: add argument description
ImageName - GC_TODO: add argument description
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFCreateDscFile (
char *FlashDeviceName,
char *FileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FlashDeviceName - GC_TODO: add argument description
FileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDFCreateSymbols (
char *FlashDeviceName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FlashDeviceName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
FDDiscover (
char *FDFileName,
unsigned int BaseAddr
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
FDFileName - GC_TODO: add argument description
BaseAddr - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
#ifdef __cplusplus
}
#endif
#endif // #ifndef _FLASH_DEF_FILE_H_

769
Tools/CodeTools/Source/FlashMap/FlashMap.c Normal file
View File

@ -0,0 +1,769 @@
/*++
Copyright (c) 2004-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:
FlashMap.c
Abstract:
Utility for flash management in the Intel Platform Innovation Framework
for EFI build environment.
--*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <Common/UefiBaseTypes.h>
#include "EfiUtilityMsgs.h"
#include "Microcode.h"
#include "FlashDefFile.h"
#include "Symbols.h"
#define UTILITY_NAME "FlashMap"
typedef struct _STRING_LIST {
struct _STRING_LIST *Next;
char *Str;
} STRING_LIST;
//
// Keep our globals in one of these structures
//
static struct {
char *CIncludeFileName;
char *FlashDevice;
char *FlashDeviceImage;
char *MCIFileName;
char *MCOFileName;
char *ImageOutFileName;
char *DscFileName;
char *AsmIncludeFileName;
char *FlashDefinitionFileName;
char *StringReplaceInFileName;
char *StringReplaceOutFileName;
char *DiscoverFDImageName;
char MicrocodePadByteValue;
unsigned int MicrocodeAlignment;
STRING_LIST *MCIFileNames;
STRING_LIST *LastMCIFileNames;
unsigned int BaseAddress;
} mGlobals;
#define DEFAULT_MC_PAD_BYTE_VALUE 0xFF
#define DEFAULT_MC_ALIGNMENT 16
static
STATUS
ProcessCommandLine (
int argc,
char *argv[]
);
static
STATUS
MergeMicrocodeFiles (
char *OutFileName,
STRING_LIST *FileNames,
unsigned int Alignment,
char PadByteValue
);
static
void
Usage (
VOID
);
char*
NormalizePath (
char* OldPathName
);
int
main (
int argc,
char *argv[]
)
/*++
Routine Description:
Parse the command line arguments and then call worker functions to do the work
Arguments:
argc - number of elements in argv
argv - array of command-line arguments
Returns:
STATUS_SUCCESS - no problems encountered while processing
STATUS_WARNING - warnings, but no errors, were encountered while processing
STATUS_ERROR - errors were encountered while processing
--*/
{
STATUS Status;
SetUtilityName (UTILITY_NAME);
Status = ProcessCommandLine (argc, argv);
if (Status != STATUS_SUCCESS) {
return Status;
}
//
// Check for discovery of an FD (command line option)
//
if (mGlobals.DiscoverFDImageName != NULL) {
Status = FDDiscover (mGlobals.DiscoverFDImageName, mGlobals.BaseAddress);
goto Done;
}
//
// If they're doing microcode file parsing, then do that
//
if (mGlobals.MCIFileName != NULL) {
MicrocodeConstructor ();
MicrocodeParseFile (mGlobals.MCIFileName, mGlobals.MCOFileName);
MicrocodeDestructor ();
}
//
// If they're doing microcode file merging, then do that now
//
if (mGlobals.MCIFileNames != NULL) {
MergeMicrocodeFiles (
mGlobals.MCOFileName,
mGlobals.MCIFileNames,
mGlobals.MicrocodeAlignment,
mGlobals.MicrocodePadByteValue
);
}
//
// If using a flash definition file, then process that and return
//
if (mGlobals.FlashDefinitionFileName != NULL) {
FDFConstructor ();
SymbolsConstructor ();
Status = FDFParseFile (mGlobals.FlashDefinitionFileName);
if (GetUtilityStatus () != STATUS_ERROR) {
//
// If they want us to do a string-replace on a file, then add the symbol definitions to
// the symbol table, and then do the string replace.
//
if (mGlobals.StringReplaceInFileName != NULL) {
Status = FDFCreateSymbols (mGlobals.FlashDevice);
Status = SymbolsFileStringsReplace (mGlobals.StringReplaceInFileName, mGlobals.StringReplaceOutFileName);
}
//
// If they want us to create a .h defines file or .c flashmap data file, then do so now
//
if (mGlobals.CIncludeFileName != NULL) {
Status = FDFCreateCIncludeFile (mGlobals.FlashDevice, mGlobals.CIncludeFileName);
}
if (mGlobals.AsmIncludeFileName != NULL) {
Status = FDFCreateAsmIncludeFile (mGlobals.FlashDevice, mGlobals.AsmIncludeFileName);
}
//
// If they want us to create an image, do that now
//
if (mGlobals.ImageOutFileName != NULL) {
Status = FDFCreateImage (mGlobals.FlashDevice, mGlobals.FlashDeviceImage, mGlobals.ImageOutFileName);
}
//
// If they want to create an output DSC file, do that now
//
if (mGlobals.DscFileName != NULL) {
Status = FDFCreateDscFile (mGlobals.FlashDevice, mGlobals.DscFileName);
}
}
SymbolsDestructor ();
FDFDestructor ();
}
Done:
//
// Free up memory
//
while (mGlobals.MCIFileNames != NULL) {
mGlobals.LastMCIFileNames = mGlobals.MCIFileNames->Next;
_free (mGlobals.MCIFileNames);
mGlobals.MCIFileNames = mGlobals.LastMCIFileNames;
}
return GetUtilityStatus ();
}
static
STATUS
MergeMicrocodeFiles (
char *OutFileName,
STRING_LIST *FileNames,
unsigned int Alignment,
char PadByteValue
)
/*++
Routine Description:
Merge binary microcode files into a single file, taking into consideration
the alignment and pad value.
Arguments:
OutFileName - name of the output file to create
FileNames - linked list of input microcode files to merge
Alignment - alignment for each microcode file in the output image
PadByteValue - value to use when padding to meet alignment requirements
Returns:
STATUS_SUCCESS - merge completed successfully or with acceptable warnings
STATUS_ERROR - merge failed, output file not created
--*/
{
long FileSize;
long TotalFileSize;
FILE *InFptr;
FILE *OutFptr;
char *Buffer;
STATUS Status;
//
// Open the output file
//
if ((OutFptr = fopen (OutFileName, "wb")) == NULL) {
Error (NULL, 0, 0, OutFileName, "failed to open output file for writing");
return STATUS_ERROR;
}
//
// Walk the list of files
//
Status = STATUS_ERROR;
Buffer = NULL;
InFptr = NULL;
TotalFileSize = 0;
while (FileNames != NULL) {
//
// Open the file, determine the size, then read it in and write
// it back out.
//
if ((InFptr = fopen (NormalizePath(FileNames->Str), "rb")) == NULL) {
Error (NULL, 0, 0, NormalizePath(FileNames->Str), "failed to open input file for reading");
goto Done;
}
fseek (InFptr, 0, SEEK_END);
FileSize = ftell (InFptr);
fseek (InFptr, 0, SEEK_SET);
if (FileSize != 0) {
Buffer = (char *) _malloc (FileSize);
if (Buffer == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
goto Done;
}
if (fread (Buffer, FileSize, 1, InFptr) != 1) {
Error (NULL, 0, 0, FileNames->Str, "failed to read file contents");
goto Done;
}
//
// Align
//
if (Alignment != 0) {
while ((TotalFileSize % Alignment) != 0) {
if (fwrite (&PadByteValue, 1, 1, OutFptr) != 1) {
Error (NULL, 0, 0, OutFileName, "failed to write pad bytes to output file");
goto Done;
}
TotalFileSize++;
}
}
TotalFileSize += FileSize;
if (fwrite (Buffer, FileSize, 1, OutFptr) != 1) {
Error (NULL, 0, 0, OutFileName, "failed to write to output file");
goto Done;
}
_free (Buffer);
Buffer = NULL;
} else {
Warning (NULL, 0, 0, FileNames->Str, "0-size file encountered");
}
fclose (InFptr);
InFptr = NULL;
FileNames = FileNames->Next;
}
Status = STATUS_SUCCESS;
Done:
fclose (OutFptr);
if (InFptr != NULL) {
fclose (InFptr);
}
if (Buffer != NULL) {
_free (Buffer);
}
if (Status == STATUS_ERROR) {
remove (OutFileName);
}
return Status;
}
static
STATUS
ProcessCommandLine (
int argc,
char *argv[]
)
/*++
Routine Description:
Process the command line arguments
Arguments:
argc - Standard C entry point arguments
argv[] - Standard C entry point arguments
Returns:
STATUS_SUCCESS - no problems encountered while processing
STATUS_WARNING - warnings, but no errors, were encountered while processing
STATUS_ERROR - errors were encountered while processing
--*/
{
int ThingsToDo;
unsigned int Temp;
STRING_LIST *Str;
//
// Skip program name arg, process others
//
argc--;
argv++;
if (argc == 0) {
Usage ();
return STATUS_ERROR;
}
//
// Clear out our globals, then start walking the arguments
//
memset ((void *) &mGlobals, 0, sizeof (mGlobals));
mGlobals.MicrocodePadByteValue = DEFAULT_MC_PAD_BYTE_VALUE;
mGlobals.MicrocodeAlignment = DEFAULT_MC_ALIGNMENT;
ThingsToDo = 0;
while (argc > 0) {
if (strcmp (argv[0], "-?") == 0) {
Usage ();
return STATUS_ERROR;
} else if (strcmp (argv[0], "-hfile") == 0) {
//
// -hfile FileName
//
// Used to specify an output C #include file to create that contains
// #define statements for all the flashmap region offsets and sizes.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output file name");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.CIncludeFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-flashdevice") == 0) {
//
// -flashdevice FLASH_DEVICE_NAME
//
// Used to select which flash device definition to operate on.
// Check for additional argument
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires a flash device name to use");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.FlashDevice = argv[0];
} else if (strcmp (argv[0], "-mco") == 0) {
//
// -mco OutFileName
//
// Used to specify a microcode output binary file to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, (INT8 *) argv[0], (INT8 *) "option requires an output microcode file name to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.MCOFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-asmincfile") == 0) {
//
// -asmincfile FileName
//
// Used to specify the name of the output assembly include file that contains
// equates for the flash region addresses and sizes.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output ASM include file name to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.AsmIncludeFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-mci") == 0) {
//
// -mci FileName
//
// Used to specify an input microcode text file to parse.
// Check for additional argument
//
if (argc < 2) {
Error (NULL, 0, 0, (INT8 *) argv[0], (INT8 *) "option requires an input microcode text file name to parse");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.MCIFileName = argv[0];
} else if (strcmp (argv[0], "-flashdeviceimage") == 0) {
//
// -flashdeviceimage FlashDeviceImage
//
// Used to specify which flash device image definition from the input flash definition file
// to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires the name of a flash definition image to use");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.FlashDeviceImage = argv[0];
} else if (strcmp (argv[0], "-imageout") == 0) {
//
// -imageout FileName
//
// Used to specify the name of the output FD image file to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output image filename to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.ImageOutFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-dsc") == 0) {
//
// -dsc FileName
//
// Used to specify the name of the output DSC file to create.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an output DSC filename to create");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.DscFileName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-fdf") == 0) {
//
// -fdf FileName
//
// Used to specify the name of the input flash definition file.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an input flash definition file name");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.FlashDefinitionFileName = argv[0];
} else if (strcmp (argv[0], "-discover") == 0) {
//
// -discover FDFileName
//
// Debug functionality used to scan an existing FD image, trying to find
// firmware volumes at 64K boundaries.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an input FD image file name");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.DiscoverFDImageName = argv[0];
ThingsToDo++;
} else if (strcmp (argv[0], "-baseaddr") == 0) {
//
// -baseaddr Addr
//
// Used to specify a base address when doing a discover of an FD image.
// Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires a base address");
return STATUS_ERROR;
}
argc--;
argv++;
if (tolower (argv[0][1]) == 'x') {
sscanf (argv[0] + 2, "%x", &mGlobals.BaseAddress);
} else {
sscanf (argv[0], "%d", &mGlobals.BaseAddress);
}
} else if (strcmp (argv[0], "-padvalue") == 0) {
//
// -padvalue Value
//
// Used to specify the value to pad with when aligning data while
// creating an FD image. Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires a byte value");
return STATUS_ERROR;
}
argc--;
argv++;
if (tolower (argv[0][1]) == 'x') {
sscanf (argv[0] + 2, "%x", &Temp);
mGlobals.MicrocodePadByteValue = (char) Temp;
} else {
sscanf (argv[0], "%d", &Temp);
mGlobals.MicrocodePadByteValue = (char) Temp;
}
} else if (strcmp (argv[0], "-align") == 0) {
//
// -align Alignment
//
// Used to specify how each data file is aligned in the region
// when creating an FD image. Check for additional argument.
//
if (argc < 2) {
Error (NULL, 0, 0, argv[0], "option requires an alignment");
return STATUS_ERROR;
}
argc--;
argv++;
if (tolower (argv[0][1]) == 'x') {
sscanf (argv[0] + 2, "%x", &mGlobals.MicrocodeAlignment);
} else {
sscanf (argv[0], "%d", &mGlobals.MicrocodeAlignment);
}
} else if (strcmp (argv[0], "-mcmerge") == 0) {
//
// -mcmerge FileName(s)
//
// Used to concatenate multiple microde binary files. Can specify
// multiple file names with the one -mcmerge flag. Check for additional argument.
//
if ((argc < 2) || (argv[1][0] == '-')) {
Error (NULL, 0, 0, argv[0], "option requires one or more input file names");
return STATUS_ERROR;
}
//
// Take input files until another option or end of list
//
ThingsToDo++;
while ((argc > 1) && (argv[1][0] != '-')) {
Str = (STRING_LIST *) _malloc (sizeof (STRING_LIST));
if (Str == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
return STATUS_ERROR;
}
memset (Str, 0, sizeof (STRING_LIST));
Str->Str = argv[1];
if (mGlobals.MCIFileNames == NULL) {
mGlobals.MCIFileNames = Str;
} else {
mGlobals.LastMCIFileNames->Next = Str;
}
mGlobals.LastMCIFileNames = Str;
argc--;
argv++;
}
} else if (strcmp (argv[0], "-strsub") == 0) {
//
// -strsub SrcFile DestFile
//
// Used to perform string substitutions on a file, writing the result to a new
// file. Check for two additional arguments.
//
if (argc < 3) {
Error (NULL, 0, 0, argv[0], "option requires input and output file names for string substitution");
return STATUS_ERROR;
}
argc--;
argv++;
mGlobals.StringReplaceInFileName = argv[0];
argc--;
argv++;
mGlobals.StringReplaceOutFileName = argv[0];
ThingsToDo++;
} else {
Error (NULL, 0, 0, argv[0], "invalid option");
return STATUS_ERROR;
}
argc--;
argv++;
}
//
// If no outputs requested, then report an error
//
if (ThingsToDo == 0) {
Error (NULL, 0, 0, "nothing to do", NULL);
return STATUS_ERROR;
}
//
// If they want an asm file, #include file, or C file to be created, then they have to specify a
// flash device name and flash definition file name.
//
if ((mGlobals.CIncludeFileName != NULL) &&
((mGlobals.FlashDevice == NULL) || (mGlobals.FlashDefinitionFileName == NULL))) {
Error (NULL, 0, 0, "must specify -flashdevice and -fdf with -hfile", NULL);
return STATUS_ERROR;
}
if ((mGlobals.AsmIncludeFileName != NULL) &&
((mGlobals.FlashDevice == NULL) || (mGlobals.FlashDefinitionFileName == NULL))) {
Error (NULL, 0, 0, "must specify -flashdevice and -fdf with -asmincfile", NULL);
return STATUS_ERROR;
}
//
// If they want a dsc file to be created, then they have to specify a
// flash device name and a flash definition file name
//
if (mGlobals.DscFileName != NULL) {
if (mGlobals.FlashDevice == NULL) {
Error (NULL, 0, 0, "must specify -flashdevice with -dsc", NULL);
return STATUS_ERROR;
}
if (mGlobals.FlashDefinitionFileName == NULL) {
Error (NULL, 0, 0, "must specify -fdf with -dsc", NULL);
return STATUS_ERROR;
}
}
//
// If they specified an output microcode file name, then they have to specify an input
// file name, and vice versa.
//
if ((mGlobals.MCIFileName != NULL) && (mGlobals.MCOFileName == NULL)) {
Error (NULL, 0, 0, "must specify output microcode file name", NULL);
return STATUS_ERROR;
}
if ((mGlobals.MCOFileName != NULL) && (mGlobals.MCIFileName == NULL) && (mGlobals.MCIFileNames == NULL)) {
Error (NULL, 0, 0, "must specify input microcode file name", NULL);
return STATUS_ERROR;
}
//
// If doing merge, then have to specify output file name
//
if ((mGlobals.MCIFileNames != NULL) && (mGlobals.MCOFileName == NULL)) {
Error (NULL, 0, 0, "must specify output microcode file name", NULL);
return STATUS_ERROR;
}
//
// If they want an output image to be created, then they have to specify
// the flash device and the flash device image to use.
//
if (mGlobals.ImageOutFileName != NULL) {
if (mGlobals.FlashDevice == NULL) {
Error (NULL, 0, 0, "must specify -flashdevice with -imageout", NULL);
return STATUS_ERROR;
}
if (mGlobals.FlashDeviceImage == NULL) {
Error (NULL, 0, 0, "must specify -flashdeviceimage with -imageout", NULL);
return STATUS_ERROR;
}
if (mGlobals.FlashDefinitionFileName == NULL) {
Error (NULL, 0, 0, "must specify -c or -fdf with -imageout", NULL);
return STATUS_ERROR;
}
}
return STATUS_SUCCESS;
}
static
void
Usage (
VOID
)
/*++
Routine Description:
Print utility command line help
Arguments:
None
Returns:
NA
--*/
{
int i;
char *Msg[] = {
"Usage: FlashTool -fdf FlashDefFile -flashdevice FlashDevice",
" -flashdeviceimage FlashDeviceImage -mci MCIFile -mco MCOFile",
" -discover FDImage -dsc DscFile -asmincfile AsmIncFile",
" -imageOut ImageOutFile -hfile HFile -strsub InStrFile OutStrFile",
" -baseaddr BaseAddr -align Alignment -padvalue PadValue",
" -mcmerge MCIFile(s)",
" where",
" FlashDefFile - input Flash Definition File",
" FlashDevice - flash device to use (from flash definition file)",
" FlashDeviceImage - flash device image to use (from flash definition file)",
" MCIFile - input microcode file to parse",
" MCOFile - output binary microcode image to create from MCIFile",
" HFile - output #include file to create",
" FDImage - name of input FDImage file to scan",
" ImageOutFile - output image file to create",
" DscFile - output DSC file to create",
" AsmIncFile - output ASM include file to create",
" InStrFile - input file to replace symbol names, writing result to OutStrFile",
" BaseAddr - base address of FDImage (used with -discover)",
" Alignment - alignment to use when merging microcode binaries",
" PadValue - byte value to use as pad value when aligning microcode binaries",
" MCIFile(s) - one or more microcode binary files to merge/concatenate",
"",
NULL
};
for (i = 0; Msg[i] != NULL; i++) {
fprintf (stdout, "%s\n", Msg[i]);
}
}
char*
NormalizePath (
char* OldPathName
)
{
char* Visitor;
if (OldPathName == NULL) {
return NULL;
}
Visitor = OldPathName;
while (*Visitor != '\0') {
if (*Visitor == '\\') {
*Visitor = '/';
}
Visitor++;
}
return OldPathName;
}

304
Tools/CodeTools/Source/FlashMap/Microcode.c Normal file
View File

@ -0,0 +1,304 @@
/*++
Copyright (c) 2004-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:
Microcode.c
Abstract:
Utility for working with microcode patch files in the Intel
Platform Innovation Framework for EFI build environment.
--*/
#include <stdio.h>
#include <string.h> // for memset()
#include <ctype.h>
#include <stdlib.h> // for malloc()
#include "EfiUtilityMsgs.h"
#include "Microcode.h"
#define MAX_LINE_LEN 256
//
// Structure definition for a microcode header
//
typedef struct {
unsigned int HeaderVersion;
unsigned int PatchId;
unsigned int Date;
unsigned int CpuId;
unsigned int Checksum;
unsigned int LoaderVersion;
unsigned int PlatformId;
unsigned int DataSize; // if 0, then TotalSize = 2048, and TotalSize field is invalid
unsigned int TotalSize; // number of bytes
unsigned int Reserved[3];
} MICROCODE_IMAGE_HEADER;
static
STATUS
MicrocodeReadData (
FILE *InFptr,
unsigned int *Data
);
void
MicrocodeConstructor (
void
)
/*++
Routine Description:
Constructor of module Microcode
Arguments:
None
Returns:
None
--*/
{
}
void
MicrocodeDestructor (
void
)
/*++
Routine Description:
Destructor of module Microcode
Arguments:
None
Returns:
None
--*/
{
}
static
STATUS
MicrocodeReadData (
FILE *InFptr,
unsigned int *Data
)
/*++
Routine Description:
Read a 32-bit microcode data value from a text file and convert to raw binary form.
Arguments:
InFptr - file pointer to input text file
Data - pointer to where to return the data parsed
Returns:
STATUS_SUCCESS - no errors or warnings, Data contains valid information
STATUS_ERROR - errors were encountered
--*/
{
char Line[MAX_LINE_LEN];
char *cptr;
Line[MAX_LINE_LEN - 1] = 0;
*Data = 0;
if (fgets (Line, MAX_LINE_LEN, InFptr) == NULL) {
return STATUS_ERROR;
}
//
// If it was a binary file, then it may have overwritten our null terminator
//
if (Line[MAX_LINE_LEN - 1] != 0) {
return STATUS_ERROR;
}
//
// Look for
// dd 000000001h ; comment
// dd XXXXXXXX
// DD XXXXXXXXX
// DD XXXXXXXXX
//
for (cptr = Line; *cptr && isspace(*cptr); cptr++) {
}
if ((tolower(cptr[0]) == 'd') && (tolower(cptr[1]) == 'd') && isspace (cptr[2])) {
//
// Skip blanks and look for a hex digit
//
cptr += 3;
for (; *cptr && isspace(*cptr); cptr++) {
}
if (isxdigit (*cptr)) {
if (sscanf (cptr, "%X", Data) != 1) {
return STATUS_ERROR;
}
}
return STATUS_SUCCESS;
}
return STATUS_ERROR;
}
STATUS
MicrocodeParseFile (
char *InFileName,
char *OutFileName
)
/*++
Routine Description:
Parse a microcode text file, and write the binary results to an output file.
Arguments:
InFileName - input text file to parse
OutFileName - output file to write raw binary data from parsed input file
Returns:
STATUS_SUCCESS - no errors or warnings
STATUS_ERROR - errors were encountered
--*/
{
FILE *InFptr;
FILE *OutFptr;
STATUS Status;
MICROCODE_IMAGE_HEADER *Header;
unsigned int Size;
unsigned int Size2;
unsigned int Data;
unsigned int Checksum;
char *Buffer;
char *Ptr;
unsigned int TotalSize;
Status = STATUS_ERROR;
InFptr = NULL;
OutFptr = NULL;
Buffer = NULL;
//
// Open the input text file
//
if ((InFptr = fopen (InFileName, "r")) == NULL) {
Error (NULL, 0, 0, InFileName, "failed to open input microcode file for reading");
return STATUS_ERROR;
}
//
// Make two passes on the input file. The first pass is to determine how
// much data is in the file so we can allocate a working buffer. Then
// we'll allocate a buffer and re-read the file into the buffer for processing.
//
Size = 0;
do {
Status = MicrocodeReadData (InFptr, &Data);
if (Status == STATUS_SUCCESS) {
Size += sizeof (Data);
}
} while (Status == STATUS_SUCCESS);
//
// Error if no data.
//
if (Size == 0) {
Error (NULL, 0, 0, InFileName, "no parse-able data found in file");
goto Done;
}
if (Size < sizeof (MICROCODE_IMAGE_HEADER)) {
Error (NULL, 0, 0, InFileName, "amount of parse-able data is insufficient to contain a microcode header");
goto Done;
}
//
// Allocate a buffer for the data
//
Buffer = (char *) _malloc (Size);
if (Buffer == NULL) {
Error (NULL, 0, 0, "memory allocation failure", NULL);
goto Done;
}
//
// Re-read the file, storing the data into our buffer
//
fseek (InFptr, 0, SEEK_SET);
Ptr = Buffer;
do {
Status = MicrocodeReadData (InFptr, &Data);
if (Status == STATUS_SUCCESS) {
*(unsigned int *) Ptr = Data;
Ptr += sizeof (Data);
}
} while (Status == STATUS_SUCCESS);
//
// Can't do much checking on the header because, per the spec, the
// DataSize field may be 0, which means DataSize = 2000 and TotalSize = 2K,
// and the TotalSize field is invalid (actually missing). Thus we can't
// even verify the Reserved fields are 0.
//
Header = (MICROCODE_IMAGE_HEADER *) Buffer;
if (Header->DataSize == 0) {
TotalSize = 2048;
} else {
TotalSize = Header->TotalSize;
}
if (TotalSize != Size) {
Error (NULL, 0, 0, InFileName, "file contents do not contain expected TotalSize 0x%04X", TotalSize);
goto Done;
}
//
// Checksum the contents
//
Ptr = Buffer;
Checksum = 0;
Size2 = 0;
while (Size2 < Size) {
Checksum += *(unsigned int *) Ptr;
Ptr += 4;
Size2 += 4;
}
if (Checksum != 0) {
Error (NULL, 0, 0, InFileName, "checksum failed on file contents");
goto Done;
}
//
// Open the output file and write the buffer contents
//
if ((OutFptr = fopen (OutFileName, "wb")) == NULL) {
Error (NULL, 0, 0, OutFileName, "failed to open output microcode file for writing");
goto Done;
}
if (fwrite (Buffer, Size, 1, OutFptr) != 1) {
Error (NULL, 0, 0, OutFileName, "failed to write microcode data to output file");
goto Done;
}
Status = STATUS_SUCCESS;
Done:
if (Buffer != NULL) {
free (Buffer);
}
if (InFptr != NULL) {
fclose (InFptr);
}
if (OutFptr != NULL) {
fclose (OutFptr);
if (Status == STATUS_ERROR) {
remove (OutFileName);
}
}
return Status;
}

87
Tools/CodeTools/Source/FlashMap/Microcode.h Normal file
View File

@ -0,0 +1,87 @@
/*++
Copyright (c) 2004-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:
Microcode.h
Abstract:
Header file for flash management utility in the Intel Platform
Innovation Framework for EFI build environment.
--*/
#ifndef _MICROCODE_H_
#define _MICROCODE_H_
void
MicrocodeConstructor (
void
);
/*++
Routine Description:
Constructor of module Microcode
Arguments:
None
Returns:
None
--*/
void
MicrocodeDestructor (
void
);
/*++
Routine Description:
Destructor of module Microcode
Arguments:
None
Returns:
None
--*/
STATUS
MicrocodeParseFile (
char *InFileName,
char *OutFileName
);
/*++
Routine Description:
Parse a microcode text file, and write the binary results to an output file.
Arguments:
InFileName - input text file to parse
OutFileName - output file to write raw binary data from parsed input file
Returns:
STATUS_SUCCESS - no errors or warnings
STATUS_ERROR - errors were encountered
--*/
#endif // #ifndef _MICROCODE_H_

648
Tools/CodeTools/Source/FlashMap/Symbols.c Normal file
View File

@ -0,0 +1,648 @@
/*++
Copyright (c) 2004-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:
Symbol.c
Abstract:
Class-like implementation for a symbol table.
--*/
// GC_TODO: fix comment to set correct module name: Symbols.c
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
//
// for isspace()
//
#include <ctype.h>
#include <Common/UefiBaseTypes.h>
#include "CommonLib.h"
#include "EfiUtilityMsgs.h"
#include "Symbols.h"
#define MAX_LINE_LEN 512
//
// Linked list to keep track of all symbols
//
typedef struct _SYMBOL {
struct _SYMBOL *Next;
int Type;
char *Name;
char *Value;
} SYMBOL;
static
SYMBOL *
FreeSymbols (
SYMBOL *Syms
);
static
int
ExpandMacros (
char *SourceLine,
char *DestLine,
int LineLen
);
static SYMBOL *mSymbolTable = NULL;
void
SymbolsConstructor (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
{
SymbolsDestructor ();
}
void
SymbolsDestructor (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
{
mSymbolTable = FreeSymbols (mSymbolTable);
}
char *
GetSymbolValue (
char *SymbolName
)
/*++
Routine Description:
Look up a symbol in our symbol table.
Arguments:
SymbolName
Returns:
Pointer to the value of the symbol if found
NULL if the symbol is not found
--*/
// GC_TODO: SymbolName - add argument and description to function comment
{
SYMBOL *Symbol;
//
// Walk the symbol table
//
Symbol = mSymbolTable;
while (Symbol) {
if (stricmp (SymbolName, Symbol->Name) == 0) {
return Symbol->Value;
}
Symbol = Symbol->Next;
}
return NULL;
}
int
SymbolAdd (
char *Name,
char *Value,
int Mode
)
/*++
Routine Description:
Add a symbol name/value to the symbol table
Arguments:
Name - name of symbol to add
Value - value of symbol to add
Mode - currrently unused
Returns:
Length of symbol added.
Notes:
If Value == NULL, then this routine will assume that the Name field
looks something like "MySymName = MySymValue", and will try to parse
it that way and add the symbol name/pair from the string.
--*/
{
SYMBOL *Symbol;
SYMBOL *NewSymbol;
int Len;
char *Start;
char *Cptr;
char CSave;
char *SaveCptr;
Len = 0;
SaveCptr = NULL;
CSave = 0;
//
// If value pointer is null, then they passed us a line something like:
// varname = value, or simply var =
//
if (Value == NULL) {
Start = Name;
while (*Name && isspace (*Name)) {
Name++;
}
if (Name == NULL) {
return -1;
}
//
// Find the end of the name. Either space or a '='.
//
for (Value = Name; *Value && !isspace (*Value) && (*Value != '='); Value++)
;
if (Value == NULL) {
return -1;
}
//
// Look for the '='
//
Cptr = Value;
while (*Value && (*Value != '=')) {
Value++;
}
if (Value == NULL) {
return -1;
}
//
// Now truncate the name
//
*Cptr = 0;
//
// Skip over the = and then any spaces
//
Value++;
while (*Value && isspace (*Value)) {
Value++;
}
//
// Find end of string, checking for quoted string
//
if (*Value == '\"') {
Value++;
for (Cptr = Value; *Cptr && *Cptr != '\"'; Cptr++)
;
} else {
for (Cptr = Value; *Cptr && !isspace (*Cptr); Cptr++)
;
}
//
// Null terminate the value string
//
CSave = *Cptr;
SaveCptr = Cptr;
*Cptr = 0;
Len = (int) (Cptr - Start);
}
//
// We now have a symbol name and a value. Look for an existing variable
// and overwrite it.
//
Symbol = mSymbolTable;
while (Symbol) {
//
// Check for symbol name match
//
if (stricmp (Name, Symbol->Name) == 0) {
_free (Symbol->Value);
Symbol->Value = (char *) _malloc (strlen (Value) + 1);
if (Symbol->Value == NULL) {
Error (NULL, 0, 0, NULL, "failed to allocate memory");
return -1;
}
strcpy (Symbol->Value, Value);
//
// If value == "NULL", then make it a 0-length string
//
if (stricmp (Symbol->Value, "NULL") == 0) {
Symbol->Value[0] = 0;
}
return Len;
}
Symbol = Symbol->Next;
}
//
// Does not exist, create a new one
//
NewSymbol = (SYMBOL *) _malloc (sizeof (SYMBOL));
if (NewSymbol == NULL) {
Error (NULL, 0, 0, NULL, "memory allocation failure");
return -1;
}
memset ((char *) NewSymbol, 0, sizeof (SYMBOL));
NewSymbol->Name = (char *) _malloc (strlen (Name) + 1);
if (NewSymbol->Name == NULL) {
Error (NULL, 0, 0, NULL, "memory allocation failure");
_free (NewSymbol);
return -1;
}
NewSymbol->Value = (char *) _malloc (strlen (Value) + 1);
if (NewSymbol->Value == NULL) {
Error (NULL, 0, 0, NULL, "memory allocation failure");
_free (NewSymbol->Name);
_free (NewSymbol);
return -1;
}
strcpy (NewSymbol->Name, Name);
strcpy (NewSymbol->Value, Value);
//
// Remove trailing spaces
//
Cptr = NewSymbol->Value + strlen (NewSymbol->Value) - 1;
while (Cptr > NewSymbol->Value) {
if (isspace (*Cptr)) {
*Cptr = 0;
Cptr--;
} else {
break;
}
}
//
// Add it to the head of the list.
//
NewSymbol->Next = mSymbolTable;
mSymbolTable = NewSymbol;
//
// If value == "NULL", then make it a 0-length string
//
if (stricmp (NewSymbol->Value, "NULL") == 0) {
NewSymbol->Value[0] = 0;
}
//
// Restore the terminator we inserted if they passed in var=value
//
if (SaveCptr != NULL) {
*SaveCptr = CSave;
}
_free (NewSymbol->Value);
_free (NewSymbol->Name);
_free (NewSymbol);
return Len;
}
static
STATUS
RemoveSymbol (
char *Name,
char SymbolType
)
/*++
Routine Description:
Remove a symbol name/value from the symbol table
Arguments:
Name - name of symbol to remove
SymbolType - type of symbol to remove
Returns:
STATUS_SUCCESS - matching symbol found and removed
STATUS_ERROR - matching symbol not found in symbol table
--*/
{
SYMBOL *Symbol;
SYMBOL *PrevSymbol;
PrevSymbol = NULL;
Symbol = mSymbolTable;
//
// Walk the linked list of symbols in the symbol table looking
// for a match of both symbol name and type.
//
while (Symbol) {
if ((stricmp (Name, Symbol->Name) == 0) && (Symbol->Type & SymbolType)) {
//
// If the symbol has a value associated with it, free the memory
// allocated for the value.
// Then free the memory allocated for the symbols string name.
//
if (Symbol->Value) {
_free (Symbol->Value);
}
_free (Symbol->Name);
//
// Link the previous symbol to the next symbol to effectively
// remove this symbol from the linked list.
//
if (PrevSymbol) {
PrevSymbol->Next = Symbol->Next;
} else {
mSymbolTable = Symbol->Next;
}
_free (Symbol);
return STATUS_SUCCESS;
}
PrevSymbol = Symbol;
Symbol = Symbol->Next;
}
return STATUS_WARNING;
}
static
SYMBOL *
FreeSymbols (
SYMBOL *Syms
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Syms - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
{
SYMBOL *Next;
while (Syms) {
if (Syms->Name != NULL) {
_free (Syms->Name);
}
if (Syms->Value != NULL) {
_free (Syms->Value);
}
Next = Syms->Next;
_free (Syms);
Syms = Next;
}
return Syms;
}
static
int
ExpandMacros (
char *SourceLine,
char *DestLine,
int LineLen
)
/*++
Routine Description:
Given a line of text, replace all variables of format $(NAME) with values
from our symbol table.
Arguments:
SourceLine - input line of text to do symbol replacements on
DestLine - on output, SourceLine with symbols replaced
LineLen - length of DestLine, so we don't exceed its allocated length
Returns:
STATUS_SUCCESS - no problems encountered
STATUS_WARNING - missing closing parenthesis on a symbol reference in SourceLine
STATUS_ERROR - memory allocation failure
--*/
{
static int NestDepth = 0;
char *FromPtr;
char *ToPtr;
char *SaveStart;
char *Cptr;
char *value;
int Expanded;
int ExpandedCount;
INT8 *LocalDestLine;
STATUS Status;
int LocalLineLen;
NestDepth++;
Status = STATUS_SUCCESS;
LocalDestLine = (char *) _malloc (LineLen);
if (LocalDestLine == NULL) {
Error (__FILE__, __LINE__, 0, "memory allocation failed", NULL);
return STATUS_ERROR;
}
FromPtr = SourceLine;
ToPtr = LocalDestLine;
//
// Walk the entire line, replacing $(MACRO_NAME).
//
LocalLineLen = LineLen;
ExpandedCount = 0;
while (*FromPtr && (LocalLineLen > 0)) {
if ((*FromPtr == '$') && (*(FromPtr + 1) == '(')) {
//
// Save the start in case it's undefined, in which case we copy it as-is.
//
SaveStart = FromPtr;
Expanded = 0;
//
// Macro expansion time. Find the end (no spaces allowed)
//
FromPtr += 2;
for (Cptr = FromPtr; *Cptr && (*Cptr != ')'); Cptr++)
;
if (*Cptr) {
//
// Truncate the string at the closing parenthesis for ease-of-use.
// Then copy the string directly to the destination line in case we don't find
// a definition for it.
//
*Cptr = 0;
strcpy (ToPtr, SaveStart);
if ((value = GetSymbolValue (FromPtr)) != NULL) {
strcpy (ToPtr, value);
LocalLineLen -= strlen (value);
ToPtr += strlen (value);
Expanded = 1;
ExpandedCount++;
}
if (!Expanded) {
//
// Restore closing parenthesis, and advance to next character
//
*Cptr = ')';
FromPtr = SaveStart + 1;
ToPtr++;
} else {
FromPtr = Cptr + 1;
}
} else {
Error (NULL, 0, 0, SourceLine, "missing closing parenthesis on macro");
strcpy (ToPtr, FromPtr);
Status = STATUS_WARNING;
goto Done;
}
} else {
*ToPtr = *FromPtr;
FromPtr++;
ToPtr++;
LocalLineLen--;
}
}
if (*FromPtr == 0) {
*ToPtr = 0;
}
//
// If we expanded at least one string successfully, then make a recursive call to try again.
//
if ((ExpandedCount != 0) && (Status == STATUS_SUCCESS) && (NestDepth < 10)) {
Status = ExpandMacros (LocalDestLine, DestLine, LineLen);
_free (LocalDestLine);
NestDepth = 0;
return Status;
}
Done:
if (Status != STATUS_ERROR) {
strcpy (DestLine, LocalDestLine);
}
NestDepth = 0;
_free (LocalDestLine);
return Status;
}
STATUS
SymbolsFileStringsReplace (
char *InFileName,
char *OutFileName
)
/*++
Routine Description:
Given input and output file names, read in the input file, replace variable
references of format $(NAME) with appropriate values from our symbol table,
and write the result out to the output file.
Arguments:
InFileName - name of input text file to replace variable references
OutFileName - name of output text file to write results to
Returns:
STATUS_SUCCESS - no problems encountered
STATUS_ERROR - failed to open input or output file
--*/
{
STATUS Status;
FILE *InFptr;
FILE *OutFptr;
char Line[MAX_LINE_LEN];
char OutLine[MAX_LINE_LEN];
Status = STATUS_ERROR;
//
// Open input and output files
//
InFptr = NULL;
OutFptr = NULL;
if ((InFptr = fopen (InFileName, "r")) == NULL) {
Error (NULL, 0, 0, InFileName, "failed to open input file for reading");
goto Done;
}
if ((OutFptr = fopen (OutFileName, "w")) == NULL) {
Error (NULL, 0, 0, OutFileName, "failed to open output file for writing");
goto Done;
}
//
// Read lines from input file until done
//
while (fgets (Line, sizeof (Line), InFptr) != NULL) {
ExpandMacros (Line, OutLine, sizeof (OutLine));
fprintf (OutFptr, OutLine);
}
Status = STATUS_SUCCESS;
Done:
if (InFptr != NULL) {
fclose (InFptr);
}
if (OutFptr != NULL) {
fclose (OutFptr);
}
return Status;
}

124
Tools/CodeTools/Source/FlashMap/Symbols.h Normal file
View File

@ -0,0 +1,124 @@
/*++
Copyright (c) 2004-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:
Symbols.h
Abstract:
Defines and prototypes for a class-like symbol table service.
--*/
#ifndef _SYMBOLS_H_
#define _SYMBOLS_H_
#ifdef __cplusplus
extern "C"
{
#endif
int
SymbolAdd (
char *Name,
char *Value,
int Mode
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
Name - GC_TODO: add argument description
Value - GC_TODO: add argument description
Mode - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
STATUS
SymbolsFileStringsReplace (
char *InFileName,
char *OutFileName
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
InFileName - GC_TODO: add argument description
OutFileName - GC_TODO: add argument description
Returns:
GC_TODO: add return values
--*/
;
void
SymbolsConstructor (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
;
void
SymbolsDestructor (
VOID
)
/*++
Routine Description:
GC_TODO: Add function description
Arguments:
None
Returns:
GC_TODO: add return values
--*/
;
#ifdef __cplusplus
}
#endif
#endif // #ifndef _SYMBOLS_H_

76
Tools/CodeTools/Source/FlashMap/build.xml Normal file
View File

@ -0,0 +1,76 @@
<?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="GenTool" basedir=".">
<!--
EDK FlashMap Tool
Copyright (c) 2006, Intel Corporation
-->
<property name="ToolName" value="FlashMap"/>
<property name="FileSet" value="*.c"/>
<taskdef resource="cpptasks.tasks"/>
<typedef resource="cpptasks.types"/>
<taskdef resource="net/sf/antcontrib/antlib.xml"/>
<property name="LINK_OUTPUT_TYPE" value="static"/>
<property name="BUILD_DIR" value="${PACKAGE_DIR}/${ToolName}/tmp"/>
<target name="GenTool" depends="init, Tool">
<echo message="The EDK Tool: ${ToolName} build has completed!"/>
</target>
<target name="init">
<echo message="Building the EDK Tool: ${ToolName}"/>
<mkdir dir="${BUILD_DIR}"/>
</target>
<target name="Tool" depends="init">
<cc name="${ToolChain}" objdir="${BUILD_DIR}"
outfile="${BIN_DIR}/${ToolName}"
outtype="executable"
optimize="speed"
debug="true">
<compilerarg value="${ExtraArgus}" if="ExtraArgus" />
<defineset>
<define name="_malloc" value="malloc"/>
<define name="_free" value="free"/>
</defineset>
<fileset dir="${basedir}/${ToolName}"
includes="${FileSet}"
defaultexcludes="TRUE"
excludes="*.xml *.inf"/>
<includepath path="${PACKAGE_DIR}/Include"/>
<includepath path="${PACKAGE_DIR}/Include/${HostArch}"/>
<includepath path="${PACKAGE_DIR}/Common"/>
<libset dir="${LIB_DIR}" libs="CommonTools"/>
</cc>
</target>
<target name="clean">
<echo message="Removing Intermediate Files Only"/>
<delete>
<fileset dir="${BUILD_DIR}" includes="*.obj"/>
</delete>
</target>
<target name="cleanall">
<echo message="Removing Object Files and the Executable: ${ToolName}${ext_exe}"/>
<delete failonerror="false" quiet="true" includeEmptyDirs="true">
<fileset dir="${BUILD_DIR}"/>
<fileset file="${BIN_DIR}/${ToolName}${ext_exe}"/>
</delete>
</target>
</project>