peloader.c

uboot在arm处理器s3c2410的移植代码

	pageOffset = baseReloc->PageRVA - hMod->textBase;
	numFixups = (baseReloc->BlockSize - sizeof(BASE_RELOCATION)) / sizeof(ushort);
	fixup = (ushort*)(baseReloc + 1);
	for (i = 0; i < numFixups; i++) {
	    relocType = *fixup >> 12;
	    if (relocType) {
		offset = pageOffset + (*fixup & 0x0FFF);
		*(ulong*)(hMod->text + offset) += delta;
		}
	    fixup++;
	    }

	/* Move to next relocation block */
	baseReloc = (BASE_RELOCATION*)((ulong)baseReloc + baseReloc->BlockSize);
	}

    /* Initialise the C runtime library for the loaded DLL */
    result = PE_unableToInitLibC;
    if ((InitLibC = (InitLibC_t)PE_getProcAddress(hMod,"_InitLibC")) == NULL)
	goto Error;
    if (!InitLibC(&___imports,PM_getOSType()))
	goto Error;

    /* Clean up, close the file and return the loaded module handle */
    PM_free(reloc);
    result = PE_ok;
    return hMod;

Error:
    if (shared)
	PM_freeShared(hMod);
    else
	PM_free(hMod);
    PM_free(reloc);
    return NULL;
}

/****************************************************************************
DESCRIPTION:
Loads a Portable Binary DLL into memory

HEADER:
peloader.h

PARAMETERS:
szDLLName   - Name of the PE DLL library to load
shared      - True to load module into shared memory

RETURNS:
Handle to loaded PE DLL, or NULL on failure.

REMARKS:
This function loads a Portable Binary DLL library from disk, relocates
the code and returns a handle to the loaded library. This function
will only work on DLL's that do not have any imports, since we don't
resolve import dependencies in this function.

SEE ALSO:
PE_getProcAddress, PE_freeLibrary
****************************************************************************/
PE_MODULE * PEAPI PE_loadLibrary(
    const char *szDLLName,
    ibool shared)
{
    PE_MODULE   *hMod;

#if (defined(__WINDOWS32__) || defined(__DRIVER__)) && defined(CHECKED)
    if (!shared) {
	PM_MODULE       hInst;
	InitLibC_t      InitLibC;

	/* For Win32 if are building checked libraries for debugging, we use
	 * the real Win32 DLL functions so that we can debug the resulting DLL
	 * files with the Win32 debuggers. Note that we can't do this if
	 * we need to load the files into a shared memory context.
	 */
	if ((hInst = PM_loadLibrary(szDLLName)) == NULL) {
	    result = PE_fileNotFound;
	    return NULL;
	    }

	/* Initialise the C runtime library for the loaded DLL */
	result = PE_unableToInitLibC;
	if ((InitLibC = (void*)PM_getProcAddress(hInst,"_InitLibC")) == NULL)
	    return NULL;
	if (!InitLibC(&___imports,PM_getOSType()))
	    return NULL;

	/* Allocate the PE_MODULE structure */
	if ((hMod = PM_malloc(sizeof(*hMod))) == NULL)
	    return NULL;
	hMod->text = (void*)hInst;
	hMod->shared = -1;

	/* DLL loaded successfully so return module handle */
	result = PE_ok;
	return hMod;
	}
    else
#endif
	{
	FILE        *f;
	ulong       size;

	/* Attempt to open the file on disk */
	if (shared < 0)
	    shared = 0;
	if ((f = fopen(szDLLName,"rb")) == NULL) {
	    result = PE_fileNotFound;
	    return NULL;
	    }
	hMod = PE_loadLibraryExt(f,0,&size,shared);
	fclose(f);
	return hMod;
	}
}

/****************************************************************************
DESCRIPTION:
Loads a Portable Binary DLL into memory

HEADER:
peloader.h

PARAMETERS:
szDLLName   - Name of the PE DLL library to load
shared      - True to load module into shared memory

RETURNS:
Handle to loaded PE DLL, or NULL on failure.

REMARKS:
This function is the same as the regular PE_loadLibrary function, except
that it looks for the drivers in the MGL_ROOT/drivers directory or a
/drivers directory relative to the current directory.

SEE ALSO:
PE_loadLibraryMGL, PE_getProcAddress, PE_freeLibrary
****************************************************************************/
PE_MODULE * PEAPI PE_loadLibraryMGL(
    const char *szDLLName,
    ibool shared)
{
#if !defined(__WIN32_VXD__) && !defined(__NT_DRIVER__)
    PE_MODULE   *hMod;
#endif
    char        path[256] = "";

    /* We look in the 'drivers' directory, optionally under the MGL_ROOT
     * environment variable directory.
     */
#if !defined(__WIN32_VXD__) && !defined(__NT_DRIVER__)
    if (getenv("MGL_ROOT")) {
	strcpy(path,getenv("MGL_ROOT"));
	PM_backslash(path);
	}
    strcat(path,"drivers");
    PM_backslash(path);
    strcat(path,szDLLName);
    if ((hMod = PE_loadLibrary(path,shared)) != NULL)
	return hMod;
#endif
    strcpy(path,"drivers");
    PM_backslash(path);
    strcat(path,szDLLName);
    return PE_loadLibrary(path,shared);
}

/****************************************************************************
DESCRIPTION:
Gets a function address from a Portable Binary DLL

HEADER:
peloader.h

PARAMETERS:
hModule     - Handle to a loaded PE DLL library
szProcName  - Name of the function to get the address of

RETURNS:
Pointer to the function, or NULL on failure.

REMARKS:
This function searches for the named, exported function in a loaded PE
DLL library, and returns the address of the function. If the function is
not found in the library, this function return NULL.

SEE ALSO:
PE_loadLibrary, PE_freeLibrary
****************************************************************************/
void * PEAPI PE_getProcAddress(
    PE_MODULE *hModule,
    const char *szProcName)
{
#if (defined(__WINDOWS32__) || defined(__DRIVER__)) && defined(CHECKED)
    if (hModule->shared == -1)
	return (void*)PM_getProcAddress(hModule->text,szProcName);
    else
#endif
	{
	uint                i;
	EXPORT_DIRECTORY    *exports;
	ulong               funcOffset;
	ulong               *AddressTable;
	ulong               *NameTable;
	ushort              *OrdinalTable;
	char                *name;

	/* Find the address of the export tables from the export section */
	if (!hModule)
	    return NULL;
	exports = (EXPORT_DIRECTORY*)(hModule->export + hModule->exportDir);
	AddressTable = (ulong*)(hModule->export + exports->AddressTableRVA - hModule->exportBase);
	NameTable = (ulong*)(hModule->export + exports->NameTableRVA - hModule->exportBase);
	OrdinalTable = (ushort*)(hModule->export + exports->OrdinalTableRVA - hModule->exportBase);

	/* Search the export name table to find the function name */
	for (i = 0; i < exports->NumberOfNamePointers; i++) {
	    name = (char*)(hModule->export + NameTable[i] - hModule->exportBase);
	    if (strcmp(name,szProcName) == 0)
		break;
	    }
	if (i == exports->NumberOfNamePointers)
	    return NULL;
	funcOffset = AddressTable[OrdinalTable[i]];
	if (!funcOffset)
	    return NULL;
	return (void*)(hModule->text + funcOffset - hModule->textBase);
	}
}

/****************************************************************************
DESCRIPTION:
Frees a loaded Portable Binary DLL

HEADER:
peloader.h

PARAMETERS:
hModule     - Handle to a loaded PE DLL library to free

REMARKS:
This function frees a loaded PE DLL library from memory.

SEE ALSO:
PE_getProcAddress, PE_loadLibrary
****************************************************************************/
void PEAPI PE_freeLibrary(
    PE_MODULE *hModule)
{
    TerminateLibC_t TerminateLibC;

#if (defined(__WINDOWS32__) || defined(__DRIVER__)) && defined(CHECKED)
    if (hModule->shared == -1) {
	/* Run the C runtime library exit code on module unload */
	if ((TerminateLibC = (TerminateLibC_t)PM_getProcAddress(hModule->text,"_TerminateLibC")) != NULL)
	    TerminateLibC();
	PM_freeLibrary(hModule->text);
	PM_free(hModule);
	}
    else
#endif
	{
	if (hModule) {
	    /* Run the C runtime library exit code on module unload */
	    if ((TerminateLibC = (TerminateLibC_t)PE_getProcAddress(hModule,"_TerminateLibC")) != NULL)
		TerminateLibC();
	    if (hModule->shared)
		PM_freeShared(hModule);
	    else
		PM_free(hModule);
	    }
	}
}

/****************************************************************************
DESCRIPTION:
Returns the error code for the last operation

HEADER:
peloader.h

RETURNS:
Error code for the last operation.

SEE ALSO:
PE_getProcAddress, PE_loadLibrary
****************************************************************************/
int PEAPI PE_getError(void)
{
    return result;
}