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

Initial import.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@3 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
bbahnsen
2006-04-21 22:54:32 +00:00
commit 878ddf1fc3
2651 changed files with 624620 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.mbd Normal file
View File

@@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
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.
-->
<LibraryModuleBuildDescription xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0 http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">
<MbdLibHeader>
<BaseName>BaseMemoryLibMmx</BaseName>
<Guid>d458a654-f64c-49db-b8d1-3821306bf1f6</Guid>
<Version>EDK_RELEASE_VERSION 0x00090000</Version>
<Description>FIX ME!</Description>
<Copyright>Copyright (c) 2006, Intel Corporation</Copyright>
<License>
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.
</License>
<Created>2006-04-12 19:53</Created>
</MbdLibHeader>
</LibraryModuleBuildDescription>

58
MdePkg/Library/BaseMemoryLibMmx/BaseMemoryLibMmx.msa Normal file
View File

@@ -0,0 +1,58 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
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.
-->
<LibraryModuleSurfaceArea xmlns="http://www.TianoCore.org/2006/Edk2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.TianoCore.org/2006/Edk2.0 http://www.TianoCore.org/2006/Edk2.0/SurfaceArea.xsd">
<MsaLibHeader>
<BaseName>BaseMemoryLibMmx</BaseName>
<ModuleType>BASE</ModuleType>
<ComponentType>LIBRARY</ComponentType>
<Guid>d458a654-f64c-49db-b8d1-3821306bf1f6</Guid>
<Version>EDK_RELEASE_VERSION 0x00090000</Version>
<Abstract>Memory-only library functions with no library constructor/destructor</Abstract>
<Description>FIX ME!</Description>
<Copyright>Copyright (c) 2006, Intel Corporation</Copyright>
<License>
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.
</License>
<Specification>EFI_SPECIFICATION_VERSION 0x00000000</Specification>
<Created>2006-04-12 19:53</Created>
</MsaLibHeader>
<LibraryClassDefinitions>
<LibraryClass Usage="ALWAYS_PRODUCED">BaseMemoryLib</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">BaseLib</LibraryClass>
<LibraryClass Usage="ALWAYS_CONSUMED">DebugLib</LibraryClass>
</LibraryClassDefinitions>
<SourceFiles>
<Arch ArchType="IA32">
<Filename>MemLibGuid.c</Filename>
<Filename>MemLibWrapper.c</Filename>
<Filename>Ia32\CopyMem.asm</Filename>
<Filename>Ia32\SetMem.asm</Filename>
<Filename>Ia32\ZeroMem.asm</Filename>
<Filename>Ia32\SetMem16.asm</Filename>
<Filename>Ia32\SetMem32.asm</Filename>
<Filename>Ia32\SetMem64.asm</Filename>
<Filename>Ia32\CompareMem.asm</Filename>
<Filename>Ia32\ScanMem8.asm</Filename>
<Filename>Ia32\ScanMem16.asm</Filename>
<Filename>Ia32\ScanMem32.asm</Filename>
<Filename>Ia32\ScanMem64.asm</Filename>
</Arch>
</SourceFiles>
<Includes>
<PackageName>MdePkg</PackageName>
</Includes>
</LibraryModuleSurfaceArea>

131
MdePkg/Library/BaseMemoryLibMmx/MemLibGuid.c Normal file
View File

@@ -0,0 +1,131 @@
/** @file
Implementation of GUID functions.
Copyright (c) 2006, Intel Corporation<BR>
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: MemLibGuid.c
The following BaseMemoryLib instances share the same version of this file:
BaseMemoryLib
BaseMemoryLibMmx
BaseMemoryLibSse2
BaseMemoryLibRepStr
PeiMemoryLib
UefiMemoryLib
**/
/**
This function copies a source GUID to a destination GUID.
This function copies the contents of the 128-bit GUID specified by SourceGuid
to DestinationGuid, and returns DestinationGuid.
If DestinationGuid is NULL, then ASSERT().
If SourceGuid is NULL, then ASSERT().
@param DestinationGuid Pointer to the destination GUID.
@param SourceGuid Pointer to the source GUID.
@return DestinationGuid
**/
GUID *
EFIAPI
CopyGuid (
OUT GUID *DestinationGuid,
IN CONST GUID *SourceGuid
)
{
WriteUnaligned64 (
(UINT64*)DestinationGuid,
ReadUnaligned64 ((CONST UINT64*)SourceGuid)
);
WriteUnaligned64 (
(UINT64*)DestinationGuid + 1,
ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1)
);
return DestinationGuid;
}
/**
Compares two GUIDs
This function compares Guid1 to Guid2. If the GUIDs are identical then TRUE
is returned. If there are any bit differences in the two GUIDs, then FALSE is
returned.
If Guid1 is NULL, then ASSERT().
If Guid2 is NULL, then ASSERT().
@param Guid1 guid to compare
@param Guid2 guid to compare
@retval TRUE if Guid1 == Guid2
@retval FALSE if Guid1 != Guid2
**/
BOOLEAN
EFIAPI
CompareGuid (
IN CONST GUID *Guid1,
IN CONST GUID *Guid2
)
{
return (BOOLEAN)(
ReadUnaligned64 ((CONST UINT64*)Guid1)
== ReadUnaligned64 ((CONST UINT64*)Guid2) &&
ReadUnaligned64 ((CONST UINT64*)Guid1 + 1)
== ReadUnaligned64 ((CONST UINT64*)Guid2 + 1)
);
}
/**
Scans a target buffer for a GUID, and returns a pointer to the matching GUID
in the target buffer.
This function searches target the buffer specified by Buffer and Length from
the lowest address to the highest address at 128-bit increments for the
128-bit GUID value that matches Guid. If a match is found, then a pointer to
the matching GUID in the target buffer is returned. If no match is found,
then NULL is returned. If Length is 0, then NULL is returned.
If Buffer is NULL, then ASSERT().
If Buffer is not aligned on a 64-bit boundary, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan.
@param Guid Value to search for in the target buffer.
@return Pointer to the first occurrence.
@retval NULL if Length == 0 or Guid was not found.
**/
VOID *
EFIAPI
ScanGuid (
IN CONST VOID *Buffer,
IN UINTN Length,
IN CONST GUID *Guid
)
{
CONST GUID *GuidPtr;
GuidPtr = (GUID*)Buffer;
Buffer = GuidPtr + Length / sizeof (*GuidPtr);
while (GuidPtr < (CONST GUID*)Buffer) {
if (CompareGuid (GuidPtr, Guid)) {
return (VOID*)GuidPtr;
}
GuidPtr++;
}
return NULL;
}

620
MdePkg/Library/BaseMemoryLibMmx/MemLibWrapper.c Normal file
View File

@@ -0,0 +1,620 @@
/** @file
Wrapper functions for Base Memory Library.
Copyright (c) 2006, Intel Corporation<BR>
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: MemLibWrapper.c
The following BaseMemoryLib instances share the same version of this file:
BaseMemoryLib
BaseMemoryLibMmx
BaseMemoryLibSse2
BaseMemoryLibRepStr
PeiMemoryLib
UefiMemoryLib
**/
/**
Copy Length bytes from Source to Destination.
@param Destination Target of copy
@param Source Place to copy from
@param Length Number of bytes to copy
@return Destination
**/
VOID *
EFIAPI
InternalMemCopyMem (
OUT VOID *DestinationBuffer,
IN CONST VOID *SourceBuffer,
IN UINTN Length
);
/**
Set Buffer to Value for Size bytes.
@param Buffer Memory to set.
@param Size Number of bytes to set
@param Value Value of the set operation.
@return Buffer
**/
VOID *
EFIAPI
InternalMemSetMem (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT8 Value
);
/**
Fills a target buffer with a 16-bit value, and returns the target buffer.
@param Buffer Pointer to the target buffer to fill.
@param Length Number of bytes in Buffer to fill.
@param Value Value with which to fill Length bytes of Buffer.
@return Buffer
**/
VOID *
EFIAPI
InternalMemSetMem16 (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT16 Value
);
/**
Fills a target buffer with a 32-bit value, and returns the target buffer.
@param Buffer Pointer to the target buffer to fill.
@param Length Number of bytes in Buffer to fill.
@param Value Value with which to fill Length bytes of Buffer.
@return Buffer
**/
VOID *
EFIAPI
InternalMemSetMem32 (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT32 Value
);
/**
Fills a target buffer with a 64-bit value, and returns the target buffer.
@param Buffer Pointer to the target buffer to fill.
@param Length Number of bytes in Buffer to fill.
@param Value Value with which to fill Length bytes of Buffer.
@return Buffer
**/
VOID *
EFIAPI
InternalMemSetMem64 (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT64 Value
);
/**
Set Buffer to 0 for Size bytes.
@param Buffer Memory to set.
@param Size Number of bytes to set
@return Buffer
**/
VOID *
EFIAPI
InternalMemZeroMem (
OUT VOID *Buffer,
IN UINTN Length
);
/**
Compares two memory buffers of a given length.
@param DestinationBuffer First memory buffer
@param SourceBuffer Second memory buffer
@param Length Length of DestinationBuffer and SourceBuffer memory
regions to compare. Must be non-zero.
@retval 0 if MemOne == MemTwo
**/
INTN
EFIAPI
InternalMemCompareMem (
IN CONST VOID *DestinationBuffer,
IN CONST VOID *SourceBuffer,
IN UINTN Length
);
/**
Scans a target buffer for an 8-bit value, and returns a pointer to the
matching 8-bit value in the target buffer.
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan. Must be non-zero.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
**/
CONST VOID *
EFIAPI
InternalMemScanMem8 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT8 Value
);
/**
Scans a target buffer for a 16-bit value, and returns a pointer to the
matching 16-bit value in the target buffer.
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan. Must be non-zero.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
**/
CONST VOID *
EFIAPI
InternalMemScanMem16 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT16 Value
);
/**
Scans a target buffer for a 32-bit value, and returns a pointer to the
matching 32-bit value in the target buffer.
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan. Must be non-zero.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
**/
CONST VOID *
EFIAPI
InternalMemScanMem32 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT32 Value
);
/**
Scans a target buffer for a 64-bit value, and returns a pointer to the
matching 64-bit value in the target buffer.
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan. Must be non-zero.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
**/
CONST VOID *
EFIAPI
InternalMemScanMem64 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT64 Value
);
/**
Copy Length bytes from Source to Destination.
This function copies Length bytes from SourceBuffer to DestinationBuffer, and
returns DestinationBuffer. The implementation must be reentrant, and it must
handle the case where SourceBuffer overlaps DestinationBuffer.
If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then
ASSERT().
If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
@param Destination Target of copy
@param Source Place to copy from
@param Length Number of bytes to copy
@return Destination
**/
VOID *
EFIAPI
CopyMem (
OUT VOID *Destination,
IN CONST VOID *Source,
IN UINTN Length
)
{
ASSERT (Length <= MAX_ADDRESS - (UINTN)Destination + 1);
ASSERT (Length <= MAX_ADDRESS - (UINTN)Source + 1);
return InternalMemCopyMem (Destination, Source, Length);
}
/**
Set Buffer to Value for Size bytes.
This function fills Length bytes of Buffer with Value, and returns Buffer.
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Memory to set.
@param Size Number of bytes to set
@param Value Value of the set operation.
@return Buffer
**/
VOID *
EFIAPI
SetMem (
IN VOID *Buffer,
IN UINTN Size,
IN UINT8 Value
)
{
ASSERT (Size <= MAX_ADDRESS - (UINTN)Buffer + 1);
return InternalMemSetMem (Buffer, Size, Value);
}
/**
Fills a target buffer with a 16-bit value, and returns the target buffer.
This function fills Length bytes of Buffer with the 16-bit value specified by
Value, and returns Buffer. Value is repeated every 16-bits in for Length
bytes of Buffer.
If Buffer is NULL and Length > 0, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
If Buffer is not aligned on a 16-bit boundary, then ASSERT().
If Length is not aligned on a 16-bit boundary, then ASSERT().
@param Buffer Pointer to the target buffer to fill.
@param Length Number of bytes in Buffer to fill.
@param Value Value with which to fill Length bytes of Buffer.
@return Buffer
**/
VOID *
EFIAPI
SetMem16 (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT16 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (Length <= MAX_ADDRESS - (UINTN)Buffer + 1);
ASSERT ((((UINTN)Buffer) & 1) != 0);
ASSERT ((Length & 1) != 0);
if ((Length /= sizeof (Value)) == 0) {
return Buffer;
}
return InternalMemSetMem16 (Buffer, Length, Value);
}
/**
Fills a target buffer with a 32-bit value, and returns the target buffer.
This function fills Length bytes of Buffer with the 32-bit value specified by
Value, and returns Buffer. Value is repeated every 32-bits in for Length
bytes of Buffer.
If Buffer is NULL and Length > 0, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
If Buffer is not aligned on a 32-bit boundary, then ASSERT().
If Length is not aligned on a 32-bit boundary, then ASSERT().
@param Buffer Pointer to the target buffer to fill.
@param Length Number of bytes in Buffer to fill.
@param Value Value with which to fill Length bytes of Buffer.
@return Buffer
**/
VOID *
EFIAPI
SetMem32 (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT32 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (Length <= MAX_ADDRESS - (UINTN)Buffer + 1);
ASSERT ((((UINTN)Buffer) & 1) != 0);
ASSERT ((Length & 1) != 0);
if ((Length /= sizeof (Value)) == 0) {
return Buffer;
}
return InternalMemSetMem32 (Buffer, Length, Value);
}
/**
Fills a target buffer with a 64-bit value, and returns the target buffer.
This function fills Length bytes of Buffer with the 64-bit value specified by
Value, and returns Buffer. Value is repeated every 64-bits in for Length
bytes of Buffer.
If Buffer is NULL and Length > 0, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
If Buffer is not aligned on a 64-bit boundary, then ASSERT().
If Length is not aligned on a 64-bit boundary, then ASSERT().
@param Buffer Pointer to the target buffer to fill.
@param Length Number of bytes in Buffer to fill.
@param Value Value with which to fill Length bytes of Buffer.
@return Buffer
**/
VOID *
EFIAPI
SetMem64 (
OUT VOID *Buffer,
IN UINTN Length,
IN UINT64 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (Length <= MAX_ADDRESS - (UINTN)Buffer + 1);
ASSERT ((((UINTN)Buffer) & 1) != 0);
ASSERT ((Length & 1) != 0);
if ((Length /= sizeof (Value)) == 0) {
return Buffer;
}
return InternalMemSetMem64 (Buffer, Length, Value);
}
/**
Set Buffer to 0 for Size bytes.
This function fills Length bytes of Buffer with zeros, and returns Buffer.
If Buffer is NULL and Length > 0, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Memory to set.
@param Size Number of bytes to set
@return Buffer
**/
VOID *
EFIAPI
ZeroMem (
IN VOID *Buffer,
IN UINTN Size
)
{
ASSERT (Buffer != NULL);
return InternalMemSetMem (Buffer, Size, 0);
}
/**
Compares two memory buffers of a given length.
This function compares Length bytes of SourceBuffer to Length bytes of
DestinationBuffer. If all Length bytes of the two buffers are identical, then
0 is returned. Otherwise, the value returned is the first mismatched byte in
SourceBuffer subtracted from the first mismatched byte in DestinationBuffer.
If DestinationBuffer is NULL and Length > 0, then ASSERT().
If SourceBuffer is NULL and Length > 0, then ASSERT().
If Length is greater than (MAX_ADDRESS - DestinationBuffer + 1), then
ASSERT().
If Length is greater than (MAX_ADDRESS - SourceBuffer + 1), then ASSERT().
@param DestinationBuffer First memory buffer
@param SourceBuffer Second memory buffer
@param Length Length of DestinationBuffer and SourceBuffer memory
regions to compare
@retval 0 if DestinationBuffer == SourceBuffer
@retval Non-zero if DestinationBuffer != SourceBuffer
**/
INTN
EFIAPI
CompareMem (
IN CONST VOID *DestinationBuffer,
IN CONST VOID *SourceBuffer,
IN UINTN Length
)
{
ASSERT (DestinationBuffer != NULL);
ASSERT (SourceBuffer != NULL);
ASSERT (Length <= MAX_ADDRESS - (UINTN)DestinationBuffer + 1);
ASSERT (Length <= MAX_ADDRESS - (UINTN)SourceBuffer + 1);
if (Length == 0) {
return 0;
}
return InternalMemCompareMem (DestinationBuffer, SourceBuffer, Length);
}
/**
Scans a target buffer for an 8-bit value, and returns a pointer to the
matching 8-bit value in the target buffer.
This function searches target the buffer specified by Buffer and Length from
the lowest address to the highest address for an 8-bit value that matches
Value. If a match is found, then a pointer to the matching byte in the target
buffer is returned. If no match is found, then NULL is returned. If Length is
0, then NULL is returned.
If Buffer is NULL, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
@retval NULL if Length == 0 or Value was not found.
**/
VOID *
EFIAPI
ScanMem8 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT8 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (Length <= MAX_ADDRESS + (UINTN)Buffer + 1);
if ((Length /= sizeof (Value)) == 0) {
return NULL;
}
return (VOID*)InternalMemScanMem8 (Buffer, Length, Value);
}
/**
Scans a target buffer for a 16-bit value, and returns a pointer to the
matching 16-bit value in the target buffer.
This function searches target the buffer specified by Buffer and Length from
the lowest address to the highest address at 16-bit increments for a 16-bit
value that matches Value. If a match is found, then a pointer to the matching
value in the target buffer is returned. If no match is found, then NULL is
returned. If Length is 0, then NULL is returned.
If Buffer is NULL, then ASSERT().
If Buffer is not aligned on a 16-bit boundary, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence.
@retval NULL if Length == 0 or Value was not found.
**/
VOID *
EFIAPI
ScanMem16 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT16 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
ASSERT (Length <= MAX_ADDRESS + (UINTN)Buffer + 1);
if ((Length /= sizeof (Value)) == 0) {
return NULL;
}
return (VOID*)InternalMemScanMem16 (Buffer, Length, Value);
}
/**
Scans a target buffer for a 32-bit value, and returns a pointer to the
matching 32-bit value in the target buffer.
This function searches target the buffer specified by Buffer and Length from
the lowest address to the highest address at 32-bit increments for a 32-bit
value that matches Value. If a match is found, then a pointer to the matching
value in the target buffer is returned. If no match is found, then NULL is
returned. If Length is 0, then NULL is returned.
If Buffer is NULL, then ASSERT().
If Buffer is not aligned on a 32-bit boundary, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
@retval NULL if Length == 0 or Value was not found.
**/
VOID *
EFIAPI
ScanMem32 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT32 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
ASSERT (Length <= MAX_ADDRESS + (UINTN)Buffer + 1);
if ((Length /= sizeof (Value)) == 0) {
return NULL;
}
return (VOID*)InternalMemScanMem32 (Buffer, Length, Value);
}
/**
Scans a target buffer for a 64-bit value, and returns a pointer to the
matching 64-bit value in the target buffer.
This function searches target the buffer specified by Buffer and Length from
the lowest address to the highest address at 64-bit increments for a 64-bit
value that matches Value. If a match is found, then a pointer to the matching
value in the target buffer is returned. If no match is found, then NULL is
returned. If Length is 0, then NULL is returned.
If Buffer is NULL, then ASSERT().
If Buffer is not aligned on a 64-bit boundary, then ASSERT().
If Length is greater than (MAX_ADDRESS - Buffer + 1), then ASSERT().
@param Buffer Pointer to the target buffer to scan.
@param Length Number of bytes in Buffer to scan.
@param Value Value to search for in the target buffer.
@return Pointer to the first occurrence or NULL if not found.
@retval NULL if Length == 0 or Value was not found.
**/
VOID *
EFIAPI
ScanMem64 (
IN CONST VOID *Buffer,
IN UINTN Length,
IN UINT64 Value
)
{
ASSERT (Buffer != NULL);
ASSERT (((UINTN)Buffer & (sizeof (Value) - 1)) == 0);
ASSERT (Length <= MAX_ADDRESS + (UINTN)Buffer + 1);
if ((Length /= sizeof (Value)) == 0) {
return NULL;
}
return (VOID*)InternalMemScanMem64 (Buffer, Length, Value);
}

47
MdePkg/Library/BaseMemoryLibMmx/build.xml Normal file
View File

@@ -0,0 +1,47 @@
<?xml version="1.0" encoding="UTF-8"?><!-- 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 basedir="." default="BaseMemoryLibMmx"><!--Apply external ANT tasks-->
<taskdef resource="GenBuild.tasks"/>
<taskdef resource="net/sf/antcontrib/antlib.xml"/>
<property environment="env"/>
<property name="WORKSPACE_DIR" value="${env.WORKSPACE}"/>
<import file="${WORKSPACE_DIR}\Tools\Conf\BuildMacro.xml"/><!--MODULE_RELATIVE PATH is relative to PACKAGE_DIR-->
<property name="MODULE_RELATIVE_PATH" value="Library\BaseMemoryLibMmx"/>
<property name="MODULE_DIR" value="${PACKAGE_DIR}\${MODULE_RELATIVE_PATH}"/>
<property name="COMMON_FILE" value="${WORKSPACE_DIR}\Tools\Conf\Common.xml"/>
<target name="BaseMemoryLibMmx">
<GenBuild baseName="BaseMemoryLibMmx" mbdFilename="${MODULE_DIR}\BaseMemoryLibMmx.mbd" msaFilename="${MODULE_DIR}\BaseMemoryLibMmx.msa"/>
</target>
<target depends="BaseMemoryLibMmx_clean" name="clean"/>
<target depends="BaseMemoryLibMmx_cleanall" name="cleanall"/>
<target name="BaseMemoryLibMmx_clean">
<OutputDirSetup baseName="BaseMemoryLibMmx" mbdFilename="${MODULE_DIR}\BaseMemoryLibMmx.mbd" msaFilename="${MODULE_DIR}\BaseMemoryLibMmx.msa"/>
<if>
<available file="${DEST_DIR_OUTPUT}\BaseMemoryLibMmx_build.xml"/>
<then>
<ant antfile="${DEST_DIR_OUTPUT}\BaseMemoryLibMmx_build.xml" target="clean"/>
</then>
</if>
<delete dir="${DEST_DIR_OUTPUT}" excludes="*.xml"/>
</target>
<target name="BaseMemoryLibMmx_cleanall">
<OutputDirSetup baseName="BaseMemoryLibMmx" mbdFilename="${MODULE_DIR}\BaseMemoryLibMmx.mbd" msaFilename="${MODULE_DIR}\BaseMemoryLibMmx.msa"/>
<if>
<available file="${DEST_DIR_OUTPUT}\BaseMemoryLibMmx_build.xml"/>
<then>
<ant antfile="${DEST_DIR_OUTPUT}\BaseMemoryLibMmx_build.xml" target="cleanall"/>
</then>
</if>
<delete dir="${DEST_DIR_OUTPUT}"/>
<delete dir="${DEST_DIR_DEBUG}"/>
<delete>
<fileset dir="${BIN_DIR}" includes="**BaseMemoryLibMmx*"/>
</delete>
</target>
</project>

46
MdePkg/Library/BaseMemoryLibMmx/ia32/CompareMem.asm Normal file
View File

@@ -0,0 +1,46 @@
;------------------------------------------------------------------------------
;
; 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:
;
; CompareMem.Asm
;
; Abstract:
;
; CompareMem function
;
; Notes:
;
; The following BaseMemoryLib instances share the same version of this file:
;
; BaseMemoryLibRepStr
; BaseMemoryLibMmx
; BaseMemoryLibSse2
;
;------------------------------------------------------------------------------
.686
.model flat,C
.code
InternalMemCompareMem PROC USES esi edi
mov esi, [esp + 12]
mov edi, [esp + 16]
mov ecx, [esp + 20]
repe cmpsb
movzx eax, byte ptr [esi - 1]
movzx edx, byte ptr [edi - 1]
sub eax, edx
sub eax, edx
ret
InternalMemCompareMem ENDP
END

86
MdePkg/Library/BaseMemoryLibMmx/ia32/CopyMem.asm Normal file
View File

@@ -0,0 +1,86 @@
;------------------------------------------------------------------------------
;
; 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:
;
; CopyMem.asm
;
; Abstract:
;
; CopyMem function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.xmm
.code
;------------------------------------------------------------------------------
; VOID *
; _mem_CopyMem (
; IN VOID *Destination,
; IN VOID *Source,
; IN UINTN Count
; )
;------------------------------------------------------------------------------
InternalMemCopyMem PROC USES esi edi
mov esi, [esp + 16] ; esi <- Source
mov edi, [esp + 12] ; edi <- Destination
mov edx, [esp + 20] ; edx <- Count
lea eax, [edi + edx - 1] ; eax <- End of Destination
cmp esi, edi
jae @F
cmp eax, esi ; Overlapped?
jae @CopyBackward ; Copy backward if overlapped
@@:
xor ecx, ecx
sub ecx, esi
and ecx, 7 ; ecx + esi aligns on 8-byte boundary
jz @F
cmp ecx, edx
cmova ecx, edx
sub edx, ecx ; edx <- remaining bytes to copy
rep movsb
@@:
mov ecx, edx
and edx, 7
shr ecx, 3 ; ecx <- # of Qwords to copy
jz @CopyBytes
push eax
push eax
movq [esp], mm0 ; save mm0
@@:
movq mm0, [esi]
movntq [edi], mm0
add esi, 8
add edi, 8
loop @B
mfence
movq mm0, [esp] ; restore mm0
pop ecx ; stack cleanup
pop ecx ; stack cleanup
jmp @CopyBytes
@CopyBackward:
mov edi, eax ; edi <- Last byte in Destination
lea esi, [esi + edx - 1] ; esi <- Last byte in Source
std
@CopyBytes:
mov ecx, edx
rep movsb
cld
mov eax, [esp + 12]
ret
InternalMemCopyMem ENDP
END

44
MdePkg/Library/BaseMemoryLibMmx/ia32/ScanMem16.asm Normal file
View File

@@ -0,0 +1,44 @@
;------------------------------------------------------------------------------
;
; 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:
;
; ScanMem16.Asm
;
; Abstract:
;
; ScanMem16 function
;
; Notes:
;
; The following BaseMemoryLib instances share the same version of this file:
;
; BaseMemoryLibRepStr
; BaseMemoryLibMmx
; BaseMemoryLibSse2
;
;------------------------------------------------------------------------------
.686
.model flat,C
.code
InternalMemScanMem16 PROC USES edi
mov ecx, [esp + 12]
mov edi, [esp + 8]
mov eax, [esp + 16]
repne scasw
lea eax, [edi - 2]
cmovnz eax, ecx
ret
InternalMemScanMem16 ENDP
END

44
MdePkg/Library/BaseMemoryLibMmx/ia32/ScanMem32.asm Normal file
View File

@@ -0,0 +1,44 @@
;------------------------------------------------------------------------------
;
; 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:
;
; ScanMem32.Asm
;
; Abstract:
;
; ScanMem32 function
;
; Notes:
;
; The following BaseMemoryLib instances share the same version of this file:
;
; BaseMemoryLibRepStr
; BaseMemoryLibMmx
; BaseMemoryLibSse2
;
;------------------------------------------------------------------------------
.686
.model flat,C
.code
InternalMemScanMem32 PROC USES edi
mov ecx, [esp + 12]
mov edi, [esp + 8]
mov eax, [esp + 16]
repne scasd
lea eax, [edi - 4]
cmovnz eax, ecx
ret
InternalMemScanMem32 ENDP
END

53
MdePkg/Library/BaseMemoryLibMmx/ia32/ScanMem64.asm Normal file
View File

@@ -0,0 +1,53 @@
;------------------------------------------------------------------------------
;
; 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:
;
; ScanMem64.Asm
;
; Abstract:
;
; ScanMem64 function
;
; Notes:
;
; The following BaseMemoryLib instances share the same version of this file:
;
; BaseMemoryLibRepStr
; BaseMemoryLibMmx
; BaseMemoryLibSse2
;
;------------------------------------------------------------------------------
.686
.model flat,C
.code
InternalMemScanMem64 PROC USES edi
mov ecx, [esp + 12]
mov eax, [esp + 16]
mov edx, [esp + 20]
mov edi, [esp + 8]
@@:
cmp eax, [edi]
lea edi, [edi + 8]
loopne @B
jne @F
cmp edx, [edi - 4]
jecxz @F
jne @B
@@:
lea eax, [edi - 8]
cmovne eax, ecx
ret
InternalMemScanMem64 ENDP
END

44
MdePkg/Library/BaseMemoryLibMmx/ia32/ScanMem8.asm Normal file
View File

@@ -0,0 +1,44 @@
;------------------------------------------------------------------------------
;
; 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:
;
; ScanMem8.Asm
;
; Abstract:
;
; ScanMem8 function
;
; Notes:
;
; The following BaseMemoryLib instances share the same version of this file:
;
; BaseMemoryLibRepStr
; BaseMemoryLibMmx
; BaseMemoryLibSse2
;
;------------------------------------------------------------------------------
.686
.model flat,C
.code
InternalMemScanMem8 PROC USES edi
mov ecx, [esp + 12]
mov edi, [esp + 8]
mov al, [esp + 16]
repne scasb
lea eax, [edi - 1]
cmovnz eax, ecx
ret
InternalMemScanMem8 ENDP
END

66
MdePkg/Library/BaseMemoryLibMmx/ia32/SetMem.asm Normal file
View File

@@ -0,0 +1,66 @@
;------------------------------------------------------------------------------
;
; 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:
;
; SetMem.asm
;
; Abstract:
;
; SetMem function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.xmm
.code
;------------------------------------------------------------------------------
; VOID *
; _mem_SetMem (
; IN VOID *Buffer,
; IN UINTN Count,
; IN UINT8 Value
; )
;------------------------------------------------------------------------------
InternalMemSetMem PROC USES edi
mov ecx, [esp + 12] ; ecx <- Count
mov edi, [esp + 8] ; edi <- Buffer
mov edx, ecx
shr ecx, 3 ; # of Qwords to set
mov al, [esp + 16] ; al <- Value
jz @SetBytes
mov ah, al ; ax <- Value | (Value << 8)
push ecx
push ecx
movq [esp], mm0 ; save mm0
movd mm0, eax
pshufw mm0, mm0, 0 ; fill mm0 with 8 Value's
@@:
movntq [edi], mm0
add edi, 8
loop @B
mfence
movq mm0, [esp] ; restore mm0
pop ecx ; stack cleanup
pop ecx
@SetBytes:
and edx, 7
mov ecx, edx
rep stosb
mov eax, [esp + 8] ; eax <- Buffer as return value
ret
InternalMemSetMem ENDP
END

59
MdePkg/Library/BaseMemoryLibMmx/ia32/SetMem16.asm Normal file
View File

@@ -0,0 +1,59 @@
;------------------------------------------------------------------------------
;
; 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:
;
; SetMem16.asm
;
; Abstract:
;
; SetMem16 function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.xmm
.code
;------------------------------------------------------------------------------
; VOID *
; _mem_SetMem16 (
; IN VOID *Buffer,
; IN UINTN Count,
; IN UINT16 Value
; )
;------------------------------------------------------------------------------
InternalMemSetMem16 PROC USES edi
mov edx, [esp + 12]
mov edi, [esp + 8]
mov ecx, edx
and edx, 3
shr ecx, 2
mov eax, [esp + 16]
jz @SetWords
movd mm0, eax
pshufw mm0, mm0, 0
@@:
movntq [edi], mm0
add edi, 8
loop @B
mfence
@SetWords:
mov ecx, edx
rep stosw
mov eax, [esp + 8]
ret
InternalMemSetMem16 ENDP
END

59
MdePkg/Library/BaseMemoryLibMmx/ia32/SetMem32.asm Normal file
View File

@@ -0,0 +1,59 @@
;------------------------------------------------------------------------------
;
; 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:
;
; SetMem32.asm
;
; Abstract:
;
; SetMem32 function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.xmm
.code
;------------------------------------------------------------------------------
; VOID *
; _mem_SetMem32 (
; IN VOID *Buffer,
; IN UINTN Count,
; IN UINT32 Value
; )
;------------------------------------------------------------------------------
InternalMemSetMem32 PROC USES edi
mov edx, [esp + 12]
mov edi, [esp + 8]
mov ecx, edx
shr ecx, 1
movd mm0, [esp + 16]
mov eax, edi
jz @SetDwords
pshufw mm0, mm0, 44h
@@:
movntq [edi], mm0
add edi, 8
loop @B
mfence
@SetDwords:
test dl, 1
jz @F
movd [edi], mm0
@@:
ret
InternalMemSetMem32 ENDP
END

50
MdePkg/Library/BaseMemoryLibMmx/ia32/SetMem64.asm Normal file
View File

@@ -0,0 +1,50 @@
;------------------------------------------------------------------------------
;
; 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:
;
; SetMem64.asm
;
; Abstract:
;
; SetMem64 function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.xmm
.code
;------------------------------------------------------------------------------
; VOID *
; _mem_SetMem64 (
; IN VOID *Buffer,
; IN UINTN Count,
; IN UINT64 Value
; )
;------------------------------------------------------------------------------
InternalMemSetMem64 PROC USES edi
movq mm0, [esp + 16]
mov ecx, [esp + 12]
mov edi, [esp + 8]
mov eax, edi
@@:
movntq [edi], mm0
add edi, 8
loop @B
mfence
ret
InternalMemSetMem64 ENDP
END

57
MdePkg/Library/BaseMemoryLibMmx/ia32/ZeroMem.asm Normal file
View File

@@ -0,0 +1,57 @@
;------------------------------------------------------------------------------
;
; 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:
;
; ZeroMem.asm
;
; Abstract:
;
; ZeroMem function
;
; Notes:
;
;------------------------------------------------------------------------------
.686
.model flat,C
.xmm
.code
;------------------------------------------------------------------------------
; VOID *
; _mem_ZeroMem (
; IN VOID *Buffer,
; IN UINTN Count
; )
;------------------------------------------------------------------------------
InternalMemZeroMem PROC USES edi
mov edi, [esp + 8]
mov ecx, [esp + 12]
mov edx, ecx
shr ecx, 3
jz @ZeroBytes
pxor mm0, mm0
@@:
movntq [edi], mm0
add edi, 8
loop @B
mfence
@ZeroBytes:
and edx, 7
xor eax, eax
mov ecx, edx
rep stosb
mov eax, [esp + 8]
ret
InternalMemZeroMem ENDP
END