ArmPlatformPkg/ArmShellCmdRunAxf: Added 'runaxf' cmd to shell
authorHarry Liebel <Harry.Liebel@arm.com>
Mon, 27 Oct 2014 10:52:11 +0000 (10:52 +0000)
committeroliviermartin <oliviermartin@Edk2>
Mon, 27 Oct 2014 10:52:11 +0000 (10:52 +0000)
Use the command to load and start a ARM Executable File from mass storage.
This is basically just an ELF file. The program is copied to memory and
the Entrypoint is called. Control is not expected to return back to the
Shell. This has only been tested on AArch64 with a limited set of AXF
binaries.

Contributed-under: TianoCore Contribution Agreement 1.0
Signed-off-by: Harry Liebel <Harry.Liebel@arm.com>
Reviewed-By: Olivier Martin <olivier.martin@arm.com>
git-svn-id: https://svn.code.sf.net/p/edk2/code/trunk/edk2@16247 6f19259b-4bc3-4df7-8a09-765794883524

17 files changed:
ArmPlatformPkg/ArmVExpressPkg/ArmVExpress.dsc.inc
ArmPlatformPkg/ArmVExpressPkg/ArmVExpressDxe/ArmFvpDxe.c
ArmPlatformPkg/ArmVExpressPkg/ArmVExpressDxe/ArmFvpDxe.inf
ArmPlatformPkg/ArmVExpressPkg/ArmVExpressDxe/ArmHwDxe.c
ArmPlatformPkg/ArmVExpressPkg/ArmVExpressDxe/ArmHwDxe.inf
ArmPlatformPkg/Include/Library/ArmShellCmdLib.h [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.c [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.h [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.inf [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/BootMonFsLoader.c [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/BootMonFsLoader.h [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/ElfLoader.c [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/ElfLoader.h [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/RunAxf.c [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf32.h [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf64.h [new file with mode: 0644]
ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf_common.h [new file with mode: 0644]

index c97aa58..f9af2a3 100644 (file)
   BdsLib|ArmPkg/Library/BdsLib/BdsLib.inf\r
   FdtLib|EmbeddedPkg/Library/FdtLib/FdtLib.inf\r
 \r
+  # RunAxf support via Dynamic Shell Command protocol\r
+  # It uses the Shell libraries.\r
+  ArmShellCmdRunAxfLib|ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.inf\r
+  ShellLib|ShellPkg/Library/UefiShellLib/UefiShellLib.inf\r
+  FileHandleLib|ShellPkg/Library/UefiFileHandleLib/UefiFileHandleLib.inf\r
+  SortLib|ShellPkg/Library/UefiSortLib/UefiSortLib.inf\r
+\r
 [LibraryClasses.common.SEC]\r
   ArmPlatformSecExtraActionLib|ArmPlatformPkg/Library/DebugSecExtraActionLib/DebugSecExtraActionLib.inf\r
   ArmPlatformGlobalVariableLib|ArmPlatformPkg/Library/ArmPlatformGlobalVariableLib/Sec/SecArmPlatformGlobalVariableLib.inf\r
   gArmPlatformTokenSpaceGuid.PcdDefaultConInPaths|L"VenHw(D3987D4B-971A-435F-8CAF-4967EB627241)/Uart(38400,8,N,1)/VenPcAnsi()"\r
   gArmPlatformTokenSpaceGuid.PcdPlatformBootTimeOut|10\r
 \r
+  # RunAxf support via Dynamic Shell Command protocol\r
+  # We want to use the Shell Libraries but don't want it to initialise\r
+  # automatically. We initialise the libraries when the command is called by the\r
+  # Shell.\r
+  gEfiShellPkgTokenSpaceGuid.PcdShellLibAutoInitialize|FALSE\r
+\r
 [Components.common]\r
   # Versatile Express FileSystem\r
   ArmPlatformPkg/FileSystem/BootMonFs/BootMonFs.inf\r
index 99a7cf7..64e4158 100644 (file)
@@ -16,6 +16,7 @@
 #include <Library/VirtioMmioDeviceLib.h>\r
 #include <Library/DebugLib.h>\r
 #include <Library/UefiBootServicesTableLib.h>\r
+#include <Library/ArmShellCmdLib.h>\r
 \r
 #define ARM_FVP_BASE_VIRTIO_BLOCK_BASE    0x1c130000\r
 \r
@@ -71,5 +72,11 @@ ArmFvpInitialise (
     DEBUG ((EFI_D_ERROR, "ArmFvpDxe: Failed to install Virtio block device\n"));\r
   }\r
 \r
+  // Install dynamic Shell command to run baremetal binaries.\r
+  Status = ShellDynCmdRunAxfInstall (ImageHandle);\r
+  if (EFI_ERROR (Status)) {\r
+    DEBUG ((EFI_D_ERROR, "ArmFvpDxe: Failed to install ShellDynCmdRunAxf\n"));\r
+  }\r
+\r
   return Status;\r
 }\r
index 465945d..7112144 100644 (file)
@@ -29,6 +29,7 @@
   OvmfPkg/OvmfPkg.dec\r
 \r
 [LibraryClasses]\r
+  ArmShellCmdRunAxfLib\r
   UefiDriverEntryPoint\r
   UefiBootServicesTableLib\r
   VirtioMmioDeviceLib\r
index bd7ef88..7ed5c61 100644 (file)
@@ -13,6 +13,8 @@
 **/\r
 \r
 #include <Library/UefiLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/ArmShellCmdLib.h>\r
 \r
 EFI_STATUS\r
 EFIAPI\r
@@ -21,5 +23,13 @@ ArmHwInitialise (
   IN EFI_SYSTEM_TABLE   *SystemTable\r
   )\r
 {\r
-  return EFI_SUCCESS;\r
+  EFI_STATUS  Status;\r
+\r
+  // Install dynamic Shell command to run baremetal binaries.\r
+  Status = ShellDynCmdRunAxfInstall (ImageHandle);\r
+  if (EFI_ERROR (Status)) {\r
+    DEBUG ((EFI_D_ERROR, "ArmHwDxe: Failed to install ShellDynCmdRunAxf\n"));\r
+  }\r
+\r
+  return Status;\r
 }\r
index 21f513f..3bcdbd0 100644 (file)
@@ -28,4 +28,5 @@
   ArmPlatformPkg/ArmPlatformPkg.dec\r
 \r
 [LibraryClasses]\r
+  ArmShellCmdRunAxfLib\r
   UefiDriverEntryPoint\r
diff --git a/ArmPlatformPkg/Include/Library/ArmShellCmdLib.h b/ArmPlatformPkg/Include/Library/ArmShellCmdLib.h
new file mode 100644 (file)
index 0000000..eb31cd4
--- /dev/null
@@ -0,0 +1,57 @@
+/** @file\r
+*\r
+*  Definitions for the Dynamic Shell command library\r
+*\r
+*  Copyright (C) 2014, ARM Ltd\r
+*\r
+*  This program and the accompanying materials are licensed and made available\r
+*  under the terms and conditions of the BSD License which accompanies this\r
+*  distribution. The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT\r
+*  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#ifndef _ARM_SHELL_CMD_LIB_H_\r
+#define _ARM_SHELL_CMD_LIB_H_\r
+\r
+/**\r
+\r
+  Initialize and Install EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL for RunAxf command.\r
+\r
+  @param[in] ImageHandle        Handle the protocol should be attached to.\r
+\r
+  @retval EFI_SUCCESS           The command has been installed successfully.\r
+\r
+  @retval EFI_UNSUPPORTED       Help for the command failed to initialise.\r
+\r
+  @return                       Status code returned by InstallProtocolInterface\r
+                                Boot Service function.\r
+\r
+**/\r
+EFI_STATUS\r
+ShellDynCmdRunAxfInstall (\r
+  IN EFI_HANDLE             ImageHandle\r
+  );\r
+\r
+/**\r
+\r
+  Uninstall the RunAxf Command\r
+\r
+  @param[in] ImageHandle  Handle of the device where the protocol should have\r
+                          been installed.\r
+\r
+  @retval EFI_SUCCESS     The device has been un-initialized successfully.\r
+\r
+  @return                 Status code returned by UninstallProtocolInterface\r
+                          Boot Service function.\r
+\r
+**/\r
+EFI_STATUS\r
+ShellDynCmdRunAxfUninstall (\r
+  IN EFI_HANDLE             ImageHandle\r
+  );\r
+\r
+#endif // _ARM_SHELL_CMD_LIB_H_\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.c b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.c
new file mode 100644 (file)
index 0000000..67bbb9e
--- /dev/null
@@ -0,0 +1,95 @@
+/** @file\r
+*\r
+*  Copyright (c) 2014, ARM Ltd. All rights reserved.<BR>\r
+*\r
+*  This program and the accompanying materials are licensed and made available\r
+*  under the terms and conditions of the BSD License which accompanies this\r
+*  distribution.  The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#include <Uefi.h>\r
+\r
+#include <Library/BaseLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiLib.h>\r
+#include <Library/ArmShellCmdLib.h>\r
+\r
+#include "ArmShellCmdRunAxf.h"\r
+\r
+EFI_HANDLE gRunAxfHiiHandle = NULL;\r
+\r
+#define RUNAXF_HII_GUID \\r
+  { \\r
+  0xf5a6413b, 0x78d5, 0x448e, { 0xa2, 0x15, 0x22, 0x82, 0x8e, 0xbc, 0x61, 0x61 } \\r
+  }\r
+\r
+EFI_GUID gRunAxfHiiGuid = RUNAXF_HII_GUID;\r
+\r
+static EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL mShellDynCmdProtocolRunAxf = {\r
+    L"runaxf",                             // *CommandName\r
+    ShellDynCmdRunAxfHandler,              // Handler\r
+    ShellDynCmdRunAxfGetHelp               // GetHelp\r
+};\r
+\r
+EFI_STATUS\r
+ShellDynCmdRunAxfInstall (\r
+  IN EFI_HANDLE             ImageHandle\r
+  )\r
+{\r
+  EFI_STATUS Status;\r
+\r
+  // Register our shell command\r
+  Status = gBS->InstallMultipleProtocolInterfaces (&ImageHandle,\r
+                 &gEfiShellDynamicCommandProtocolGuid,\r
+                 &mShellDynCmdProtocolRunAxf,\r
+                 NULL);\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  // Load the manual page for our command\r
+  //\r
+  // 3rd parameter 'HII strings array' must be name of .uni strings file\r
+  // followed by 'Strings', e.g. mycommands.uni must be specified as\r
+  // 'mycommandsStrings' because the build Autogen process defines this as a\r
+  // string array for the strings in your .uni file.  Examine your Build folder\r
+  // under your package's DEBUG folder and you will find it defined in a\r
+  // xxxStrDefs.h file.\r
+  //\r
+  gRunAxfHiiHandle = HiiAddPackages (&gRunAxfHiiGuid, ImageHandle,\r
+                                     ArmShellCmdRunAxfStrings, NULL);\r
+  if (gRunAxfHiiHandle == NULL) {\r
+    return EFI_UNSUPPORTED;\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+EFI_STATUS\r
+ShellDynCmdRunAxfUninstall (\r
+  IN EFI_HANDLE             ImageHandle\r
+  )\r
+{\r
+\r
+  EFI_STATUS Status;\r
+\r
+  if (gRunAxfHiiHandle != NULL) {\r
+    HiiRemovePackages (gRunAxfHiiHandle);\r
+  }\r
+\r
+  Status = gBS->UninstallMultipleProtocolInterfaces (ImageHandle,\r
+                 &gEfiShellDynamicCommandProtocolGuid,\r
+                 &mShellDynCmdProtocolRunAxf,\r
+                 NULL);\r
+  if (EFI_ERROR (Status)) {\r
+    return Status;\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.h b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.h
new file mode 100644 (file)
index 0000000..8599961
--- /dev/null
@@ -0,0 +1,85 @@
+/** @file\r
+*\r
+*  Copyright (c) 2014, ARM Ltd. All rights reserved.<BR>\r
+*\r
+*  This program and the accompanying materials are licensed and made available\r
+*  under the terms and conditions of the BSD License which accompanies this\r
+*  distribution.  The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#ifndef __ARM_SHELL_CMD_RUNAXF__\r
+#define __ARM_SHELL_CMD_RUNAXF__\r
+\r
+#include <ShellBase.h>\r
+\r
+#include <Protocol/EfiShell.h>\r
+#include <Protocol/EfiShellDynamicCommand.h>\r
+\r
+#include <Library/HiiLib.h>\r
+#include <Library/ShellLib.h>\r
+#include <Library/UefiBootServicesTableLib.h>\r
+\r
+extern EFI_GUID      gRunAxfHiiGuid;\r
+extern EFI_HANDLE    gRunAxfHiiHandle;\r
+extern EFI_HANDLE    gRunAxfImageHandle;\r
+\r
+// List of data segments to load to memory from AXF/ELF file.\r
+typedef struct {\r
+  LIST_ENTRY  Link;       // This attribute must be the first entry of this\r
+                          // structure (to avoid pointer computation)\r
+  UINTN       MemOffset;  // Where the data should go, Dest\r
+  UINTN       FileOffset; // Where the data is from, Src\r
+  BOOLEAN     Zeroes;     // A section of Zeroes. Like .bss in ELF\r
+  UINTN       Length;     // Number of bytes.\r
+} RUNAXF_LOAD_LIST;\r
+\r
+\r
+/**\r
+  This is the shell command handler function pointer callback type. This\r
+  function handles the command when it is invoked in the shell.\r
+\r
+  @param[in] This             The instance of the\r
+                              EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.\r
+  @param[in] SystemTable      The pointer to the system table.\r
+  @param[in] ShellParameters  The parameters associated with the command.\r
+  @param[in] Shell            The instance of the shell protocol used in the\r
+                              context of processing this command.\r
+\r
+  @return EFI_SUCCESS         The operation was successful.\r
+  @return other               The operation failed.\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellDynCmdRunAxfHandler (\r
+  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,\r
+  IN EFI_SYSTEM_TABLE                      *SystemTable,\r
+  IN EFI_SHELL_PARAMETERS_PROTOCOL         *ShellParameters,\r
+  IN EFI_SHELL_PROTOCOL                    *Shell\r
+  );\r
+\r
+\r
+/**\r
+  This is the command help handler function pointer callback type. This\r
+  function is responsible for displaying help information for the associated\r
+  command.\r
+\r
+  @param[in] This             The instance of the\r
+                              EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.\r
+  @param[in] Language         The pointer to the language string to use.\r
+\r
+  @return string              Pool allocated help string, must be freed by\r
+                              caller.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+ShellDynCmdRunAxfGetHelp (\r
+  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,\r
+  IN CONST CHAR8                           *Language\r
+  );\r
+\r
+#endif //__ARM_SHELL_CMD_RUNAXF__\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.inf b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ArmShellCmdRunAxf.inf
new file mode 100644 (file)
index 0000000..7d15f69
--- /dev/null
@@ -0,0 +1,54 @@
+## @file\r
+#\r
+#  Copyright (c) 2014, ARM Ltd. All rights reserved.<BR>\r
+#\r
+#  This program and the accompanying materials are licensed and made available\r
+#  under the terms and conditions of the BSD License which accompanies this\r
+#  distribution.  The full text of the license may be found at\r
+#  http://opensource.org/licenses/bsd-license.php\r
+#\r
+#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#\r
+##\r
+\r
+[Defines]\r
+  INF_VERSION                    = 0x00010006\r
+  BASE_NAME                      = ArmShellCmdRunAxf\r
+  FILE_GUID                      = 1f78349d-7fba-4686-8098-fa017eda35fb\r
+  MODULE_TYPE                    = UEFI_APPLICATION\r
+  VERSION_STRING                 = 1.0\r
+  LIBRARY_CLASS                  = ArmShellCmdRunAxfLib\r
+\r
+[Sources.common]\r
+  ArmShellCmdRunAxf.c\r
+  ArmShellCmdRunAxf.uni\r
+  RunAxf.c\r
+  BootMonFsLoader.h\r
+  BootMonFsLoader.c\r
+  ElfLoader.h\r
+  ElfLoader.c\r
+  # ELF definitions taken from BaseTools\r
+  elf32.h\r
+  elf64.h\r
+  elf_common.h\r
+\r
+[Packages]\r
+  ArmPkg/ArmPkg.dec\r
+  ArmPlatformPkg/ArmPlatformPkg.dec\r
+  MdeModulePkg/MdeModulePkg.dec\r
+  MdePkg/MdePkg.dec\r
+  ShellPkg/ShellPkg.dec\r
+\r
+[LibraryClasses]\r
+  ArmLib\r
+  BaseLib\r
+  DebugLib\r
+  HiiLib\r
+  ShellLib\r
+\r
+[Protocols]\r
+  gEfiShellDynamicCommandProtocolGuid\r
+\r
+[Guids]\r
+  gArmBootMonFsFileInfoGuid\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/BootMonFsLoader.c b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/BootMonFsLoader.c
new file mode 100644 (file)
index 0000000..0bce037
--- /dev/null
@@ -0,0 +1,154 @@
+/** @file\r
+*\r
+*  Copyright (c) 2014, ARM Ltd. All rights reserved.\r
+*\r
+*  This program and the accompanying materials are licensed and made available\r
+*  under the terms and conditions of the BSD License which accompanies this\r
+*  distribution. The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT\r
+*  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#include <Library/BaseLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiLib.h>\r
+\r
+#include <Guid/BootMonFsFileInfo.h>\r
+#include <Protocol/SimpleFileSystem.h> // EFI_FILE_HANDLE\r
+\r
+#include "ArmShellCmdRunAxf.h"\r
+#include "BootMonFsLoader.h"\r
+\r
+/**\r
+  Check that loading the file is supported.\r
+\r
+  Not all information is checked, only the properties that matters to us in\r
+  our simplified loader.\r
+\r
+  BootMonFS file properties is not in a file header but in the file-system\r
+  metadata, so we need to pass a handle to the file to allow access to the\r
+  information.\r
+\r
+  @param[in] FileHandle  Handle of the file to check.\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the header is invalid.\r
+  @retval EFI_UNSUPPORTED if the file type/platform is not supported.\r
+**/\r
+EFI_STATUS\r
+BootMonFsCheckFile (\r
+  IN  CONST EFI_FILE_HANDLE  FileHandle\r
+  )\r
+{\r
+  EFI_STATUS           Status;\r
+  BOOTMON_FS_FILE_INFO Info;\r
+  UINTN                InfoSize;\r
+  UINTN                Index;\r
+\r
+  ASSERT (FileHandle != NULL);\r
+\r
+  // Try to load the file information as BootMonFS executable.\r
+  InfoSize = sizeof (Info);\r
+  // Get BootMon File info and see if it gives us what we need to load the file.\r
+  Status = FileHandle->GetInfo (FileHandle, &gArmBootMonFsFileInfoGuid,\r
+                               &InfoSize, &Info);\r
+\r
+  if (!EFI_ERROR (Status)) {\r
+    // Check the values return to see if they look reasonable.\r
+    // Do we have a good entrypoint and at least one good load region?\r
+    // We assume here that we cannot load to address 0x0.\r
+    if ((Info.Size == 0) || (Info.EntryPoint == 0) || (Info.RegionCount == 0) ||\r
+        (Info.RegionCount > BOOTMONFS_IMAGE_DESCRIPTION_REGION_MAX)) {\r
+      // The file does not seem to be of the right type.\r
+      Status = EFI_UNSUPPORTED;\r
+    } else {\r
+      // Check load regions. We just check for valid numbers, we dont do the\r
+      // checksums. Info.Offset can be zero if it loads from the start of the\r
+      // file.\r
+      for (Index = 0; Index < Info.RegionCount; Index++) {\r
+        if ((Info.Region[Index].LoadAddress == 0) || (Info.Region[Index].Size == 0)) {\r
+          Status = EFI_UNSUPPORTED;\r
+          break;\r
+        }\r
+      }\r
+    }\r
+  }\r
+\r
+  return Status;\r
+}\r
+\r
+/**\r
+  Load a binary file from BootMonFS.\r
+\r
+  @param[in]  FileHandle    Handle of the file to load.\r
+\r
+  @param[in]  FileData      Address  of the file data in memory.\r
+\r
+  @param[out] EntryPoint    Will be filled with the ELF entry point address.\r
+\r
+  @param[out] ImageSize     Will be filled with the file size in memory. This\r
+                            will effectively be equal to the sum of the load\r
+                            region sizes.\r
+\r
+  This function assumes the file is valid and supported as checked with\r
+  BootMonFsCheckFile().\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the file is invalid.\r
+**/\r
+EFI_STATUS\r
+BootMonFsLoadFile (\r
+  IN  CONST EFI_FILE_HANDLE   FileHandle,\r
+  IN  CONST VOID             *FileData,\r
+  OUT VOID                  **EntryPoint,\r
+  OUT LIST_ENTRY             *LoadList\r
+  )\r
+{\r
+  EFI_STATUS            Status;\r
+  BOOTMON_FS_FILE_INFO  Info;\r
+  UINTN                 InfoSize;\r
+  UINTN                 Index;\r
+  UINTN                 ImageSize;\r
+  RUNAXF_LOAD_LIST     *LoadNode;\r
+\r
+  ASSERT (FileHandle != NULL);\r
+  ASSERT (FileData   != NULL);\r
+  ASSERT (EntryPoint != NULL);\r
+  ASSERT (LoadList   != NULL);\r
+\r
+  ImageSize = 0;\r
+\r
+  InfoSize = sizeof (Info);\r
+  Status = FileHandle->GetInfo (FileHandle, &gArmBootMonFsFileInfoGuid,\r
+                               &InfoSize, &Info);\r
+\r
+  if (!EFI_ERROR (Status)) {\r
+    *EntryPoint = (VOID*)((UINTN)Info.EntryPoint);\r
+    // Load all the regions to run-time memory\r
+    for (Index = 0; Index < Info.RegionCount; Index++) {\r
+      LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST));\r
+      if (LoadNode == NULL) {\r
+        Status = EFI_OUT_OF_RESOURCES;\r
+        break;\r
+      }\r
+\r
+      LoadNode->MemOffset  = (UINTN)Info.Region[Index].LoadAddress;\r
+      LoadNode->FileOffset = (UINTN)FileData + Info.Region[Index].Offset;\r
+      LoadNode->Length     = (UINTN)Info.Region[Index].Size;\r
+      InsertTailList (LoadList, &LoadNode->Link);\r
+\r
+      ImageSize += LoadNode->Length;\r
+    }\r
+  }\r
+\r
+  if ((!EFI_ERROR (Status)) && (ImageSize == 0)) {\r
+    Status = EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return Status;\r
+}\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/BootMonFsLoader.h b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/BootMonFsLoader.h
new file mode 100644 (file)
index 0000000..de3c0ad
--- /dev/null
@@ -0,0 +1,66 @@
+/** @file\r
+*\r
+*  Copyright (c) 2014, ARM Ltd. All rights reserved.\r
+*\r
+*  This program and the accompanying materials are licensed and made available\r
+*  under the terms and conditions of the BSD License which accompanies this\r
+*  distribution. The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, WITHOUT\r
+*  WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#ifndef __BOOTMONFS_LOADER_H__\r
+#define __BOOTMONFS_LOADER_H__\r
+\r
+/**\r
+  Check that loading the file is supported.\r
+\r
+  Not all information is checked, only the properties that matters to us in\r
+  our simplified loader.\r
+\r
+  BootMonFS file properties is not in a file header but in the file-system\r
+  metadata, so we need to pass a handle to the file to allow access to the\r
+  information.\r
+\r
+  @param[in] FileHandle  Handle of the file to check.\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the header is invalid.\r
+  @retval EFI_UNSUPPORTED if the file type/platform is not supported.\r
+**/\r
+EFI_STATUS\r
+BootMonFsCheckFile (\r
+  IN  CONST EFI_FILE_HANDLE  FileHandle\r
+  );\r
+\r
+/**\r
+  Load a binary file from BootMonFS.\r
+\r
+  @param[in]  FileHandle    Handle of the file to load.\r
+\r
+  @param[in]  FileData      Address  of the file data in memory.\r
+\r
+  @param[out] EntryPoint    Will be filled with the ELF entry point address.\r
+\r
+  @param[out] ImageSize     Will be filled with the file size in memory. This\r
+                            will effectively be equal to the sum of the load\r
+                            region sizes.\r
+\r
+  This function assumes the file is valid and supported as checked with\r
+  BootMonFsCheckFile().\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the file is invalid.\r
+**/\r
+EFI_STATUS\r
+BootMonFsLoadFile (\r
+  IN  CONST EFI_FILE_HANDLE   FileHandle,\r
+  IN  CONST VOID             *FileData,\r
+  OUT VOID                  **EntryPoint,\r
+  OUT LIST_ENTRY             *LoadList\r
+  );\r
+\r
+#endif // __BOOTMONFS_LOADER_H__\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ElfLoader.c b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ElfLoader.c
new file mode 100644 (file)
index 0000000..6bb0d22
--- /dev/null
@@ -0,0 +1,340 @@
+/** @file\r
+*\r
+*  Copyright (c) 2014, ARM Limited. All rights reserved.\r
+*\r
+*  This program and the accompanying materials\r
+*  are licensed and made available under the terms and conditions of the BSD License\r
+*  which accompanies this distribution.  The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#include <Library/BaseLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/DebugLib.h>\r
+#include <Library/UefiLib.h>\r
+\r
+#include "ArmShellCmdRunAxf.h"\r
+#include "ElfLoader.h"\r
+#include "elf_common.h"\r
+#include "elf32.h"\r
+#include "elf64.h"\r
+\r
+\r
+// Put the functions the #ifdef. We only use the appropriate one for the platform.\r
+// This prevents 'defined but not used' compiler warning.\r
+#ifdef MDE_CPU_ARM\r
+STATIC\r
+BOOLEAN\r
+IsArmElf (\r
+  IN  CONST VOID *Buf\r
+  )\r
+{\r
+  Elf32_Ehdr *Hdr = (Elf32_Ehdr*)Buf;\r
+\r
+  if (Hdr->e_ident[EI_CLASS] != ELFCLASS32) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS_32), gRunAxfHiiHandle);\r
+    return FALSE;\r
+  }\r
+\r
+  if (Hdr->e_machine != EM_ARM) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGMACH_32), gRunAxfHiiHandle);\r
+    return FALSE;\r
+  }\r
+\r
+  // We don't currently check endianness of ELF data (hdr->e_ident[EI_DATA])\r
+\r
+  return TRUE;\r
+}\r
+#elif defined(MDE_CPU_AARCH64)\r
+STATIC\r
+BOOLEAN\r
+IsAarch64Elf (\r
+  IN  CONST VOID *Buf\r
+  )\r
+{\r
+  Elf64_Ehdr *Hdr = (Elf64_Ehdr*)Buf;\r
+\r
+  if (Hdr->e_ident[EI_CLASS] != ELFCLASS64) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS_64), gRunAxfHiiHandle);\r
+    return FALSE;\r
+  }\r
+\r
+  if (Hdr->e_machine != EM_AARCH64) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGMACH_64), gRunAxfHiiHandle);\r
+    return FALSE;\r
+  }\r
+\r
+  // We don't currently check endianness of ELF data (hdr->e_ident[EI_DATA])\r
+\r
+  return TRUE;\r
+}\r
+#endif // MDE_CPU_ARM , MDE_CPU_AARCH64\r
+\r
+\r
+/**\r
+ Support checking 32 and 64bit as the header could be valid, we might just\r
+ not support loading it.\r
+**/\r
+STATIC\r
+EFI_STATUS\r
+ElfCheckHeader (\r
+  IN  CONST VOID *Buf\r
+  )\r
+{\r
+  Elf32_Ehdr *Hdr32 = (Elf32_Ehdr*)Buf;\r
+\r
+  if (!IS_ELF (*Hdr32)) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFMAGIC), gRunAxfHiiHandle);\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (Hdr32->e_type != ET_EXEC) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOTEXEC), gRunAxfHiiHandle);\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  if (Hdr32->e_ident[EI_CLASS] == ELFCLASS32) {\r
+    if ((Hdr32->e_phoff == 0) || (Hdr32->e_phentsize == 0) || (Hdr32->e_phnum == 0)) {\r
+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOPROG), gRunAxfHiiHandle);\r
+      return EFI_INVALID_PARAMETER;\r
+    }\r
+\r
+    if (Hdr32->e_flags != 0) {\r
+      DEBUG ((EFI_D_INFO, "Warning: Wrong processor-specific flags, expected 0.\n"));\r
+    }\r
+\r
+    DEBUG ((EFI_D_INFO, "Entry point addr: 0x%lx\n", Hdr32->e_entry));\r
+    DEBUG ((EFI_D_INFO, "Start of program headers: 0x%lx\n", Hdr32->e_phoff));\r
+    DEBUG ((EFI_D_INFO, "Size of 1 program header: %d\n", Hdr32->e_phentsize));\r
+    DEBUG ((EFI_D_INFO, "Number of program headers: %d\n", Hdr32->e_phnum));\r
+  } else if (Hdr32->e_ident[EI_CLASS] == ELFCLASS64) {\r
+      Elf64_Ehdr *Hdr64 = (Elf64_Ehdr*)Buf;\r
+\r
+    if ((Hdr64->e_phoff == 0) || (Hdr64->e_phentsize == 0) || (Hdr64->e_phnum == 0)) {\r
+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOPROG), gRunAxfHiiHandle);\r
+      return EFI_INVALID_PARAMETER;\r
+    }\r
+\r
+    if (Hdr64->e_flags != 0) {\r
+      DEBUG ((EFI_D_INFO, "Warning: Wrong processor-specific flags, expected 0.\n"));\r
+    }\r
+\r
+    DEBUG ((EFI_D_INFO, "Entry point addr: 0x%lx\n", Hdr64->e_entry));\r
+    DEBUG ((EFI_D_INFO, "Start of program headers: 0x%lx\n", Hdr64->e_phoff));\r
+    DEBUG ((EFI_D_INFO, "Size of 1 program header: %d\n", Hdr64->e_phentsize));\r
+    DEBUG ((EFI_D_INFO, "Number of program headers: %d\n", Hdr64->e_phnum));\r
+  } else {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS), gRunAxfHiiHandle);\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+ Load an ELF segment into memory.\r
+\r
+ This function assumes the ELF file is valid.\r
+ This function is meant to be called for PT_LOAD type segments only.\r
+**/\r
+STATIC\r
+EFI_STATUS\r
+ElfLoadSegment (\r
+  IN  CONST VOID  *ElfImage,\r
+  IN  CONST VOID  *PHdr,\r
+  IN  LIST_ENTRY  *LoadList\r
+  )\r
+{\r
+  VOID             *FileSegment;\r
+  VOID             *MemSegment;\r
+  UINTN             ExtraZeroes;\r
+  UINTN             ExtraZeroesCount;\r
+  RUNAXF_LOAD_LIST *LoadNode;\r
+\r
+#ifdef MDE_CPU_ARM\r
+  Elf32_Phdr  *ProgramHdr;\r
+  ProgramHdr = (Elf32_Phdr *)PHdr;\r
+#elif defined(MDE_CPU_AARCH64)\r
+  Elf64_Phdr  *ProgramHdr;\r
+  ProgramHdr = (Elf64_Phdr *)PHdr;\r
+#endif\r
+\r
+  ASSERT (ElfImage != NULL);\r
+  ASSERT (ProgramHdr != NULL);\r
+\r
+  FileSegment = (VOID *)((UINTN)ElfImage + ProgramHdr->p_offset);\r
+  MemSegment = (VOID *)ProgramHdr->p_vaddr;\r
+\r
+  // If the segment's memory size p_memsz is larger than the file size p_filesz,\r
+  // the "extra" bytes are defined to hold the value 0 and to follow the\r
+  // segment's initialised area.\r
+  // This is typically the case for the .bss segment.\r
+  // The file size may not be larger than the memory size.\r
+  if (ProgramHdr->p_filesz > ProgramHdr->p_memsz) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFBADFORMAT), gRunAxfHiiHandle);\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  // Load the segment in memory.\r
+  if (ProgramHdr->p_filesz != 0) {\r
+    DEBUG ((EFI_D_INFO, "Loading segment from 0x%lx to 0x%lx (size = %ld)\n",\r
+                 FileSegment, MemSegment, ProgramHdr->p_filesz));\r
+\r
+    LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST));\r
+    if (LoadNode == NULL) {\r
+      return EFI_OUT_OF_RESOURCES;\r
+    }\r
+    LoadNode->MemOffset  = (UINTN)MemSegment;\r
+    LoadNode->FileOffset = (UINTN)FileSegment;\r
+    LoadNode->Length     = (UINTN)ProgramHdr->p_filesz;\r
+    InsertTailList (LoadList, &LoadNode->Link);\r
+  }\r
+\r
+  ExtraZeroes = ((UINTN)MemSegment + ProgramHdr->p_filesz);\r
+  ExtraZeroesCount = ProgramHdr->p_memsz - ProgramHdr->p_filesz;\r
+  DEBUG ((EFI_D_INFO, "Completing segment with %d zero bytes.\n", ExtraZeroesCount));\r
+  if (ExtraZeroesCount > 0) {\r
+    // Extra Node to add the Zeroes.\r
+    LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST));\r
+    if (LoadNode == NULL) {\r
+      return EFI_OUT_OF_RESOURCES;\r
+    }\r
+    LoadNode->MemOffset  = (UINTN)ExtraZeroes;\r
+    LoadNode->Zeroes     = TRUE;\r
+    LoadNode->Length     = ExtraZeroesCount;\r
+    InsertTailList (LoadList, &LoadNode->Link);\r
+  }\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+\r
+/**\r
+ Check that the ELF File Header is valid and Machine type supported.\r
+\r
+ Not all information is checked in the ELF header, only the stuff that\r
+ matters to us in our simplified ELF loader.\r
+\r
+ @param[in] ElfImage  Address of the ELF file to check.\r
+\r
+ @retval EFI_SUCCESS on success.\r
+ @retval EFI_INVALID_PARAMETER if the header is invalid.\r
+ @retval EFI_UNSUPPORTED if the file type/platform is not supported.\r
+**/\r
+EFI_STATUS\r
+ElfCheckFile (\r
+  IN  CONST VOID *ElfImage\r
+  )\r
+{\r
+  EFI_STATUS Status;\r
+\r
+  ASSERT (ElfImage != NULL);\r
+\r
+  // Check that the ELF header is valid.\r
+  Status = ElfCheckHeader (ElfImage);\r
+  if (EFI_ERROR(Status)) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFBADHEADER), gRunAxfHiiHandle);\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+#ifdef MDE_CPU_ARM\r
+  if (IsArmElf (ElfImage)) {\r
+    return EFI_SUCCESS;\r
+  }\r
+#elif defined(MDE_CPU_AARCH64)\r
+  if (IsAarch64Elf (ElfImage)) {\r
+    return EFI_SUCCESS;\r
+  }\r
+#endif\r
+\r
+  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_BAD_ARCH), gRunAxfHiiHandle);\r
+  return EFI_UNSUPPORTED;\r
+}\r
+\r
+\r
+/**\r
+  Load a ELF file.\r
+\r
+  @param[in] ElfImage       Address of the ELF file in memory.\r
+\r
+  @param[out] EntryPoint    Will be filled with the ELF entry point address.\r
+\r
+  @param[out] ImageSize     Will be filled with the ELF size in memory. This will\r
+                            effectively be equal to the sum of the segments sizes.\r
+\r
+  This functon assumes the header is valid and supported as checked with\r
+  ElfCheckFile().\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the ELF file is invalid.\r
+**/\r
+EFI_STATUS\r
+ElfLoadFile (\r
+  IN  CONST VOID   *ElfImage,\r
+  OUT VOID        **EntryPoint,\r
+  OUT LIST_ENTRY   *LoadList\r
+  )\r
+{\r
+  EFI_STATUS    Status;\r
+  UINT8        *ProgramHdr;\r
+  UINTN         Index;\r
+  UINTN         ImageSize;\r
+\r
+#ifdef MDE_CPU_ARM\r
+  Elf32_Ehdr   *ElfHdr;\r
+  Elf32_Phdr   *ProgramHdrPtr;\r
+\r
+  ElfHdr = (Elf32_Ehdr*)ElfImage;\r
+#elif defined(MDE_CPU_AARCH64)\r
+  Elf64_Ehdr   *ElfHdr;\r
+  Elf64_Phdr   *ProgramHdrPtr;\r
+\r
+  ElfHdr = (Elf64_Ehdr*)ElfImage;\r
+#endif\r
+\r
+  ASSERT (ElfImage   != NULL);\r
+  ASSERT (EntryPoint != NULL);\r
+  ASSERT (LoadList   != NULL);\r
+\r
+  ProgramHdr = (UINT8*)ElfImage + ElfHdr->e_phoff;\r
+  DEBUG ((EFI_D_INFO, "ELF program header entry : 0x%lx\n", ProgramHdr));\r
+\r
+  ImageSize = 0;\r
+\r
+  // Load every loadable ELF segment into memory.\r
+  for (Index = 0; Index < ElfHdr->e_phnum; ++Index) {\r
+\r
+#ifdef MDE_CPU_ARM\r
+    ProgramHdrPtr = (Elf32_Phdr*)ProgramHdr;\r
+#elif defined(MDE_CPU_AARCH64)\r
+    ProgramHdrPtr = (Elf64_Phdr*)ProgramHdr;\r
+#endif\r
+\r
+    // Only consider PT_LOAD type segments, ignore others.\r
+    if (ProgramHdrPtr->p_type == PT_LOAD) {\r
+      Status = ElfLoadSegment (ElfImage, (VOID *)ProgramHdrPtr, LoadList);\r
+      if (EFI_ERROR (Status)) {\r
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFFAILSEG), gRunAxfHiiHandle);\r
+        return EFI_INVALID_PARAMETER;\r
+      }\r
+      ImageSize += ProgramHdrPtr->p_memsz;\r
+    }\r
+    ProgramHdr += ElfHdr->e_phentsize;\r
+  }\r
+\r
+  if (ImageSize == 0) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOSEG), gRunAxfHiiHandle);\r
+    return EFI_INVALID_PARAMETER;\r
+  }\r
+\r
+  // Return the entry point specified in the ELF header.\r
+  *EntryPoint = (void*)ElfHdr->e_entry;\r
+\r
+  return EFI_SUCCESS;\r
+}\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ElfLoader.h b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/ElfLoader.h
new file mode 100644 (file)
index 0000000..7020a6c
--- /dev/null
@@ -0,0 +1,64 @@
+/** @file\r
+*\r
+*  Copyright (c) 2014, ARM Limited. All rights reserved.\r
+*\r
+*  This program and the accompanying materials\r
+*  are licensed and made available under the terms and conditions of the BSD License\r
+*  which accompanies this distribution.  The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#ifndef ELF_LOADER_H\r
+#define ELF_LOADER_H\r
+\r
+/**\r
+  Check that the ELF File Header is valid and Machine type supported.\r
+\r
+  Not all information is checked in the ELF header, only the stuff that\r
+  matters to us in our simplified ELF loader.\r
+\r
+  @param[in] ElfImage  Address of the ELF file to check.\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the header is invalid.\r
+  @retval EFI_UNSUPPORTED if the file type/platform is not supported.\r
+**/\r
+EFI_STATUS\r
+ElfCheckFile (\r
+  IN  CONST VOID *ElfImage\r
+  );\r
+\r
+\r
+/**\r
+  Load a ELF file.\r
+\r
+  @param[in]  ElfImage      Address of the ELF file in memory.\r
+\r
+  @param[out] EntryPoint    Will be filled with the ELF entry point address.\r
+\r
+  @param[out] ImageSize     Will be filled with the ELF size in memory. This will\r
+                            effectively be equal to the sum of the segments sizes.\r
+\r
+  This function assumes the header is valid and supported as checked with\r
+  ElfCheckFile().\r
+\r
+  NOTE:\r
+   - We don't currently take the segment permissions into account (indicated by\r
+     the program headers). It can be used to allocate pages with the right\r
+     read/write/exec permissions.\r
+\r
+  @retval EFI_SUCCESS on success.\r
+  @retval EFI_INVALID_PARAMETER if the ELF file is invalid.\r
+**/\r
+EFI_STATUS\r
+ElfLoadFile (\r
+  IN  CONST VOID   *ElfImage,\r
+  OUT VOID        **EntryPoint,\r
+  OUT LIST_ENTRY   *LoadList\r
+  );\r
+\r
+#endif // ELF_LOADER_H\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/RunAxf.c b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/RunAxf.c
new file mode 100644 (file)
index 0000000..e8576af
--- /dev/null
@@ -0,0 +1,395 @@
+/** @file\r
+*\r
+*  Shell command for launching AXF files.\r
+*\r
+*  Copyright (c) 2014, ARM Limited. All rights reserved.\r
+*\r
+*  This program and the accompanying materials\r
+*  are licensed and made available under the terms and conditions of the BSD License\r
+*  which accompanies this distribution.  The full text of the license may be found at\r
+*  http://opensource.org/licenses/bsd-license.php\r
+*\r
+*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+*\r
+**/\r
+\r
+#include <Guid/GlobalVariable.h>\r
+#include <Library/PrintLib.h>\r
+#include <Library/HandleParsingLib.h>\r
+#include <Library/DevicePathLib.h>\r
+#include <Library/BaseLib.h>\r
+#include <Library/BaseMemoryLib.h>\r
+#include <Library/MemoryAllocationLib.h>\r
+#include <Library/DebugLib.h>\r
+\r
+#include <Library/ArmLib.h>\r
+\r
+#include "ArmShellCmdRunAxf.h"\r
+#include "ElfLoader.h"\r
+#include "BootMonFsLoader.h"\r
+\r
+// Provide arguments to AXF?\r
+typedef VOID (*ELF_ENTRYPOINT)(UINTN arg0, UINTN arg1,\r
+                               UINTN arg2, UINTN arg3);\r
+\r
+\r
+STATIC\r
+EFI_STATUS\r
+ShutdownUefiBootServices (\r
+  VOID\r
+  )\r
+{\r
+  EFI_STATUS              Status;\r
+  UINTN                   MemoryMapSize;\r
+  EFI_MEMORY_DESCRIPTOR   *MemoryMap;\r
+  UINTN                   MapKey;\r
+  UINTN                   DescriptorSize;\r
+  UINT32                  DescriptorVersion;\r
+  UINTN                   Pages;\r
+\r
+  MemoryMap = NULL;\r
+  MemoryMapSize = 0;\r
+  Pages = 0;\r
+\r
+  do {\r
+    Status = gBS->GetMemoryMap (\r
+                    &MemoryMapSize,\r
+                    MemoryMap,\r
+                    &MapKey,\r
+                    &DescriptorSize,\r
+                    &DescriptorVersion\r
+                    );\r
+    if (Status == EFI_BUFFER_TOO_SMALL) {\r
+\r
+      Pages = EFI_SIZE_TO_PAGES (MemoryMapSize) + 1;\r
+      MemoryMap = AllocatePages (Pages);\r
+\r
+      //\r
+      // Get System MemoryMap\r
+      //\r
+      Status = gBS->GetMemoryMap (\r
+                      &MemoryMapSize,\r
+                      MemoryMap,\r
+                      &MapKey,\r
+                      &DescriptorSize,\r
+                      &DescriptorVersion\r
+                      );\r
+    }\r
+\r
+    // Don't do anything between the GetMemoryMap() and ExitBootServices()\r
+    if (!EFI_ERROR (Status)) {\r
+      Status = gBS->ExitBootServices (gImageHandle, MapKey);\r
+      if (EFI_ERROR (Status)) {\r
+        FreePages (MemoryMap, Pages);\r
+        MemoryMap = NULL;\r
+        MemoryMapSize = 0;\r
+      }\r
+    }\r
+  } while (EFI_ERROR (Status));\r
+\r
+  return Status;\r
+}\r
+\r
+\r
+STATIC\r
+EFI_STATUS\r
+PreparePlatformHardware (\r
+  VOID\r
+  )\r
+{\r
+  //Note: Interrupts will be disabled by the GIC driver when ExitBootServices() will be called.\r
+\r
+  // Clean before Disable else the Stack gets corrupted with old data.\r
+  ArmCleanDataCache ();\r
+  ArmDisableDataCache ();\r
+  // Invalidate all the entries that might have snuck in.\r
+  ArmInvalidateDataCache ();\r
+\r
+  // Disable and invalidate the instruction cache\r
+  ArmDisableInstructionCache ();\r
+  ArmInvalidateInstructionCache ();\r
+\r
+  // Turn off MMU\r
+  ArmDisableMmu();\r
+\r
+  return EFI_SUCCESS;\r
+}\r
+\r
+// Process arguments to pass to AXF?\r
+STATIC CONST SHELL_PARAM_ITEM ParamList[] = {\r
+  {NULL, TypeMax}\r
+};\r
+\r
+\r
+/**\r
+  This is the shell command handler function pointer callback type. This\r
+  function handles the command when it is invoked in the shell.\r
+\r
+  @param[in] This             The instance of the\r
+                              EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.\r
+  @param[in] SystemTable      The pointer to the system table.\r
+  @param[in] ShellParameters  The parameters associated with the command.\r
+  @param[in] Shell            The instance of the shell protocol used in the\r
+                              context of processing this command.\r
+\r
+  @return EFI_SUCCESS         The operation was successful.\r
+  @return other               The operation failed.\r
+**/\r
+SHELL_STATUS\r
+EFIAPI\r
+ShellDynCmdRunAxfHandler (\r
+  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,\r
+  IN EFI_SYSTEM_TABLE                      *SystemTable,\r
+  IN EFI_SHELL_PARAMETERS_PROTOCOL         *ShellParameters,\r
+  IN EFI_SHELL_PROTOCOL                    *Shell\r
+  )\r
+{\r
+  LIST_ENTRY        *ParamPackage;\r
+  EFI_STATUS         Status;\r
+  SHELL_STATUS       ShellStatus;\r
+  SHELL_FILE_HANDLE  FileHandle;\r
+  ELF_ENTRYPOINT     StartElf;\r
+  CONST CHAR16      *FileName;\r
+  EFI_FILE_INFO     *Info;\r
+  UINTN              FileSize;\r
+  VOID              *FileData;\r
+  VOID              *Entrypoint;\r
+  LIST_ENTRY         LoadList;\r
+  LIST_ENTRY        *Node;\r
+  LIST_ENTRY        *NextNode;\r
+  RUNAXF_LOAD_LIST  *LoadNode;\r
+  CHAR16            *TmpFileName;\r
+  CHAR16            *TmpChar16;\r
+\r
+\r
+  ShellStatus = SHELL_SUCCESS;\r
+  FileHandle = NULL;\r
+  FileData = NULL;\r
+  InitializeListHead (&LoadList);\r
+\r
+  // Only install if they are not there yet? First time or every time?\r
+  // These can change if the shell exits and start again.\r
+  Status = gBS->InstallMultipleProtocolInterfaces (&gImageHandle,\r
+                &gEfiShellProtocolGuid, Shell,\r
+                &gEfiShellParametersProtocolGuid, ShellParameters,\r
+                NULL);\r
+\r
+  if (EFI_ERROR (Status)) {\r
+    return SHELL_DEVICE_ERROR;\r
+  }\r
+\r
+  // Update the protocols for the application library\r
+  Status = ShellInitialize ();\r
+  ASSERT_EFI_ERROR (Status);\r
+  // Add support to load AXF with optipnal args?\r
+\r
+  //\r
+  // Process Command Line arguments\r
+  //\r
+  Status = ShellCommandLineParse (ParamList, &ParamPackage, NULL, TRUE);\r
+  if (EFI_ERROR (Status)) {\r
+    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_INVALID_ARG), gRunAxfHiiHandle);\r
+    ShellStatus = SHELL_INVALID_PARAMETER;\r
+  } else {\r
+    //\r
+    // Check for "-?"\r
+    //\r
+    if ((ShellCommandLineGetFlag (ParamPackage, L"-?")) ||\r
+        (ShellCommandLineGetRawValue (ParamPackage, 1) == NULL)) {\r
+      //\r
+      // We didn't get a file to load\r
+      //\r
+      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_INVALID_ARG), gRunAxfHiiHandle);\r
+      ShellStatus = SHELL_INVALID_PARAMETER;\r
+    } else {\r
+      // For the moment we assume we only ever get one file to load with no arguments.\r
+      FileName = ShellCommandLineGetRawValue (ParamPackage, 1);\r
+      Status = ShellOpenFileByName (FileName, &FileHandle, EFI_FILE_MODE_READ, 0);\r
+      if (EFI_ERROR (Status)) {\r
+        // BootMonFS supports file extensions, but they are stripped by default\r
+        // when the NOR is programmed.\r
+        // Remove the file extension and try to open again.\r
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_FILE_NOT_FOUND),\r
+                         gRunAxfHiiHandle, FileName);\r
+        // Go through the filename and remove file extension. Preserve the\r
+        // original name.\r
+        TmpFileName = AllocateCopyPool (StrSize (FileName), (VOID *)FileName);\r
+        if (TmpFileName != NULL) {\r
+          TmpChar16 = StrStr (TmpFileName, L".");\r
+          if (TmpChar16 != NULL) {\r
+            *TmpChar16 = '\0';\r
+            DEBUG((EFI_D_ERROR, "Trying to open file: %s\n", TmpFileName));\r
+            Status = ShellOpenFileByName (TmpFileName, &FileHandle,\r
+                                          EFI_FILE_MODE_READ, 0);\r
+          }\r
+          FreePool (TmpFileName);\r
+        }\r
+        // Do we now have an open file after trying again?\r
+        if (EFI_ERROR (Status)) {\r
+          ShellStatus = SHELL_INVALID_PARAMETER;\r
+          FileHandle = NULL;\r
+        }\r
+      }\r
+\r
+      if (FileHandle != NULL) {\r
+        Info = ShellGetFileInfo (FileHandle);\r
+        FileSize = (UINTN) Info->FileSize;\r
+        FreePool (Info);\r
+\r
+        //\r
+        // Allocate buffer to read file. 'Runtime' so we can access it after\r
+        // ExitBootServices().\r
+        //\r
+        FileData = AllocateRuntimeZeroPool (FileSize);\r
+        if (FileData == NULL) {\r
+          ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_NO_MEM), gRunAxfHiiHandle);\r
+          ShellStatus = SHELL_OUT_OF_RESOURCES;\r
+        } else {\r
+          //\r
+          // Read file into Buffer\r
+          //\r
+          Status = ShellReadFile (FileHandle, &FileSize, FileData);\r
+          if (EFI_ERROR (Status)) {\r
+            ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_READ_FAIL), gRunAxfHiiHandle);\r
+            SHELL_FREE_NON_NULL (FileData);\r
+            FileData = NULL;\r
+            ShellStatus = SHELL_DEVICE_ERROR;\r
+          }\r
+        }\r
+      }\r
+    }\r
+\r
+    //\r
+    // Free the command line package\r
+    //\r
+    ShellCommandLineFreeVarList (ParamPackage);\r
+  }\r
+\r
+  // We have a file in memory. Try to work out if we can use it.\r
+  // It can either be in ELF format or BootMonFS format.\r
+  if (FileData != NULL) {\r
+    // Do some validation on the file before we try to load it. The file can\r
+    // either be an proper ELF file or one processed by the FlashLoader.\r
+    // Since the data might need to go to various locations in memory we cannot\r
+    // load the data directly while UEFI is running. We use the file loaders to\r
+    // populate a linked list of data and load addresses. This is processed and\r
+    // data copied to where it needs to go after calling ExitBootServices. At\r
+    // that stage we've reached the point of no return, so overwriting UEFI code\r
+    // does not make a difference.\r
+    Status = ElfCheckFile (FileData);\r
+    if (!EFI_ERROR (Status)) {\r
+      // Load program into memory\r
+      Status = ElfLoadFile ((VOID*)FileData, &Entrypoint, &LoadList);\r
+    } else {\r
+      // Try to see if it is a BootMonFs executable\r
+      Status = BootMonFsCheckFile ((EFI_FILE_HANDLE)FileHandle);\r
+      if (!EFI_ERROR (Status)) {\r
+        // Load program into memory\r
+        Status = BootMonFsLoadFile ((EFI_FILE_HANDLE)FileHandle,\r
+                                    (VOID*)FileData, &Entrypoint, &LoadList);\r
+      } else {\r
+        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_BAD_FILE),\r
+                         gRunAxfHiiHandle);\r
+        SHELL_FREE_NON_NULL (FileData);\r
+        ShellStatus = SHELL_UNSUPPORTED;\r
+      }\r
+    }\r
+  }\r
+\r
+  // Program load list created.\r
+  // Shutdown UEFI, copy and jump to code.\r
+  if (!IsListEmpty (&LoadList) && !EFI_ERROR (Status)) {\r
+    // Exit boot services here. This means we cannot return and cannot assume to\r
+    // have access to UEFI functions.\r
+    Status = ShutdownUefiBootServices ();\r
+    if (EFI_ERROR (Status)) {\r
+      DEBUG ((EFI_D_ERROR,"Can not shutdown UEFI boot services. Status=0x%X\n",\r
+              Status));\r
+    } else {\r
+      // Process linked list. Copy data to Memory.\r
+      Node = GetFirstNode (&LoadList);\r
+      while (!IsNull (&LoadList, Node)) {\r
+        LoadNode = (RUNAXF_LOAD_LIST *)Node;\r
+        // Do we have data to copy or do we need to set Zeroes (.bss)?\r
+        if (LoadNode->Zeroes) {\r
+          ZeroMem ((VOID*)LoadNode->MemOffset, LoadNode->Length);\r
+        } else {\r
+          CopyMem ((VOID *)LoadNode->MemOffset, (VOID *)LoadNode->FileOffset,\r
+                   LoadNode->Length);\r
+        }\r
+        Node = GetNextNode (&LoadList, Node);\r
+      }\r
+\r
+      //\r
+      // Switch off interrupts, caches, mmu, etc\r
+      //\r
+      Status = PreparePlatformHardware ();\r
+      ASSERT_EFI_ERROR (Status);\r
+\r
+      StartElf = (ELF_ENTRYPOINT)Entrypoint;\r
+      StartElf (0,0,0,0);\r
+\r
+      // We should never get here.. But if we do, spin..\r
+      ASSERT (FALSE);\r
+      while (1);\r
+    }\r
+  }\r
+\r
+  // Free file related information as we are returning to UEFI.\r
+  Node = GetFirstNode (&LoadList);\r
+  while (!IsNull (&LoadList, Node)) {\r
+    NextNode = RemoveEntryList (Node);\r
+    FreePool (Node);\r
+    Node = NextNode;\r
+  }\r
+  SHELL_FREE_NON_NULL (FileData);\r
+  if (FileHandle != NULL) {\r
+    ShellCloseFile (&FileHandle);\r
+  }\r
+\r
+  // Uninstall protocols as we don't know if they will change.\r
+  // If the shell exits and come in again these mappings may be different\r
+  // and cause a crash.\r
+  Status = gBS->UninstallMultipleProtocolInterfaces (gImageHandle,\r
+                &gEfiShellProtocolGuid, Shell,\r
+                &gEfiShellParametersProtocolGuid, ShellParameters,\r
+                NULL);\r
+\r
+  if (EFI_ERROR (Status) && ShellStatus == SHELL_SUCCESS) {\r
+    ShellStatus = SHELL_DEVICE_ERROR;\r
+  }\r
+\r
+  return ShellStatus;\r
+}\r
+\r
+\r
+/**\r
+  This is the command help handler function pointer callback type. This\r
+  function is responsible for displaying help information for the associated\r
+  command.\r
+\r
+  @param[in] This             The instance of the\r
+                              EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL.\r
+  @param[in] Language         The pointer to the language string to use.\r
+\r
+  @return string              Pool allocated help string, must be freed by\r
+                              caller.\r
+**/\r
+CHAR16*\r
+EFIAPI\r
+ShellDynCmdRunAxfGetHelp (\r
+  IN EFI_SHELL_DYNAMIC_COMMAND_PROTOCOL    *This,\r
+  IN CONST CHAR8                           *Language\r
+  )\r
+{\r
+  CHAR16 *HelpText;\r
+\r
+  ASSERT (gRunAxfHiiHandle != NULL);\r
+\r
+  // This allocates memory. The caller is responsoible to free.\r
+  HelpText = HiiGetString (gRunAxfHiiHandle, STRING_TOKEN (STR_GET_HELP_RUNAXF),\r
+                           Language);\r
+\r
+  return HelpText;\r
+}\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf32.h b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf32.h
new file mode 100644 (file)
index 0000000..3951444
--- /dev/null
@@ -0,0 +1,258 @@
+/** @file\r
+Ported ELF include files from FreeBSD\r
+\r
+Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>\r
+This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+\r
+**/\r
+/*-\r
+ * Copyright (c) 1996-1998 John D. Polstra.\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ * $FreeBSD: src/sys/sys/elf32.h,v 1.8.14.2 2007/12/03 21:30:36 marius Exp $\r
+ */\r
+\r
+#ifndef _SYS_ELF32_H_\r
+#define _SYS_ELF32_H_ 1\r
+\r
+\r
+/*\r
+ * ELF definitions common to all 32-bit architectures.\r
+ */\r
+\r
+typedef UINT32  Elf32_Addr;\r
+typedef UINT16  Elf32_Half;\r
+typedef UINT32  Elf32_Off;\r
+typedef INT32   Elf32_Sword;\r
+typedef UINT32  Elf32_Word;\r
+typedef UINT64  Elf32_Lword;\r
+\r
+typedef Elf32_Word      Elf32_Hashelt;\r
+\r
+/* Non-standard class-dependent datatype used for abstraction. */\r
+typedef Elf32_Word      Elf32_Size;\r
+typedef Elf32_Sword     Elf32_Ssize;\r
+\r
+/*\r
+ * ELF header.\r
+ */\r
+\r
+typedef struct {\r
+  unsigned char   e_ident[EI_NIDENT]; /* File identification. */\r
+  Elf32_Half      e_type;             /* File type. */\r
+  Elf32_Half      e_machine;          /* Machine architecture. */\r
+  Elf32_Word      e_version;          /* ELF format version. */\r
+  Elf32_Addr      e_entry;            /* Entry point. */\r
+  Elf32_Off       e_phoff;            /* Program header file offset. */\r
+  Elf32_Off       e_shoff;            /* Section header file offset. */\r
+  Elf32_Word      e_flags;            /* Architecture-specific flags. */\r
+  Elf32_Half      e_ehsize;           /* Size of ELF header in bytes. */\r
+  Elf32_Half      e_phentsize;        /* Size of program header entry. */\r
+  Elf32_Half      e_phnum;            /* Number of program header entries. */\r
+  Elf32_Half      e_shentsize;        /* Size of section header entry. */\r
+  Elf32_Half      e_shnum;            /* Number of section header entries. */\r
+  Elf32_Half      e_shstrndx;         /* Section name strings section. */\r
+} Elf32_Ehdr;\r
+\r
+/*\r
+ * Section header.\r
+ */\r
+\r
+typedef struct {\r
+  Elf32_Word      sh_name;        /* Section name (index into the\r
+                                     section header string table). */\r
+  Elf32_Word      sh_type;        /* Section type. */\r
+  Elf32_Word      sh_flags;       /* Section flags. */\r
+  Elf32_Addr      sh_addr;        /* Address in memory image. */\r
+  Elf32_Off       sh_offset;      /* Offset in file. */\r
+  Elf32_Word      sh_size;        /* Size in bytes. */\r
+  Elf32_Word      sh_link;        /* Index of a related section. */\r
+  Elf32_Word      sh_info;        /* Depends on section type. */\r
+  Elf32_Word      sh_addralign;   /* Alignment in bytes. */\r
+  Elf32_Word      sh_entsize;     /* Size of each entry in section. */\r
+} Elf32_Shdr;\r
+\r
+/*\r
+ * Program header.\r
+ */\r
+\r
+typedef struct {\r
+  Elf32_Word      p_type;         /* Entry type. */\r
+  Elf32_Off       p_offset;       /* File offset of contents. */\r
+  Elf32_Addr      p_vaddr;        /* Virtual address in memory image. */\r
+  Elf32_Addr      p_paddr;        /* Physical address (not used). */\r
+  Elf32_Word      p_filesz;       /* Size of contents in file. */\r
+  Elf32_Word      p_memsz;        /* Size of contents in memory. */\r
+  Elf32_Word      p_flags;        /* Access permission flags. */\r
+  Elf32_Word      p_align;        /* Alignment in memory and file. */\r
+} Elf32_Phdr;\r
+\r
+/*\r
+ * Dynamic structure.  The ".dynamic" section contains an array of them.\r
+ */\r
+\r
+typedef struct {\r
+  Elf32_Sword     d_tag;          /* Entry type. */\r
+  union {\r
+    Elf32_Word      d_val;  /* Integer value. */\r
+    Elf32_Addr      d_ptr;  /* Address value. */\r
+  } d_un;\r
+} Elf32_Dyn;\r
+\r
+/*\r
+ * Relocation entries.\r
+ */\r
+\r
+/* Relocations that don't need an addend field. */\r
+typedef struct {\r
+  Elf32_Addr      r_offset;       /* Location to be relocated. */\r
+  Elf32_Word      r_info;         /* Relocation type and symbol index. */\r
+} Elf32_Rel;\r
+\r
+/* Relocations that need an addend field. */\r
+typedef struct {\r
+  Elf32_Addr      r_offset;       /* Location to be relocated. */\r
+  Elf32_Word      r_info;         /* Relocation type and symbol index. */\r
+  Elf32_Sword     r_addend;       /* Addend. */\r
+} Elf32_Rela;\r
+\r
+/* Macros for accessing the fields of r_info. */\r
+#define ELF32_R_SYM(info)       ((info) >> 8)\r
+#define ELF32_R_TYPE(info)      ((unsigned char)(info))\r
+\r
+/* Macro for constructing r_info from field values. */\r
+#define ELF32_R_INFO(sym, type) (((sym) << 8) + (unsigned char)(type))\r
+\r
+/*\r
+ *      Note entry header\r
+ */\r
+typedef Elf_Note Elf32_Nhdr;\r
+\r
+/*\r
+ *      Move entry\r
+ */\r
+typedef struct {\r
+  Elf32_Lword     m_value;        /* symbol value */\r
+  Elf32_Word      m_info;         /* size + index */\r
+  Elf32_Word      m_poffset;      /* symbol offset */\r
+  Elf32_Half      m_repeat;       /* repeat count */\r
+  Elf32_Half      m_stride;       /* stride info */\r
+} Elf32_Move;\r
+\r
+/*\r
+ *      The macros compose and decompose values for Move.r_info\r
+ *\r
+ *      sym = ELF32_M_SYM(M.m_info)\r
+ *      size = ELF32_M_SIZE(M.m_info)\r
+ *      M.m_info = ELF32_M_INFO(sym, size)\r
+ */\r
+#define ELF32_M_SYM(info)       ((info)>>8)\r
+#define ELF32_M_SIZE(info)      ((unsigned char)(info))\r
+#define ELF32_M_INFO(sym, size) (((sym)<<8)+(unsigned char)(size))\r
+\r
+/*\r
+ *      Hardware/Software capabilities entry\r
+ */\r
+typedef struct {\r
+  Elf32_Word      c_tag;          /* how to interpret value */\r
+  union {\r
+    Elf32_Word      c_val;\r
+    Elf32_Addr      c_ptr;\r
+  } c_un;\r
+} Elf32_Cap;\r
+\r
+/*\r
+ * Symbol table entries.\r
+ */\r
+\r
+typedef struct {\r
+  Elf32_Word      st_name;        /* String table index of name. */\r
+  Elf32_Addr      st_value;       /* Symbol value. */\r
+  Elf32_Word      st_size;        /* Size of associated object. */\r
+  unsigned char   st_info;        /* Type and binding information. */\r
+  unsigned char   st_other;       /* Reserved (not used). */\r
+  Elf32_Half      st_shndx;       /* Section index of symbol. */\r
+} Elf32_Sym;\r
+\r
+/* Macros for accessing the fields of st_info. */\r
+#define ELF32_ST_BIND(info)             ((info) >> 4)\r
+#define ELF32_ST_TYPE(info)             ((info) & 0xf)\r
+\r
+/* Macro for constructing st_info from field values. */\r
+#define ELF32_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))\r
+\r
+/* Macro for accessing the fields of st_other. */\r
+#define ELF32_ST_VISIBILITY(oth)        ((oth) & 0x3)\r
+\r
+/* Structures used by Sun & GNU symbol versioning. */\r
+typedef struct\r
+{\r
+  Elf32_Half      vd_version;\r
+  Elf32_Half      vd_flags;\r
+  Elf32_Half      vd_ndx;\r
+  Elf32_Half      vd_cnt;\r
+  Elf32_Word      vd_hash;\r
+  Elf32_Word      vd_aux;\r
+  Elf32_Word      vd_next;\r
+} Elf32_Verdef;\r
+\r
+typedef struct\r
+{\r
+  Elf32_Word      vda_name;\r
+  Elf32_Word      vda_next;\r
+} Elf32_Verdaux;\r
+\r
+typedef struct\r
+{\r
+  Elf32_Half      vn_version;\r
+  Elf32_Half      vn_cnt;\r
+  Elf32_Word      vn_file;\r
+  Elf32_Word      vn_aux;\r
+  Elf32_Word      vn_next;\r
+} Elf32_Verneed;\r
+\r
+typedef struct\r
+{\r
+  Elf32_Word      vna_hash;\r
+  Elf32_Half      vna_flags;\r
+  Elf32_Half      vna_other;\r
+  Elf32_Word      vna_name;\r
+  Elf32_Word      vna_next;\r
+} Elf32_Vernaux;\r
+\r
+typedef Elf32_Half Elf32_Versym;\r
+\r
+typedef struct {\r
+  Elf32_Half      si_boundto;     /* direct bindings - symbol bound to */\r
+  Elf32_Half      si_flags;       /* per symbol flags */\r
+} Elf32_Syminfo;\r
+\r
+#endif /* !_SYS_ELF32_H_ */\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf64.h b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf64.h
new file mode 100644 (file)
index 0000000..1cfe0c9
--- /dev/null
@@ -0,0 +1,260 @@
+/** @file\r
+Ported ELF include files from FreeBSD\r
+\r
+Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>\r
+This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+/*-\r
+ * Copyright (c) 1996-1998 John D. Polstra.\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ * $FreeBSD: src/sys/sys/elf64.h,v 1.10.14.2 2007/12/03 21:30:36 marius Exp $\r
+ */\r
+\r
+#ifndef _SYS_ELF64_H_\r
+#define _SYS_ELF64_H_ 1\r
+\r
+\r
+/*\r
+ * ELF definitions common to all 64-bit architectures.\r
+ */\r
+\r
+typedef UINT64  Elf64_Addr;\r
+typedef UINT16  Elf64_Half;\r
+typedef UINT64  Elf64_Off;\r
+typedef INT32   Elf64_Sword;\r
+typedef INT64   Elf64_Sxword;\r
+typedef UINT32  Elf64_Word;\r
+typedef UINT64  Elf64_Lword;\r
+typedef UINT64  Elf64_Xword;\r
+\r
+/*\r
+ * Types of dynamic symbol hash table bucket and chain elements.\r
+ *\r
+ * This is inconsistent among 64 bit architectures, so a machine dependent\r
+ * typedef is required.\r
+ */\r
+\r
+typedef Elf64_Word      Elf64_Hashelt;\r
+\r
+/* Non-standard class-dependent datatype used for abstraction. */\r
+typedef Elf64_Xword     Elf64_Size;\r
+typedef Elf64_Sxword    Elf64_Ssize;\r
+\r
+/*\r
+ * ELF header.\r
+ */\r
+\r
+typedef struct {\r
+  unsigned char   e_ident[EI_NIDENT]; /* File identification. */\r
+  Elf64_Half      e_type;             /* File type. */\r
+  Elf64_Half      e_machine;          /* Machine architecture. */\r
+  Elf64_Word      e_version;          /* ELF format version. */\r
+  Elf64_Addr      e_entry;            /* Entry point. */\r
+  Elf64_Off       e_phoff;            /* Program header file offset. */\r
+  Elf64_Off       e_shoff;            /* Section header file offset. */\r
+  Elf64_Word      e_flags;            /* Architecture-specific flags. */\r
+  Elf64_Half      e_ehsize;           /* Size of ELF header in bytes. */\r
+  Elf64_Half      e_phentsize;        /* Size of program header entry. */\r
+  Elf64_Half      e_phnum;            /* Number of program header entries. */\r
+  Elf64_Half      e_shentsize;        /* Size of section header entry. */\r
+  Elf64_Half      e_shnum;            /* Number of section header entries. */\r
+  Elf64_Half      e_shstrndx;         /* Section name strings section. */\r
+} Elf64_Ehdr;\r
+\r
+/*\r
+ * Section header.\r
+ */\r
+\r
+typedef struct {\r
+  Elf64_Word      sh_name;        /* Section name (index into the\r
+                                     section header string table). */\r
+  Elf64_Word      sh_type;        /* Section type. */\r
+  Elf64_Xword     sh_flags;       /* Section flags. */\r
+  Elf64_Addr      sh_addr;        /* Address in memory image. */\r
+  Elf64_Off       sh_offset;      /* Offset in file. */\r
+  Elf64_Xword     sh_size;        /* Size in bytes. */\r
+  Elf64_Word      sh_link;        /* Index of a related section. */\r
+  Elf64_Word      sh_info;        /* Depends on section type. */\r
+  Elf64_Xword     sh_addralign;   /* Alignment in bytes. */\r
+  Elf64_Xword     sh_entsize;     /* Size of each entry in section. */\r
+} Elf64_Shdr;\r
+\r
+/*\r
+ * Program header.\r
+ */\r
+\r
+typedef struct {\r
+  Elf64_Word      p_type;         /* Entry type. */\r
+  Elf64_Word      p_flags;        /* Access permission flags. */\r
+  Elf64_Off       p_offset;       /* File offset of contents. */\r
+  Elf64_Addr      p_vaddr;        /* Virtual address in memory image. */\r
+  Elf64_Addr      p_paddr;        /* Physical address (not used). */\r
+  Elf64_Xword     p_filesz;       /* Size of contents in file. */\r
+  Elf64_Xword     p_memsz;        /* Size of contents in memory. */\r
+  Elf64_Xword     p_align;        /* Alignment in memory and file. */\r
+} Elf64_Phdr;\r
+\r
+/*\r
+ * Dynamic structure.  The ".dynamic" section contains an array of them.\r
+ */\r
+\r
+typedef struct {\r
+  Elf64_Sxword    d_tag;          /* Entry type. */\r
+  union {\r
+    Elf64_Xword     d_val;  /* Integer value. */\r
+    Elf64_Addr      d_ptr;  /* Address value. */\r
+  } d_un;\r
+} Elf64_Dyn;\r
+\r
+/*\r
+ * Relocation entries.\r
+ */\r
+\r
+/* Relocations that don't need an addend field. */\r
+typedef struct {\r
+  Elf64_Addr      r_offset;       /* Location to be relocated. */\r
+  Elf64_Xword     r_info;         /* Relocation type and symbol index. */\r
+} Elf64_Rel;\r
+\r
+/* Relocations that need an addend field. */\r
+typedef struct {\r
+  Elf64_Addr      r_offset;       /* Location to be relocated. */\r
+  Elf64_Xword     r_info;         /* Relocation type and symbol index. */\r
+  Elf64_Sxword    r_addend;       /* Addend. */\r
+} Elf64_Rela;\r
+\r
+/* Macros for accessing the fields of r_info. */\r
+#define ELF64_R_SYM(info)       ((info) >> 32)\r
+#define ELF64_R_TYPE(info)      ((info) & 0xffffffffL)\r
+\r
+/* Macro for constructing r_info from field values. */\r
+#define ELF64_R_INFO(sym, type) (((sym) << 32) + ((type) & 0xffffffffL))\r
+\r
+#define ELF64_R_TYPE_DATA(info) (((Elf64_Xword)(info)<<32)>>40)\r
+#define ELF64_R_TYPE_ID(info)   (((Elf64_Xword)(info)<<56)>>56)\r
+#define ELF64_R_TYPE_INFO(data, type)   \\r
+                (((Elf64_Xword)(data)<<8)+(Elf64_Xword)(type))\r
+\r
+/*\r
+ *      Note entry header\r
+ */\r
+typedef Elf_Note Elf64_Nhdr;\r
+\r
+/*\r
+ *      Move entry\r
+ */\r
+typedef struct {\r
+  Elf64_Lword     m_value;        /* symbol value */\r
+  Elf64_Xword     m_info;         /* size + index */\r
+  Elf64_Xword     m_poffset;      /* symbol offset */\r
+  Elf64_Half      m_repeat;       /* repeat count */\r
+  Elf64_Half      m_stride;       /* stride info */\r
+} Elf64_Move;\r
+\r
+#define ELF64_M_SYM(info)       ((info)>>8)\r
+#define ELF64_M_SIZE(info)      ((unsigned char)(info))\r
+#define ELF64_M_INFO(sym, size) (((sym)<<8)+(unsigned char)(size))\r
+\r
+/*\r
+ *      Hardware/Software capabilities entry\r
+ */\r
+typedef struct {\r
+  Elf64_Xword     c_tag;          /* how to interpret value */\r
+  union {\r
+    Elf64_Xword     c_val;\r
+    Elf64_Addr      c_ptr;\r
+  } c_un;\r
+} Elf64_Cap;\r
+\r
+/*\r
+ * Symbol table entries.\r
+ */\r
+\r
+typedef struct {\r
+  Elf64_Word      st_name;        /* String table index of name. */\r
+  unsigned char   st_info;        /* Type and binding information. */\r
+  unsigned char   st_other;       /* Reserved (not used). */\r
+  Elf64_Half      st_shndx;       /* Section index of symbol. */\r
+  Elf64_Addr      st_value;       /* Symbol value. */\r
+  Elf64_Xword     st_size;        /* Size of associated object. */\r
+} Elf64_Sym;\r
+\r
+/* Macros for accessing the fields of st_info. */\r
+#define ELF64_ST_BIND(info)             ((info) >> 4)\r
+#define ELF64_ST_TYPE(info)             ((info) & 0xf)\r
+\r
+/* Macro for constructing st_info from field values. */\r
+#define ELF64_ST_INFO(bind, type)       (((bind) << 4) + ((type) & 0xf))\r
+\r
+/* Macro for accessing the fields of st_other. */\r
+#define ELF64_ST_VISIBILITY(oth)        ((oth) & 0x3)\r
+\r
+/* Structures used by Sun & GNU-style symbol versioning. */\r
+typedef struct {\r
+  Elf64_Half      vd_version;\r
+  Elf64_Half      vd_flags;\r
+  Elf64_Half      vd_ndx;\r
+  Elf64_Half      vd_cnt;\r
+  Elf64_Word      vd_hash;\r
+  Elf64_Word      vd_aux;\r
+  Elf64_Word      vd_next;\r
+} Elf64_Verdef;\r
+\r
+typedef struct {\r
+  Elf64_Word      vda_name;\r
+  Elf64_Word      vda_next;\r
+} Elf64_Verdaux;\r
+\r
+typedef struct {\r
+  Elf64_Half      vn_version;\r
+  Elf64_Half      vn_cnt;\r
+  Elf64_Word      vn_file;\r
+  Elf64_Word      vn_aux;\r
+  Elf64_Word      vn_next;\r
+} Elf64_Verneed;\r
+\r
+typedef struct {\r
+  Elf64_Word      vna_hash;\r
+  Elf64_Half      vna_flags;\r
+  Elf64_Half      vna_other;\r
+  Elf64_Word      vna_name;\r
+  Elf64_Word      vna_next;\r
+} Elf64_Vernaux;\r
+\r
+typedef Elf64_Half Elf64_Versym;\r
+\r
+typedef struct {\r
+  Elf64_Half      si_boundto;     /* direct bindings - symbol bound to */\r
+  Elf64_Half      si_flags;       /* per symbol flags */\r
+} Elf64_Syminfo;\r
+\r
+#endif /* !_SYS_ELF64_H_ */\r
diff --git a/ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf_common.h b/ArmPlatformPkg/Library/ArmShellCmdRunAxf/elf_common.h
new file mode 100644 (file)
index 0000000..ed3cedc
--- /dev/null
@@ -0,0 +1,1059 @@
+/** @file\r
+Ported ELF include files from FreeBSD\r
+\r
+Copyright (c) 2009 - 2010, Apple Inc. All rights reserved.<BR>\r
+Portions Copyright (c) 2011 - 2013, ARM Ltd. All rights reserved.<BR>\r
+This program and the accompanying materials\r
+are licensed and made available under the terms and conditions of the BSD License\r
+which accompanies this distribution.  The full text of the license may be found at\r
+http://opensource.org/licenses/bsd-license.php\r
+\r
+THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+\r
+**/\r
+/*-\r
+ * Copyright (c) 1998 John D. Polstra.\r
+ * All rights reserved.\r
+ *\r
+ * Redistribution and use in source and binary forms, with or without\r
+ * modification, are permitted provided that the following conditions\r
+ * are met:\r
+ * 1. Redistributions of source code must retain the above copyright\r
+ *    notice, this list of conditions and the following disclaimer.\r
+ * 2. Redistributions in binary form must reproduce the above copyright\r
+ *    notice, this list of conditions and the following disclaimer in the\r
+ *    documentation and/or other materials provided with the distribution.\r
+ *\r
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND\r
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\r
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE\r
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\r
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\r
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT\r
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY\r
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF\r
+ * SUCH DAMAGE.\r
+ *\r
+ * $FreeBSD: src/sys/sys/elf_common.h,v 1.15.8.2 2007/12/03 21:30:36 marius Exp $\r
+ */\r
+\r
+#ifndef _SYS_ELF_COMMON_H_\r
+#define _SYS_ELF_COMMON_H_ 1\r
+\r
+/*\r
+ * ELF definitions that are independent of architecture or word size.\r
+ */\r
+\r
+/*\r
+ * Note header.  The ".note" section contains an array of notes.  Each\r
+ * begins with this header, aligned to a word boundary.  Immediately\r
+ * following the note header is n_namesz bytes of name, padded to the\r
+ * next word boundary.  Then comes n_descsz bytes of descriptor, again\r
+ * padded to a word boundary.  The values of n_namesz and n_descsz do\r
+ * not include the padding.\r
+ */\r
+\r
+typedef struct {\r
+        UINT32  n_namesz;       /* Length of name. */\r
+        UINT32  n_descsz;       /* Length of descriptor. */\r
+        UINT32  n_type;         /* Type of this note. */\r
+} Elf_Note;\r
+\r
+/* Indexes into the e_ident array.  Keep synced with\r
+   http://www.sco.com/developers/gabi/latest/ch4.eheader.html */\r
+#define EI_MAG0         0       /* Magic number, byte 0. */\r
+#define EI_MAG1         1       /* Magic number, byte 1. */\r
+#define EI_MAG2         2       /* Magic number, byte 2. */\r
+#define EI_MAG3         3       /* Magic number, byte 3. */\r
+#define EI_CLASS        4       /* Class of machine. */\r
+#define EI_DATA         5       /* Data format. */\r
+#define EI_VERSION      6       /* ELF format version. */\r
+#define EI_OSABI        7       /* Operating system / ABI identification */\r
+#define EI_ABIVERSION   8       /* ABI version */\r
+#define OLD_EI_BRAND    8       /* Start of architecture identification. */\r
+#define EI_PAD          9       /* Start of padding (per SVR4 ABI). */\r
+#define EI_NIDENT       16      /* Size of e_ident array. */\r
+\r
+/* Values for the magic number bytes. */\r
+#define ELFMAG0         0x7f\r
+#define ELFMAG1         'E'\r
+#define ELFMAG2         'L'\r
+#define ELFMAG3         'F'\r
+#define ELFMAG          "\177ELF"       /* magic string */\r
+#define SELFMAG         4               /* magic string size */\r
+\r
+/* Values for e_ident[EI_VERSION] and e_version. */\r
+#define EV_NONE         0\r
+#define EV_CURRENT      1\r
+\r
+/* Values for e_ident[EI_CLASS]. */\r
+#define ELFCLASSNONE    0       /* Unknown class. */\r
+#define ELFCLASS32      1       /* 32-bit architecture. */\r
+#define ELFCLASS64      2       /* 64-bit architecture. */\r
+\r
+/* Values for e_ident[EI_DATA]. */\r
+#define ELFDATANONE     0       /* Unknown data format. */\r
+#define ELFDATA2LSB     1       /* 2's complement little-endian. */\r
+#define ELFDATA2MSB     2       /* 2's complement big-endian. */\r
+\r
+/* Values for e_ident[EI_OSABI]. */\r
+#define ELFOSABI_NONE           0       /* UNIX System V ABI */\r
+#define ELFOSABI_HPUX           1       /* HP-UX operating system */\r
+#define ELFOSABI_NETBSD         2       /* NetBSD */\r
+#define ELFOSABI_LINUX          3       /* GNU/Linux */\r
+#define ELFOSABI_HURD           4       /* GNU/Hurd */\r
+#define ELFOSABI_86OPEN         5       /* 86Open common IA32 ABI */\r
+#define ELFOSABI_SOLARIS        6       /* Solaris */\r
+#define ELFOSABI_AIX            7       /* AIX */\r
+#define ELFOSABI_IRIX           8       /* IRIX */\r
+#define ELFOSABI_FREEBSD        9       /* FreeBSD */\r
+#define ELFOSABI_TRU64          10      /* TRU64 UNIX */\r
+#define ELFOSABI_MODESTO        11      /* Novell Modesto */\r
+#define ELFOSABI_OPENBSD        12      /* OpenBSD */\r
+#define ELFOSABI_OPENVMS        13      /* Open VMS */\r
+#define ELFOSABI_NSK            14      /* HP Non-Stop Kernel */\r
+#define ELFOSABI_ARM            97      /* ARM */\r
+#define ELFOSABI_STANDALONE     255     /* Standalone (embedded) application */\r
+\r
+#define ELFOSABI_SYSV           ELFOSABI_NONE   /* symbol used in old spec */\r
+#define ELFOSABI_MONTEREY       ELFOSABI_AIX    /* Monterey */\r
+\r
+/* e_ident */\r
+#define IS_ELF(ehdr)    ((ehdr).e_ident[EI_MAG0] == ELFMAG0 && \\r
+                         (ehdr).e_ident[EI_MAG1] == ELFMAG1 && \\r
+                         (ehdr).e_ident[EI_MAG2] == ELFMAG2 && \\r
+                         (ehdr).e_ident[EI_MAG3] == ELFMAG3)\r
+\r
+/* Values for e_type. */\r
+#define ET_NONE         0       /* Unknown type. */\r
+#define ET_REL          1       /* Relocatable. */\r
+#define ET_EXEC         2       /* Executable. */\r
+#define ET_DYN          3       /* Shared object. */\r
+#define ET_CORE         4       /* Core file. */\r
+#define ET_LOOS         0xfe00  /* First operating system specific. */\r
+#define ET_HIOS         0xfeff  /* Last operating system-specific. */\r
+#define ET_LOPROC       0xff00  /* First processor-specific. */\r
+#define ET_HIPROC       0xffff  /* Last processor-specific. */\r
+\r
+/* Values for e_machine. */\r
+#define EM_NONE         0       /* Unknown machine. */\r
+#define EM_M32          1       /* AT&T WE32100. */\r
+#define EM_SPARC        2       /* Sun SPARC. */\r
+#define EM_386          3       /* Intel i386. */\r
+#define EM_68K          4       /* Motorola 68000. */\r
+#define EM_88K          5       /* Motorola 88000. */\r
+#define EM_860          7       /* Intel i860. */\r
+#define EM_MIPS         8       /* MIPS R3000 Big-Endian only. */\r
+#define EM_S370         9       /* IBM System/370. */\r
+#define EM_MIPS_RS3_LE  10      /* MIPS R3000 Little-Endian. */\r
+#define EM_PARISC       15      /* HP PA-RISC. */\r
+#define EM_VPP500       17      /* Fujitsu VPP500. */\r
+#define EM_SPARC32PLUS  18      /* SPARC v8plus. */\r
+#define EM_960          19      /* Intel 80960. */\r
+#define EM_PPC          20      /* PowerPC 32-bit. */\r
+#define EM_PPC64        21      /* PowerPC 64-bit. */\r
+#define EM_S390         22      /* IBM System/390. */\r
+#define EM_V800         36      /* NEC V800. */\r
+#define EM_FR20         37      /* Fujitsu FR20. */\r
+#define EM_RH32         38      /* TRW RH-32. */\r
+#define EM_RCE          39      /* Motorola RCE. */\r
+#define EM_ARM          40      /* ARM. */\r
+#define EM_SH           42      /* Hitachi SH. */\r
+#define EM_SPARCV9      43      /* SPARC v9 64-bit. */\r
+#define EM_TRICORE      44      /* Siemens TriCore embedded processor. */\r
+#define EM_ARC          45      /* Argonaut RISC Core. */\r
+#define EM_H8_300       46      /* Hitachi H8/300. */\r
+#define EM_H8_300H      47      /* Hitachi H8/300H. */\r
+#define EM_H8S          48      /* Hitachi H8S. */\r
+#define EM_H8_500       49      /* Hitachi H8/500. */\r
+#define EM_IA_64        50      /* Intel IA-64 Processor. */\r
+#define EM_MIPS_X       51      /* Stanford MIPS-X. */\r
+#define EM_COLDFIRE     52      /* Motorola ColdFire. */\r
+#define EM_68HC12       53      /* Motorola M68HC12. */\r
+#define EM_MMA          54      /* Fujitsu MMA. */\r
+#define EM_PCP          55      /* Siemens PCP. */\r
+#define EM_NCPU         56      /* Sony nCPU. */\r
+#define EM_NDR1         57      /* Denso NDR1 microprocessor. */\r
+#define EM_STARCORE     58      /* Motorola Star*Core processor. */\r
+#define EM_ME16         59      /* Toyota ME16 processor. */\r
+#define EM_ST100        60      /* STMicroelectronics ST100 processor. */\r
+#define EM_TINYJ        61      /* Advanced Logic Corp. TinyJ processor. */\r
+#define EM_X86_64       62      /* Advanced Micro Devices x86-64 */\r
+#define EM_AMD64        EM_X86_64 /* Advanced Micro Devices x86-64 (compat) */\r
+#define EM_AARCH64      183     /* ARM 64bit Architecture */\r
+\r
+/* Non-standard or deprecated. */\r
+#define EM_486          6       /* Intel i486. */\r
+#define EM_MIPS_RS4_BE  10      /* MIPS R4000 Big-Endian */\r
+#define EM_ALPHA_STD    41      /* Digital Alpha (standard value). */\r
+#define EM_ALPHA        0x9026  /* Alpha (written in the absence of an ABI) */\r
+\r
+/* Special section indexes. */\r
+#define SHN_UNDEF            0          /* Undefined, missing, irrelevant. */\r
+#define SHN_LORESERVE   0xff00          /* First of reserved range. */\r
+#define SHN_LOPROC      0xff00          /* First processor-specific. */\r
+#define SHN_HIPROC      0xff1f          /* Last processor-specific. */\r
+#define SHN_LOOS        0xff20          /* First operating system-specific. */\r
+#define SHN_HIOS        0xff3f          /* Last operating system-specific. */\r
+#define SHN_ABS         0xfff1          /* Absolute values. */\r
+#define SHN_COMMON      0xfff2          /* Common data. */\r
+#define SHN_XINDEX      0xffff          /* Escape -- index stored elsewhere. */\r
+#define SHN_HIRESERVE   0xffff          /* Last of reserved range. */\r
+\r
+/* sh_type */\r
+#define SHT_NULL                0       /* inactive */\r
+#define SHT_PROGBITS            1       /* program defined information */\r
+#define SHT_SYMTAB              2       /* symbol table section */\r
+#define SHT_STRTAB              3       /* string table section */\r
+#define SHT_RELA                4       /* relocation section with addends */\r
+#define SHT_HASH                5       /* symbol hash table section */\r
+#define SHT_DYNAMIC             6       /* dynamic section */\r
+#define SHT_NOTE                7       /* note section */\r
+#define SHT_NOBITS              8       /* no space section */\r
+#define SHT_REL                 9       /* relocation section - no addends */\r
+#define SHT_SHLIB               10      /* reserved - purpose unknown */\r
+#define SHT_DYNSYM              11      /* dynamic symbol table section */\r
+#define SHT_INIT_ARRAY          14      /* Initialization function pointers. */\r
+#define SHT_FINI_ARRAY          15      /* Termination function pointers. */\r
+#define SHT_PREINIT_ARRAY       16      /* Pre-initialization function ptrs. */\r
+#define SHT_GROUP               17      /* Section group. */\r
+#define SHT_SYMTAB_SHNDX        18      /* Section indexes (see SHN_XINDEX). */\r
+#define SHT_LOOS                0x60000000      /* First of OS specific semantics */\r
+#define SHT_LOSUNW              0x6ffffff4\r
+#define SHT_SUNW_dof            0x6ffffff4\r
+#define SHT_SUNW_cap            0x6ffffff5\r
+#define SHT_SUNW_SIGNATURE      0x6ffffff6\r
+#define SHT_SUNW_ANNOTATE       0x6ffffff7\r
+#define SHT_SUNW_DEBUGSTR       0x6ffffff8\r
+#define SHT_SUNW_DEBUG          0x6ffffff9\r
+#define SHT_SUNW_move           0x6ffffffa\r
+#define SHT_SUNW_COMDAT         0x6ffffffb\r
+#define SHT_SUNW_syminfo        0x6ffffffc\r
+#define SHT_SUNW_verdef         0x6ffffffd\r
+#define SHT_GNU_verdef          0x6ffffffd      /* Symbol versions provided */\r
+#define SHT_SUNW_verneed        0x6ffffffe\r
+#define SHT_GNU_verneed         0x6ffffffe      /* Symbol versions required */\r
+#define SHT_SUNW_versym         0x6fffffff\r
+#define SHT_GNU_versym          0x6fffffff      /* Symbol version table */\r
+#define SHT_HISUNW              0x6fffffff\r
+#define SHT_HIOS                0x6fffffff      /* Last of OS specific semantics */\r
+#define SHT_LOPROC              0x70000000      /* reserved range for processor */\r
+#define SHT_AMD64_UNWIND        0x70000001      /* unwind information */\r
+#define SHT_HIPROC              0x7fffffff      /* specific section header types */\r
+#define SHT_LOUSER              0x80000000      /* reserved range for application */\r
+#define SHT_HIUSER              0xffffffff      /* specific indexes */\r
+\r
+/* Flags for sh_flags. */\r
+#define SHF_WRITE               0x1     /* Section contains writable data. */\r
+#define SHF_ALLOC               0x2     /* Section occupies memory. */\r
+#define SHF_EXECINSTR           0x4     /* Section contains instructions. */\r
+#define SHF_MERGE               0x10    /* Section may be merged. */\r
+#define SHF_STRINGS             0x20    /* Section contains strings. */\r
+#define SHF_INFO_LINK           0x40    /* sh_info holds section index. */\r
+#define SHF_LINK_ORDER          0x80    /* Special ordering requirements. */\r
+#define SHF_OS_NONCONFORMING    0x100   /* OS-specific processing required. */\r
+#define SHF_GROUP               0x200   /* Member of section group. */\r
+#define SHF_TLS                 0x400   /* Section contains TLS data. */\r
+#define SHF_MASKOS      0x0ff00000      /* OS-specific semantics. */\r
+#define SHF_MASKPROC    0xf0000000      /* Processor-specific semantics. */\r
+\r
+/* Values for p_type. */\r
+#define PT_NULL         0       /* Unused entry. */\r
+#define PT_LOAD         1       /* Loadable segment. */\r
+#define PT_DYNAMIC      2       /* Dynamic linking information segment. */\r
+#define PT_INTERP       3       /* Pathname of interpreter. */\r
+#define PT_NOTE         4       /* Auxiliary information. */\r
+#define PT_SHLIB        5       /* Reserved (not used). */\r
+#define PT_PHDR         6       /* Location of program header itself. */\r
+#define PT_TLS          7       /* Thread local storage segment */\r
+#define PT_LOOS         0x60000000      /* First OS-specific. */\r
+#define PT_SUNW_UNWIND  0x6464e550      /* amd64 UNWIND program header */\r
+#define PT_GNU_EH_FRAME 0x6474e550\r
+#define PT_LOSUNW       0x6ffffffa\r
+#define PT_SUNWBSS      0x6ffffffa      /* Sun Specific segment */\r
+#define PT_SUNWSTACK    0x6ffffffb      /* describes the stack segment */\r
+#define PT_SUNWDTRACE   0x6ffffffc      /* private */\r
+#define PT_SUNWCAP      0x6ffffffd      /* hard/soft capabilities segment */\r
+#define PT_HISUNW       0x6fffffff\r
+#define PT_HIOS         0x6fffffff      /* Last OS-specific. */\r
+#define PT_LOPROC       0x70000000      /* First processor-specific type. */\r
+#define PT_HIPROC       0x7fffffff      /* Last processor-specific type. */\r
+\r
+/* Values for p_flags. */\r
+#define PF_X            0x1             /* Executable. */\r
+#define PF_W            0x2             /* Writable. */\r
+#define PF_R            0x4             /* Readable. */\r
+#define PF_MASKOS       0x0ff00000      /* Operating system-specific. */\r
+#define PF_MASKPROC     0xf0000000      /* Processor-specific. */\r
+\r
+/* Extended program header index. */\r
+#define PN_XNUM         0xffff\r
+\r
+/* Values for d_tag. */\r
+#define DT_NULL         0       /* Terminating entry. */\r
+#define DT_NEEDED       1       /* String table offset of a needed shared\r
+                                   library. */\r
+#define DT_PLTRELSZ     2       /* Total size in bytes of PLT relocations. */\r
+#define DT_PLTGOT       3       /* Processor-dependent address. */\r
+#define DT_HASH         4       /* Address of symbol hash table. */\r
+#define DT_STRTAB       5       /* Address of string table. */\r
+#define DT_SYMTAB       6       /* Address of symbol table. */\r
+#define DT_RELA         7       /* Address of ElfNN_Rela relocations. */\r
+#define DT_RELASZ       8       /* Total size of ElfNN_Rela relocations. */\r
+#define DT_RELAENT      9       /* Size of each ElfNN_Rela relocation entry. */\r
+#define DT_STRSZ        10      /* Size of string table. */\r
+#define DT_SYMENT       11      /* Size of each symbol table entry. */\r
+#define DT_INIT         12      /* Address of initialization function. */\r
+#define DT_FINI         13      /* Address of finalization function. */\r
+#define DT_SONAME       14      /* String table offset of shared object\r
+                                   name. */\r
+#define DT_RPATH        15      /* String table offset of library path. [sup] */\r
+#define DT_SYMBOLIC     16      /* Indicates "symbolic" linking. [sup] */\r
+#define DT_REL          17      /* Address of ElfNN_Rel relocations. */\r
+#define DT_RELSZ        18      /* Total size of ElfNN_Rel relocations. */\r
+#define DT_RELENT       19      /* Size of each ElfNN_Rel relocation. */\r
+#define DT_PLTREL       20      /* Type of relocation used for PLT. */\r
+#define DT_DEBUG        21      /* Reserved (not used). */\r
+#define DT_TEXTREL      22      /* Indicates there may be relocations in\r
+                                   non-writable segments. [sup] */\r
+#define DT_JMPREL       23      /* Address of PLT relocations. */\r
+#define DT_BIND_NOW     24      /* [sup] */\r
+#define DT_INIT_ARRAY   25      /* Address of the array of pointers to\r
+                                   initialization functions */\r
+#define DT_FINI_ARRAY   26      /* Address of the array of pointers to\r
+                                   termination functions */\r
+#define DT_INIT_ARRAYSZ 27      /* Size in bytes of the array of\r
+                                   initialization functions. */\r
+#define DT_FINI_ARRAYSZ 28      /* Size in bytes of the array of\r
+                                   terminationfunctions. */\r
+#define DT_RUNPATH      29      /* String table offset of a null-terminated\r
+                                   library search path string. */\r
+#define DT_FLAGS        30      /* Object specific flag values. */\r
+#define DT_ENCODING     32      /* Values greater than or equal to DT_ENCODING\r
+                                   and less than DT_LOOS follow the rules for\r
+                                   the interpretation of the d_un union\r
+                                   as follows: even == 'd_ptr', even == 'd_val'\r
+                                   or none */\r
+#define DT_PREINIT_ARRAY   32   /* Address of the array of pointers to\r
+                                   pre-initialization functions. */\r
+#define DT_PREINIT_ARRAYSZ 33   /* Size in bytes of the array of\r
+                                   pre-initialization functions. */\r
+#define DT_MAXPOSTAGS      34   /* number of positive tags */\r
+#define DT_LOOS            0x6000000d      /* First OS-specific */\r
+#define DT_SUNW_AUXILIARY  0x6000000d      /* symbol auxiliary name */\r
+#define DT_SUNW_RTLDINF    0x6000000e      /* ld.so.1 info (private) */\r
+#define DT_SUNW_FILTER     0x6000000f      /* symbol filter name */\r
+#define DT_SUNW_CAP        0x60000010      /* hardware/software */\r
+#define DT_HIOS            0x6ffff000      /* Last OS-specific */\r
+\r
+/*\r
+ * DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the\r
+ * Dyn.d_un.d_val field of the Elf*_Dyn structure.\r
+ */\r
+#define DT_VALRNGLO     0x6ffffd00\r
+#define DT_CHECKSUM     0x6ffffdf8      /* elf checksum */\r
+#define DT_PLTPADSZ     0x6ffffdf9      /* pltpadding size */\r
+#define DT_MOVEENT      0x6ffffdfa      /* move table entry size */\r
+#define DT_MOVESZ       0x6ffffdfb      /* move table size */\r
+#define DT_FEATURE_1    0x6ffffdfc      /* feature holder */\r
+#define DT_POSFLAG_1    0x6ffffdfd      /* flags for DT_* entries, effecting */\r
+                                        /*      the following DT_* entry. */\r
+                                        /*      See DF_P1_* definitions */\r
+#define DT_SYMINSZ      0x6ffffdfe      /* syminfo table size (in bytes) */\r
+#define DT_SYMINENT     0x6ffffdff      /* syminfo entry size (in bytes) */\r
+#define DT_VALRNGHI     0x6ffffdff\r
+\r
+/*\r
+ * DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the\r
+ * Dyn.d_un.d_ptr field of the Elf*_Dyn structure.\r
+ *\r
+ * If any adjustment is made to the ELF object after it has been\r
+ * built, these entries will need to be adjusted.\r
+ */\r
+#define DT_ADDRRNGLO    0x6ffffe00\r
+#define DT_CONFIG       0x6ffffefa      /* configuration information */\r
+#define DT_DEPAUDIT     0x6ffffefb      /* dependency auditing */\r
+#define DT_AUDIT        0x6ffffefc      /* object auditing */\r
+#define DT_PLTPAD       0x6ffffefd      /* pltpadding (sparcv9) */\r
+#define DT_MOVETAB      0x6ffffefe      /* move table */\r
+#define DT_SYMINFO      0x6ffffeff      /* syminfo table */\r
+#define DT_ADDRRNGHI    0x6ffffeff\r
+\r
+#define DT_VERSYM       0x6ffffff0      /* Address of versym section. */\r
+#define DT_RELACOUNT    0x6ffffff9      /* number of RELATIVE relocations */\r
+#define DT_RELCOUNT     0x6ffffffa      /* number of RELATIVE relocations */\r
+#define DT_FLAGS_1      0x6ffffffb      /* state flags - see DF_1_* defs */\r
+#define DT_VERDEF       0x6ffffffc      /* Address of verdef section. */\r
+#define DT_VERDEFNUM    0x6ffffffd      /* Number of elems in verdef section */\r
+#define DT_VERNEED      0x6ffffffe      /* Address of verneed section. */\r
+#define DT_VERNEEDNUM   0x6fffffff      /* Number of elems in verneed section */\r
+\r
+#define DT_LOPROC       0x70000000      /* First processor-specific type. */\r
+#define DT_DEPRECATED_SPARC_REGISTER    0x7000001\r
+#define DT_AUXILIARY    0x7ffffffd      /* shared library auxiliary name */\r
+#define DT_USED         0x7ffffffe      /* ignored - same as needed */\r
+#define DT_FILTER       0x7fffffff      /* shared library filter name */\r
+#define DT_HIPROC       0x7fffffff      /* Last processor-specific type. */\r
+\r
+/* Values for DT_FLAGS */\r
+#define DF_ORIGIN       0x0001  /* Indicates that the object being loaded may\r
+                                   make reference to the $ORIGIN substitution\r
+                                   string */\r
+#define DF_SYMBOLIC     0x0002  /* Indicates "symbolic" linking. */\r
+#define DF_TEXTREL      0x0004  /* Indicates there may be relocations in\r
+                                   non-writable segments. */\r
+#define DF_BIND_NOW     0x0008  /* Indicates that the dynamic linker should\r
+                                   process all relocations for the object\r
+                                   containing this entry before transferring\r
+                                   control to the program. */\r
+#define DF_STATIC_TLS   0x0010  /* Indicates that the shared object or\r
+                                   executable contains code using a static\r
+                                   thread-local storage scheme. */\r
+\r
+/* Values for n_type.  Used in core files. */\r
+#define NT_PRSTATUS     1       /* Process status. */\r
+#define NT_FPREGSET     2       /* Floating point registers. */\r
+#define NT_PRPSINFO     3       /* Process state info. */\r
+\r
+/* Symbol Binding - ELFNN_ST_BIND - st_info */\r
+#define STB_LOCAL       0       /* Local symbol */\r
+#define STB_GLOBAL      1       /* Global symbol */\r
+#define STB_WEAK        2       /* like global - lower precedence */\r
+#define STB_LOOS        10      /* Reserved range for operating system */\r
+#define STB_HIOS        12      /*   specific semantics. */\r
+#define STB_LOPROC      13      /* reserved range for processor */\r
+#define STB_HIPROC      15      /*   specific semantics. */\r
+\r
+/* Symbol type - ELFNN_ST_TYPE - st_info */\r
+#define STT_NOTYPE      0       /* Unspecified type. */\r
+#define STT_OBJECT      1       /* Data object. */\r
+#define STT_FUNC        2       /* Function. */\r
+#define STT_SECTION     3       /* Section. */\r
+#define STT_FILE        4       /* Source file. */\r
+#define STT_COMMON      5       /* Uninitialized common block. */\r
+#define STT_TLS         6       /* TLS object. */\r
+#define STT_NUM         7\r
+#define STT_LOOS        10      /* Reserved range for operating system */\r
+#define STT_HIOS        12      /*   specific semantics. */\r
+#define STT_LOPROC      13      /* reserved range for processor */\r
+#define STT_HIPROC      15      /*   specific semantics. */\r
+\r
+/* Symbol visibility - ELFNN_ST_VISIBILITY - st_other */\r
+#define STV_DEFAULT     0x0     /* Default visibility (see binding). */\r
+#define STV_INTERNAL    0x1     /* Special meaning in relocatable objects. */\r
+#define STV_HIDDEN      0x2     /* Not visible. */\r
+#define STV_PROTECTED   0x3     /* Visible but not preemptible. */\r
+\r
+/* Special symbol table indexes. */\r
+#define STN_UNDEF       0       /* Undefined symbol index. */\r
+\r
+/* Symbol versioning flags. */\r
+#define VER_DEF_CURRENT 1\r
+#define VER_DEF_IDX(x)  VER_NDX(x)\r
+\r
+#define VER_FLG_BASE    0x01\r
+#define VER_FLG_WEAK    0x02\r
+\r
+#define VER_NEED_CURRENT        1\r
+#define VER_NEED_WEAK   (1u << 15)\r
+#define VER_NEED_HIDDEN VER_NDX_HIDDEN\r
+#define VER_NEED_IDX(x) VER_NDX(x)\r
+\r
+#define VER_NDX_LOCAL   0\r
+#define VER_NDX_GLOBAL  1\r
+#define VER_NDX_GIVEN   2\r
+\r
+#define VER_NDX_HIDDEN  (1u << 15)\r
+#define VER_NDX(x)      ((x) & ~(1u << 15))\r
+\r
+#define CA_SUNW_NULL    0\r
+#define CA_SUNW_HW_1    1               /* first hardware capabilities entry */\r
+#define CA_SUNW_SF_1    2               /* first software capabilities entry */\r
+\r
+/*\r
+ * Syminfo flag values\r
+ */\r
+#define SYMINFO_FLG_DIRECT      0x0001  /* symbol ref has direct association */\r
+                                        /*      to object containing defn. */\r
+#define SYMINFO_FLG_PASSTHRU    0x0002  /* ignored - see SYMINFO_FLG_FILTER */\r
+#define SYMINFO_FLG_COPY        0x0004  /* symbol is a copy-reloc */\r
+#define SYMINFO_FLG_LAZYLOAD    0x0008  /* object containing defn should be */\r
+                                        /*      lazily-loaded */\r
+#define SYMINFO_FLG_DIRECTBIND  0x0010  /* ref should be bound directly to */\r
+                                        /*      object containing defn. */\r
+#define SYMINFO_FLG_NOEXTDIRECT 0x0020  /* don't let an external reference */\r
+                                        /*      directly bind to this symbol */\r
+#define SYMINFO_FLG_FILTER      0x0002  /* symbol ref is associated to a */\r
+#define SYMINFO_FLG_AUXILIARY   0x0040  /*      standard or auxiliary filter */\r
+\r
+/*\r
+ * Syminfo.si_boundto values.\r
+ */\r
+#define SYMINFO_BT_SELF         0xffff  /* symbol bound to self */\r
+#define SYMINFO_BT_PARENT       0xfffe  /* symbol bound to parent */\r
+#define SYMINFO_BT_NONE         0xfffd  /* no special symbol binding */\r
+#define SYMINFO_BT_EXTERN       0xfffc  /* symbol defined as external */\r
+#define SYMINFO_BT_LOWRESERVE   0xff00  /* beginning of reserved entries */\r
+\r
+/*\r
+ * Syminfo version values.\r
+ */\r
+#define SYMINFO_NONE            0       /* Syminfo version */\r
+#define SYMINFO_CURRENT         1\r
+#define SYMINFO_NUM             2\r
+\r
+/*\r
+ * Relocation types.\r
+ *\r
+ * All machine architectures are defined here to allow tools on one to\r
+ * handle others.\r
+ */\r
+\r
+#define R_386_NONE              0       /* No relocation. */\r
+#define R_386_32                1       /* Add symbol value. */\r
+#define R_386_PC32              2       /* Add PC-relative symbol value. */\r
+#define R_386_GOT32             3       /* Add PC-relative GOT offset. */\r
+#define R_386_PLT32             4       /* Add PC-relative PLT offset. */\r
+#define R_386_COPY              5       /* Copy data from shared object. */\r
+#define R_386_GLOB_DAT          6       /* Set GOT entry to data address. */\r
+#define R_386_JMP_SLOT          7       /* Set GOT entry to code address. */\r
+#define R_386_RELATIVE          8       /* Add load address of shared object. */\r
+#define R_386_GOTOFF            9       /* Add GOT-relative symbol address. */\r
+#define R_386_GOTPC             10      /* Add PC-relative GOT table address. */\r
+#define R_386_TLS_TPOFF         14      /* Negative offset in static TLS block */\r
+#define R_386_TLS_IE            15      /* Absolute address of GOT for -ve static TLS */\r
+#define R_386_TLS_GOTIE         16      /* GOT entry for negative static TLS block */\r
+#define R_386_TLS_LE            17      /* Negative offset relative to static TLS */\r
+#define R_386_TLS_GD            18      /* 32 bit offset to GOT (index,off) pair */\r
+#define R_386_TLS_LDM           19      /* 32 bit offset to GOT (index,zero) pair */\r
+#define R_386_TLS_GD_32         24      /* 32 bit offset to GOT (index,off) pair */\r
+#define R_386_TLS_GD_PUSH       25      /* pushl instruction for Sun ABI GD sequence */\r
+#define R_386_TLS_GD_CALL       26      /* call instruction for Sun ABI GD sequence */\r
+#define R_386_TLS_GD_POP        27      /* popl instruction for Sun ABI GD sequence */\r
+#define R_386_TLS_LDM_32        28      /* 32 bit offset to GOT (index,zero) pair */\r
+#define R_386_TLS_LDM_PUSH      29      /* pushl instruction for Sun ABI LD sequence */\r
+#define R_386_TLS_LDM_CALL      30      /* call instruction for Sun ABI LD sequence */\r
+#define R_386_TLS_LDM_POP       31      /* popl instruction for Sun ABI LD sequence */\r
+#define R_386_TLS_LDO_32        32      /* 32 bit offset from start of TLS block */\r
+#define R_386_TLS_IE_32         33      /* 32 bit offset to GOT static TLS offset entry */\r
+#define R_386_TLS_LE_32         34      /* 32 bit offset within static TLS block */\r
+#define R_386_TLS_DTPMOD32      35      /* GOT entry containing TLS index */\r
+#define R_386_TLS_DTPOFF32      36      /* GOT entry containing TLS offset */\r
+#define R_386_TLS_TPOFF32       37      /* GOT entry of -ve static TLS offset */\r
+\r
+/* Null relocation */\r
+#define R_AARCH64_NONE                          256     /* No relocation */\r
+/* Static AArch64 relocations */\r
+ /* Static data relocations */\r
+#define R_AARCH64_ABS64                         257     /* S + A */\r
+#define R_AARCH64_ABS32                         258     /* S + A */\r
+#define R_AARCH64_ABS16                         259     /* S + A */\r
+#define R_AARCH64_PREL64                        260     /* S + A - P */\r
+#define R_AARCH64_PREL32                        261     /* S + A - P */\r
+#define R_AARCH64_PREL16                        262     /* S + A - P */\r
+ /* Group relocations to create a 16, 32, 48, or 64 bit unsigned data value or address inline */\r
+#define R_AARCH64_MOVW_UABS_G0                  263     /* S + A */\r
+#define R_AARCH64_MOVW_UABS_G0_NC               264     /* S + A */\r
+#define R_AARCH64_MOVW_UABS_G1                  265     /* S + A */\r
+#define R_AARCH64_MOVW_UABS_G1_NC               266     /* S + A */\r
+#define R_AARCH64_MOVW_UABS_G2                  267     /* S + A */\r
+#define R_AARCH64_MOVW_UABS_G2_NC               268     /* S + A */\r
+#define R_AARCH64_MOVW_UABS_G3                  269     /* S + A */\r
+ /* Group relocations to create a 16, 32, 48, or 64 bit signed data or offset value inline */\r
+#define R_AARCH64_MOVW_SABS_G0                  270     /* S + A */\r
+#define R_AARCH64_MOVW_SABS_G1                  271     /* S + A */\r
+#define R_AARCH64_MOVW_SABS_G2                  272     /* S + A */\r
+ /* Relocations to generate 19, 21 and 33 bit PC-relative addresses */\r
+#define R_AARCH64_LD_PREL_LO19                  273     /* S + A - P */\r
+#define R_AARCH64_ADR_PREL_LO21                 274     /* S + A - P */\r
+#define R_AARCH64_ADR_PREL_PG_HI21              275     /* Page(S+A) - Page(P) */\r
+#define R_AARCH64_ADR_PREL_PG_HI21_NC           276     /* Page(S+A) - Page(P) */\r
+#define R_AARCH64_ADD_ABS_LO12_NC               277     /* S + A */\r
+#define R_AARCH64_LDST8_ABS_LO12_NC             278     /* S + A */\r
+#define R_AARCH64_LDST16_ABS_LO12_NC            284     /* S + A */\r
+#define R_AARCH64_LDST32_ABS_LO12_NC            285     /* S + A */\r
+#define R_AARCH64_LDST64_ABS_LO12_NC            286     /* S + A */\r
+#define R_AARCH64_LDST128_ABS_LO12_NC           299     /* S + A */\r
+ /* Relocations for control-flow instructions - all offsets are a multiple of 4 */\r
+#define R_AARCH64_TSTBR14                       279     /* S+A-P */\r
+#define R_AARCH64_CONDBR19                      280     /* S+A-P */\r
+#define R_AARCH64_JUMP26                        282     /* S+A-P */\r
+#define R_AARCH64_CALL26                        283     /* S+A-P */\r
+ /* Group relocations to create a 16, 32, 48, or 64 bit PC-relative offset inline */\r
+#define R_AARCH64_MOVW_PREL_G0                  287     /* S+A-P */\r
+#define R_AARCH64_MOVW_PREL_G0_NC               288     /* S+A-P */\r
+#define R_AARCH64_MOVW_PREL_G1                  289     /* S+A-P */\r
+#define R_AARCH64_MOVW_PREL_G1_NC               290     /* S+A-P */\r
+#define R_AARCH64_MOVW_PREL_G2                  291     /* S+A-P */\r
+#define R_AARCH64_MOVW_PREL_G2_NC               292     /* S+A-P */\r
+#define R_AARCH64_MOVW_PREL_G3                  293     /* S+A-P */\r
+ /* Group relocations to create a 16, 32, 48, or 64 bit GOT-relative offsets inline */\r
+#define R_AARCH64_MOVW_GOTOFF_G0                300     /* G(S)-GOT */\r
+#define R_AARCH64_MOVW_GOTOFF_G0_NC             301     /* G(S)-GOT */\r
+#define R_AARCH64_MOVW_GOTOFF_G1                302     /* G(S)-GOT */\r
+#define R_AARCH64_MOVW_GOTOFF_G1_NC             303     /* G(S)-GOT */\r
+#define R_AARCH64_MOVW_GOTOFF_G2                304     /* G(S)-GOT */\r
+#define R_AARCH64_MOVW_GOTOFF_G2_NC             305     /* G(S)-GOT */\r
+#define R_AARCH64_MOVW_GOTOFF_G3                306     /* G(S)-GOT */\r
+ /*  GOT-relative data relocations */\r
+#define R_AARCH64_GOTREL64                      307     /* S+A-GOT */\r
+#define R_AARCH64_GOTREL32                      308     /* S+A-GOT */\r
+ /* GOT-relative instruction relocations */\r
+#define R_AARCH64_GOT_LD_PREL19                 309     /* G(S)-P */\r
+#define R_AARCH64_LD64_GOTOFF_LO15              310     /* G(S)-GOT */\r
+#define R_AARCH64_ADR_GOT_PAGE                  311     /* Page(G(S))-Page(P) */\r
+#define R_AARCH64_LD64_GOT_LO12_NC              312     /* G(S) */\r
+#define R_AARCH64_LD64_GOTPAGE_LO15             313     /* G(S)-Page(GOT) */\r
+/* Relocations for thread-local storage */\r
+ /* General Dynamic TLS relocations */\r
+#define R_AARCH64_TLSGD_ADR_PREL21              512     /* G(TLSIDX(S+A)) - P */\r
+#define R_AARCH64_TLSGD_ADR_PAGE21              513     /* Page(G(TLSIDX(S+A))) - Page(P) */\r
+#define R_AARCH64_TLSGD_ADD_LO12_NC             514     /* G(TLSIDX(S+A)) */\r
+#define R_AARCH64_TLSGD_MOVW_G1                 515     /* G(TLSIDX(S+A)) - GOT */\r
+#define R_AARCH64_TLSGD_MOVW_G0_NC              516     /* G(TLSIDX(S+A)) - GOT */\r
+ /* Local Dynamic TLS relocations */\r
+#define R_AARCH64_TLSLD_ADR_PREL21              517     /* G(LDM(S))) - P */\r
+#define R_AARCH64_TLSLD_ADR_PAGE21              518     /* Page(G(LDM(S)))-Page(P) */\r
+#define R_AARCH64_TLSLD_ADD_LO12_NC             519     /* G(LDM(S)) */\r
+#define R_AARCH64_TLSLD_MOVW_G1                 520     /* G(LDM(S)) - GOT */\r
+#define R_AARCH64_TLSLD_MOVW_G0_NC              521     /* G(LDM(S)) - GOT */\r
+#define R_AARCH64_TLSLD_LD_PREL19               522     /* G(LDM(S)) - P */\r
+#define R_AARCH64_TLSLD_MOVW_DTPREL_G2          523     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_MOVW_DTPREL_G1          524     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC       525     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_MOVW_DTPREL_G0          526     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC       527     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_ADD_DTPREL_HI12         528     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_ADD_DTPREL_LO12         529     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC      530     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST8_DTPREL_LO12       531     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC    532     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST16_DTPREL_LO12      533     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC   534     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST32_DTPREL_LO12      535     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC   536     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST64_DTPREL_LO12      537     /* DTPREL(S+A) */\r
+#define R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC   538     /* DTPREL(S+A) */\r
+ /* Initial Exec TLS relocations */\r
+#define R_AARCH64_TLSIE_MOVW_GOTTPREL_G1        539     /* G(TPREL(S+A)) - GOT */\r
+#define R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC     540     /* G(TPREL(S+A)) - GOT */\r
+#define R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21     541     /* Page(G(TPREL(S+A))) - Page(P) */\r
+#define R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC   542     /* G(TPREL(S+A)) */\r
+#define R_AARCH64_TLSIE_LD_GOTTPREL_PREL19      543     /* G(TPREL(S+A)) - P */\r
+ /* Local Exec TLS relocations */\r
+#define R_AARCH64_TLSLE_MOVW_TPREL_G2           544     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_MOVW_TPREL_G1           545     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_MOVW_TPREL_G1_NC        546     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_MOVW_TPREL_G0           547     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_MOVW_TPREL_G0_NC        548     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_ADD_TPREL_HI12          549     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_ADD_TPREL_LO12          550     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_ADD_TPREL_LO12_NC       551     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST8_TPREL_LO12        552     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC     553     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST16_TPREL_LO12       554     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC    555     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST32_TPREL_LO12       556     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC    557     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST64_TPREL_LO12       558     /* TPREL(S+A) */\r
+#define R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC    559     /* TPREL(S+A) */\r
+/* Dynamic relocations */\r
+ /* Dynamic relocations */\r
+#define R_AARCH64_COPY                          1024\r
+#define R_AARCH64_GLOB_DAT                      1025    /* S + A */\r
+#define R_AARCH64_JUMP_SLOT                     1026    /* S + A */\r
+#define R_AARCH64_RELATIVE                      1027    /* Delta(S) + A , Delta(P) + A */\r
+#define R_AARCH64_TLS_DTPREL64                  1028    /* DTPREL(S+A) */\r
+#define R_AARCH64_TLS_DTPMOD64                  1029    /* LDM(S) */\r
+#define R_AARCH64_TLS_TPREL64                   1030    /* TPREL(S+A) */\r
+#define R_AARCH64_TLS_DTPREL32                  1031    /* DTPREL(S+A) */\r
+#define R_AARCH64_TLS_DTPMOD32                  1032    /* LDM(S) */\r
+#define R_AARCH64_TLS_TPREL32                   1033    /* DTPREL(S+A) */\r
+\r
+#define R_ALPHA_NONE            0       /* No reloc */\r
+#define R_ALPHA_REFLONG         1       /* Direct 32 bit */\r
+#define R_ALPHA_REFQUAD         2       /* Direct 64 bit */\r
+#define R_ALPHA_GPREL32         3       /* GP relative 32 bit */\r
+#define R_ALPHA_LITERAL         4       /* GP relative 16 bit w/optimization */\r
+#define R_ALPHA_LITUSE          5       /* Optimization hint for LITERAL */\r
+#define R_ALPHA_GPDISP          6       /* Add displacement to GP */\r
+#define R_ALPHA_BRADDR          7       /* PC+4 relative 23 bit shifted */\r
+#define R_ALPHA_HINT            8       /* PC+4 relative 16 bit shifted */\r
+#define R_ALPHA_SREL16          9       /* PC relative 16 bit */\r
+#define R_ALPHA_SREL32          10      /* PC relative 32 bit */\r
+#define R_ALPHA_SREL64          11      /* PC relative 64 bit */\r
+#define R_ALPHA_OP_PUSH         12      /* OP stack push */\r
+#define R_ALPHA_OP_STORE        13      /* OP stack pop and store */\r
+#define R_ALPHA_OP_PSUB         14      /* OP stack subtract */\r
+#define R_ALPHA_OP_PRSHIFT      15      /* OP stack right shift */\r
+#define R_ALPHA_GPVALUE         16\r
+#define R_ALPHA_GPRELHIGH       17\r
+#define R_ALPHA_GPRELLOW        18\r
+#define R_ALPHA_IMMED_GP_16     19\r
+#define R_ALPHA_IMMED_GP_HI32   20\r
+#define R_ALPHA_IMMED_SCN_HI32  21\r
+#define R_ALPHA_IMMED_BR_HI32   22\r
+#define R_ALPHA_IMMED_LO32      23\r
+#define R_ALPHA_COPY            24      /* Copy symbol at runtime */\r
+#define R_ALPHA_GLOB_DAT        25      /* Create GOT entry */\r
+#define R_ALPHA_JMP_SLOT        26      /* Create PLT entry */\r
+#define R_ALPHA_RELATIVE        27      /* Adjust by program base */\r
+\r
+#define R_ARM_NONE              0       /* No relocation. */\r
+#define R_ARM_PC24              1\r
+#define R_ARM_ABS32             2\r
+#define R_ARM_REL32             3\r
+#define R_ARM_PC13              4\r
+#define R_ARM_ABS16             5\r
+#define R_ARM_ABS12             6\r
+#define R_ARM_THM_ABS5          7\r
+#define R_ARM_ABS8              8\r
+#define R_ARM_SBREL32           9\r
+#define R_ARM_THM_PC22          10\r
+#define R_ARM_THM_PC8           11\r
+#define R_ARM_AMP_VCALL9        12\r
+#define R_ARM_SWI24             13\r
+#define R_ARM_THM_SWI8          14\r
+#define R_ARM_XPC25             15\r
+#define R_ARM_THM_XPC22         16\r
+#define R_ARM_COPY              20      /* Copy data from shared object. */\r
+#define R_ARM_GLOB_DAT          21      /* Set GOT entry to data address. */\r
+#define R_ARM_JUMP_SLOT         22      /* Set GOT entry to code address. */\r
+#define R_ARM_RELATIVE          23      /* Add load address of shared object. */\r
+#define R_ARM_GOTOFF            24      /* Add GOT-relative symbol address. */\r
+#define R_ARM_GOTPC             25      /* Add PC-relative GOT table address. */\r
+#define R_ARM_GOT32             26      /* Add PC-relative GOT offset. */\r
+#define R_ARM_PLT32             27      /* Add PC-relative PLT offset. */\r
+#define R_ARM_CALL              28\r
+#define R_ARM_JMP24             29\r
+#define R_ARM_MOVW_ABS_NC       43\r
+#define R_ARM_MOVT_ABS          44\r
+#define R_ARM_THM_MOVW_ABS_NC   47\r
+#define R_ARM_THM_MOVT_ABS      48\r
+\r
+// Block of PC-relative relocations added to work around gcc putting\r
+// object relocations in static executables.\r
+#define R_ARM_THM_JUMP24        30\r
+#define R_ARM_PREL31            42\r
+#define R_ARM_MOVW_PREL_NC      45\r
+#define R_ARM_MOVT_PREL         46\r
+#define R_ARM_THM_MOVW_PREL_NC  49\r
+#define R_ARM_THM_MOVT_PREL     50\r
+#define R_ARM_THM_JMP6          52\r
+#define R_ARM_THM_ALU_PREL_11_0 53\r
+#define R_ARM_THM_PC12          54\r
+#define R_ARM_REL32_NOI         56\r
+#define R_ARM_ALU_PC_G0_NC      57\r
+#define R_ARM_ALU_PC_G0         58\r
+#define R_ARM_ALU_PC_G1_NC      59\r
+#define R_ARM_ALU_PC_G1         60\r
+#define R_ARM_ALU_PC_G2         61\r
+#define R_ARM_LDR_PC_G1         62\r
+#define R_ARM_LDR_PC_G2         63\r
+#define R_ARM_LDRS_PC_G0        64\r
+#define R_ARM_LDRS_PC_G1        65\r
+#define R_ARM_LDRS_PC_G2        66\r
+#define R_ARM_LDC_PC_G0         67\r
+#define R_ARM_LDC_PC_G1         68\r
+#define R_ARM_LDC_PC_G2         69\r
+#define R_ARM_GOT_PREL          96\r
+#define R_ARM_THM_JUMP11        102\r
+#define R_ARM_THM_JUMP8         103\r
+#define R_ARM_TLS_GD32          104\r
+#define R_ARM_TLS_LDM32         105\r
+#define R_ARM_TLS_IE32          107\r
+\r
+#define R_ARM_THM_JUMP19        51\r
+#define R_ARM_GNU_VTENTRY       100\r
+#define R_ARM_GNU_VTINHERIT     101\r
+#define R_ARM_RSBREL32          250\r
+#define R_ARM_THM_RPC22         251\r
+#define R_ARM_RREL32            252\r
+#define R_ARM_RABS32            253\r
+#define R_ARM_RPC24             254\r
+#define R_ARM_RBASE             255\r
+\r
+\r
+\r
+/*      Name                    Value      Field        Calculation */\r
+#define R_IA_64_NONE            0       /* None */\r
+#define R_IA_64_IMM14           0x21    /* immediate14  S + A */\r
+#define R_IA_64_IMM22           0x22    /* immediate22  S + A */\r
+#define R_IA_64_IMM64           0x23    /* immediate64  S + A */\r
+#define R_IA_64_DIR32MSB        0x24    /* word32 MSB   S + A */\r
+#define R_IA_64_DIR32LSB        0x25    /* word32 LSB   S + A */\r
+#define R_IA_64_DIR64MSB        0x26    /* word64 MSB   S + A */\r
+#define R_IA_64_DIR64LSB        0x27    /* word64 LSB   S + A */\r
+#define R_IA_64_GPREL22         0x2a    /* immediate22  @gprel(S + A) */\r
+#define R_IA_64_GPREL64I        0x2b    /* immediate64  @gprel(S + A) */\r
+#define R_IA_64_GPREL32MSB      0x2c    /* word32 MSB   @gprel(S + A) */\r
+#define R_IA_64_GPREL32LSB      0x2d    /* word32 LSB   @gprel(S + A) */\r
+#define R_IA_64_GPREL64MSB      0x2e    /* word64 MSB   @gprel(S + A) */\r
+#define R_IA_64_GPREL64LSB      0x2f    /* word64 LSB   @gprel(S + A) */\r
+#define R_IA_64_LTOFF22         0x32    /* immediate22  @ltoff(S + A) */\r
+#define R_IA_64_LTOFF64I        0x33    /* immediate64  @ltoff(S + A) */\r
+#define R_IA_64_PLTOFF22        0x3a    /* immediate22  @pltoff(S + A) */\r
+#define R_IA_64_PLTOFF64I       0x3b    /* immediate64  @pltoff(S + A) */\r
+#define R_IA_64_PLTOFF64MSB     0x3e    /* word64 MSB   @pltoff(S + A) */\r
+#define R_IA_64_PLTOFF64LSB     0x3f    /* word64 LSB   @pltoff(S + A) */\r
+#define R_IA_64_FPTR64I         0x43    /* immediate64  @fptr(S + A) */\r
+#define R_IA_64_FPTR32MSB       0x44    /* word32 MSB   @fptr(S + A) */\r
+#define R_IA_64_FPTR32LSB       0x45    /* word32 LSB   @fptr(S + A) */\r
+#define R_IA_64_FPTR64MSB       0x46    /* word64 MSB   @fptr(S + A) */\r
+#define R_IA_64_FPTR64LSB       0x47    /* word64 LSB   @fptr(S + A) */\r
+#define R_IA_64_PCREL60B        0x48    /* immediate60 form1 S + A - P */\r
+#define R_IA_64_PCREL21B        0x49    /* immediate21 form1 S + A - P */\r
+#define R_IA_64_PCREL21M        0x4a    /* immediate21 form2 S + A - P */\r
+#define R_IA_64_PCREL21F        0x4b    /* immediate21 form3 S + A - P */\r
+#define R_IA_64_PCREL32MSB      0x4c    /* word32 MSB   S + A - P */\r
+#define R_IA_64_PCREL32LSB      0x4d    /* word32 LSB   S + A - P */\r
+#define R_IA_64_PCREL64MSB      0x4e    /* word64 MSB   S + A - P */\r
+#define R_IA_64_PCREL64LSB      0x4f    /* word64 LSB   S + A - P */\r
+#define R_IA_64_LTOFF_FPTR22    0x52    /* immediate22  @ltoff(@fptr(S + A)) */\r
+#define R_IA_64_LTOFF_FPTR64I   0x53    /* immediate64  @ltoff(@fptr(S + A)) */\r
+#define R_IA_64_LTOFF_FPTR32MSB 0x54    /* word32 MSB   @ltoff(@fptr(S + A)) */\r
+#define R_IA_64_LTOFF_FPTR32LSB 0x55    /* word32 LSB   @ltoff(@fptr(S + A)) */\r
+#define R_IA_64_LTOFF_FPTR64MSB 0x56    /* word64 MSB   @ltoff(@fptr(S + A)) */\r
+#define R_IA_64_LTOFF_FPTR64LSB 0x57    /* word64 LSB   @ltoff(@fptr(S + A)) */\r
+#define R_IA_64_SEGREL32MSB     0x5c    /* word32 MSB   @segrel(S + A) */\r
+#define R_IA_64_SEGREL32LSB     0x5d    /* word32 LSB   @segrel(S + A) */\r
+#define R_IA_64_SEGREL64MSB     0x5e    /* word64 MSB   @segrel(S + A) */\r
+#define R_IA_64_SEGREL64LSB     0x5f    /* word64 LSB   @segrel(S + A) */\r
+#define R_IA_64_SECREL32MSB     0x64    /* word32 MSB   @secrel(S + A) */\r
+#define R_IA_64_SECREL32LSB     0x65    /* word32 LSB   @secrel(S + A) */\r
+#define R_IA_64_SECREL64MSB     0x66    /* word64 MSB   @secrel(S + A) */\r
+#define R_IA_64_SECREL64LSB     0x67    /* word64 LSB   @secrel(S + A) */\r
+#define R_IA_64_REL32MSB        0x6c    /* word32 MSB   BD + A */\r
+#define R_IA_64_REL32LSB        0x6d    /* word32 LSB   BD + A */\r
+#define R_IA_64_REL64MSB        0x6e    /* word64 MSB   BD + A */\r
+#define R_IA_64_REL64LSB        0x6f    /* word64 LSB   BD + A */\r
+#define R_IA_64_LTV32MSB        0x74    /* word32 MSB   S + A */\r
+#define R_IA_64_LTV32LSB        0x75    /* word32 LSB   S + A */\r
+#define R_IA_64_LTV64MSB        0x76    /* word64 MSB   S + A */\r
+#define R_IA_64_LTV64LSB        0x77    /* word64 LSB   S + A */\r
+#define R_IA_64_PCREL21BI       0x79    /* immediate21 form1 S + A - P */\r
+#define R_IA_64_PCREL22         0x7a    /* immediate22  S + A - P */\r
+#define R_IA_64_PCREL64I        0x7b    /* immediate64  S + A - P */\r
+#define R_IA_64_IPLTMSB         0x80    /* function descriptor MSB special */\r
+#define R_IA_64_IPLTLSB         0x81    /* function descriptor LSB speciaal */\r
+#define R_IA_64_SUB             0x85    /* immediate64  A - S */\r
+#define R_IA_64_LTOFF22X        0x86    /* immediate22  special */\r
+#define R_IA_64_LDXMOV          0x87    /* immediate22  special */\r
+#define R_IA_64_TPREL14         0x91    /* imm14        @tprel(S + A) */\r
+#define R_IA_64_TPREL22         0x92    /* imm22        @tprel(S + A) */\r
+#define R_IA_64_TPREL64I        0x93    /* imm64        @tprel(S + A) */\r
+#define R_IA_64_TPREL64MSB      0x96    /* word64 MSB   @tprel(S + A) */\r
+#define R_IA_64_TPREL64LSB      0x97    /* word64 LSB   @tprel(S + A) */\r
+#define R_IA_64_LTOFF_TPREL22   0x9a    /* imm22        @ltoff(@tprel(S+A)) */\r
+#define R_IA_64_DTPMOD64MSB     0xa6    /* word64 MSB   @dtpmod(S + A) */\r
+#define R_IA_64_DTPMOD64LSB     0xa7    /* word64 LSB   @dtpmod(S + A) */\r
+#define R_IA_64_LTOFF_DTPMOD22  0xaa    /* imm22        @ltoff(@dtpmod(S+A)) */\r
+#define R_IA_64_DTPREL14        0xb1    /* imm14        @dtprel(S + A) */\r
+#define R_IA_64_DTPREL22        0xb2    /* imm22        @dtprel(S + A) */\r
+#define R_IA_64_DTPREL64I       0xb3    /* imm64        @dtprel(S + A) */\r
+#define R_IA_64_DTPREL32MSB     0xb4    /* word32 MSB   @dtprel(S + A) */\r
+#define R_IA_64_DTPREL32LSB     0xb5    /* word32 LSB   @dtprel(S + A) */\r
+#define R_IA_64_DTPREL64MSB     0xb6    /* word64 MSB   @dtprel(S + A) */\r
+#define R_IA_64_DTPREL64LSB     0xb7    /* word64 LSB   @dtprel(S + A) */\r
+#define R_IA_64_LTOFF_DTPREL22  0xba    /* imm22        @ltoff(@dtprel(S+A)) */\r
+\r
+#define R_PPC_NONE              0       /* No relocation. */\r
+#define R_PPC_ADDR32            1\r
+#define R_PPC_ADDR24            2\r
+#define R_PPC_ADDR16            3\r
+#define R_PPC_ADDR16_LO         4\r
+#define R_PPC_ADDR16_HI         5\r
+#define R_PPC_ADDR16_HA         6\r
+#define R_PPC_ADDR14            7\r
+#define R_PPC_ADDR14_BRTAKEN    8\r
+#define R_PPC_ADDR14_BRNTAKEN   9\r
+#define R_PPC_REL24             10\r
+#define R_PPC_REL14             11\r
+#define R_PPC_REL14_BRTAKEN     12\r
+#define R_PPC_REL14_BRNTAKEN    13\r
+#define R_PPC_GOT16             14\r
+#define R_PPC_GOT16_LO          15\r
+#define R_PPC_GOT16_HI          16\r
+#define R_PPC_GOT16_HA          17\r
+#define R_PPC_PLTREL24          18\r
+#define R_PPC_COPY              19\r
+#define R_PPC_GLOB_DAT          20\r
+#define R_PPC_JMP_SLOT          21\r
+#define R_PPC_RELATIVE          22\r
+#define R_PPC_LOCAL24PC         23\r
+#define R_PPC_UADDR32           24\r
+#define R_PPC_UADDR16           25\r
+#define R_PPC_REL32             26\r
+#define R_PPC_PLT32             27\r
+#define R_PPC_PLTREL32          28\r
+#define R_PPC_PLT16_LO          29\r
+#define R_PPC_PLT16_HI          30\r
+#define R_PPC_PLT16_HA          31\r
+#define R_PPC_SDAREL16          32\r
+#define R_PPC_SECTOFF           33\r
+#define R_PPC_SECTOFF_LO        34\r
+#define R_PPC_SECTOFF_HI        35\r
+#define R_PPC_SECTOFF_HA        36\r
+\r
+/*\r
+ * TLS relocations\r
+ */\r
+#define R_PPC_TLS               67\r
+#define R_PPC_DTPMOD32          68\r
+#define R_PPC_TPREL16           69\r
+#define R_PPC_TPREL16_LO        70\r
+#define R_PPC_TPREL16_HI        71\r
+#define R_PPC_TPREL16_HA        72\r
+#define R_PPC_TPREL32           73\r
+#define R_PPC_DTPREL16          74\r
+#define R_PPC_DTPREL16_LO       75\r
+#define R_PPC_DTPREL16_HI       76\r
+#define R_PPC_DTPREL16_HA       77\r
+#define R_PPC_DTPREL32          78\r
+#define R_PPC_GOT_TLSGD16       79\r
+#define R_PPC_GOT_TLSGD16_LO    80\r
+#define R_PPC_GOT_TLSGD16_HI    81\r
+#define R_PPC_GOT_TLSGD16_HA    82\r
+#define R_PPC_GOT_TLSLD16       83\r
+#define R_PPC_GOT_TLSLD16_LO    84\r
+#define R_PPC_GOT_TLSLD16_HI    85\r
+#define R_PPC_GOT_TLSLD16_HA    86\r
+#define R_PPC_GOT_TPREL16       87\r
+#define R_PPC_GOT_TPREL16_LO    88\r
+#define R_PPC_GOT_TPREL16_HI    89\r
+#define R_PPC_GOT_TPREL16_HA    90\r
+\r
+/*\r
+ * The remaining relocs are from the Embedded ELF ABI, and are not in the\r
+ *  SVR4 ELF ABI.\r
+ */\r
+\r
+#define R_PPC_EMB_NADDR32       101\r
+#define R_PPC_EMB_NADDR16       102\r
+#define R_PPC_EMB_NADDR16_LO    103\r
+#define R_PPC_EMB_NADDR16_HI    104\r
+#define R_PPC_EMB_NADDR16_HA    105\r
+#define R_PPC_EMB_SDAI16        106\r
+#define R_PPC_EMB_SDA2I16       107\r
+#define R_PPC_EMB_SDA2REL       108\r
+#define R_PPC_EMB_SDA21         109\r
+#define R_PPC_EMB_MRKREF        110\r
+#define R_PPC_EMB_RELSEC16      111\r
+#define R_PPC_EMB_RELST_LO      112\r
+#define R_PPC_EMB_RELST_HI      113\r
+#define R_PPC_EMB_RELST_HA      114\r
+#define R_PPC_EMB_BIT_FLD       115\r
+#define R_PPC_EMB_RELSDA        116\r
+\r
+#define R_SPARC_NONE            0\r
+#define R_SPARC_8               1\r
+#define R_SPARC_16              2\r
+#define R_SPARC_32              3\r
+#define R_SPARC_DISP8           4\r
+#define R_SPARC_DISP16          5\r
+#define R_SPARC_DISP32          6\r
+#define R_SPARC_WDISP30         7\r
+#define R_SPARC_WDISP22         8\r
+#define R_SPARC_HI22            9\r
+#define R_SPARC_22              10\r
+#define R_SPARC_13              11\r
+#define R_SPARC_LO10            12\r
+#define R_SPARC_GOT10           13\r
+#define R_SPARC_GOT13           14\r
+#define R_SPARC_GOT22           15\r
+#define R_SPARC_PC10            16\r
+#define R_SPARC_PC22            17\r
+#define R_SPARC_WPLT30          18\r
+#define R_SPARC_COPY            19\r
+#define R_SPARC_GLOB_DAT        20\r
+#define R_SPARC_JMP_SLOT        21\r
+#define R_SPARC_RELATIVE        22\r
+#define R_SPARC_UA32            23\r
+#define R_SPARC_PLT32           24\r
+#define R_SPARC_HIPLT22         25\r
+#define R_SPARC_LOPLT10         26\r
+#define R_SPARC_PCPLT32         27\r
+#define R_SPARC_PCPLT22         28\r
+#define R_SPARC_PCPLT10         29\r
+#define R_SPARC_10              30\r
+#define R_SPARC_11              31\r
+#define R_SPARC_64              32\r
+#define R_SPARC_OLO10           33\r
+#define R_SPARC_HH22            34\r
+#define R_SPARC_HM10            35\r
+#define R_SPARC_LM22            36\r
+#define R_SPARC_PC_HH22         37\r
+#define R_SPARC_PC_HM10         38\r
+#define R_SPARC_PC_LM22         39\r
+#define R_SPARC_WDISP16         40\r
+#define R_SPARC_WDISP19         41\r
+#define R_SPARC_GLOB_JMP        42\r
+#define R_SPARC_7               43\r
+#define R_SPARC_5               44\r
+#define R_SPARC_6               45\r
+#define R_SPARC_DISP64          46\r
+#define R_SPARC_PLT64           47\r
+#define R_SPARC_HIX22           48\r
+#define R_SPARC_LOX10           49\r
+#define R_SPARC_H44             50\r
+#define R_SPARC_M44             51\r
+#define R_SPARC_L44             52\r
+#define R_SPARC_REGISTER        53\r
+#define R_SPARC_UA64            54\r
+#define R_SPARC_UA16            55\r
+#define R_SPARC_TLS_GD_HI22     56\r
+#define R_SPARC_TLS_GD_LO10     57\r
+#define R_SPARC_TLS_GD_ADD      58\r
+#define R_SPARC_TLS_GD_CALL     59\r
+#define R_SPARC_TLS_LDM_HI22    60\r
+#define R_SPARC_TLS_LDM_LO10    61\r
+#define R_SPARC_TLS_LDM_ADD     62\r
+#define R_SPARC_TLS_LDM_CALL    63\r
+#define R_SPARC_TLS_LDO_HIX22   64\r
+#define R_SPARC_TLS_LDO_LOX10   65\r
+#define R_SPARC_TLS_LDO_ADD     66\r
+#define R_SPARC_TLS_IE_HI22     67\r
+#define R_SPARC_TLS_IE_LO10     68\r
+#define R_SPARC_TLS_IE_LD       69\r
+#define R_SPARC_TLS_IE_LDX      70\r
+#define R_SPARC_TLS_IE_ADD      71\r
+#define R_SPARC_TLS_LE_HIX22    72\r
+#define R_SPARC_TLS_LE_LOX10    73\r
+#define R_SPARC_TLS_DTPMOD32    74\r
+#define R_SPARC_TLS_DTPMOD64    75\r
+#define R_SPARC_TLS_DTPOFF32    76\r
+#define R_SPARC_TLS_DTPOFF64    77\r
+#define R_SPARC_TLS_TPOFF32     78\r
+#define R_SPARC_TLS_TPOFF64     79\r
+\r
+#define R_X86_64_NONE           0       /* No relocation. */\r
+#define R_X86_64_64             1       /* Add 64 bit symbol value. */\r
+#define R_X86_64_PC32           2       /* PC-relative 32 bit signed sym value. */\r
+#define R_X86_64_GOT32          3       /* PC-relative 32 bit GOT offset. */\r
+#define R_X86_64_PLT32          4       /* PC-relative 32 bit PLT offset. */\r
+#define R_X86_64_COPY           5       /* Copy data from shared object. */\r
+#define R_X86_64_GLOB_DAT       6       /* Set GOT entry to data address. */\r
+#define R_X86_64_JMP_SLOT       7       /* Set GOT entry to code address. */\r
+#define R_X86_64_RELATIVE       8       /* Add load address of shared object. */\r
+#define R_X86_64_GOTPCREL       9       /* Add 32 bit signed pcrel offset to GOT. */\r
+#define R_X86_64_32             10      /* Add 32 bit zero extended symbol value */\r
+#define R_X86_64_32S            11      /* Add 32 bit sign extended symbol value */\r
+#define R_X86_64_16             12      /* Add 16 bit zero extended symbol value */\r
+#define R_X86_64_PC16           13      /* Add 16 bit signed extended pc relative symbol value */\r
+#define R_X86_64_8              14      /* Add 8 bit zero extended symbol value */\r
+#define R_X86_64_PC8            15      /* Add 8 bit signed extended pc relative symbol value */\r
+#define R_X86_64_DTPMOD64       16      /* ID of module containing symbol */\r
+#define R_X86_64_DTPOFF64       17      /* Offset in TLS block */\r
+#define R_X86_64_TPOFF64        18      /* Offset in static TLS block */\r
+#define R_X86_64_TLSGD          19      /* PC relative offset to GD GOT entry */\r
+#define R_X86_64_TLSLD          20      /* PC relative offset to LD GOT entry */\r
+#define R_X86_64_DTPOFF32       21      /* Offset in TLS block */\r
+#define R_X86_64_GOTTPOFF       22      /* PC relative offset to IE GOT entry */\r
+#define R_X86_64_TPOFF32        23      /* Offset in static TLS block */\r
+\r
+\r
+#endif /* !_SYS_ELF_COMMON_H_ */\r