summaryrefslogtreecommitdiffstats
path: root/sbe/image
diff options
context:
space:
mode:
authorMartin Peschke <mpeschke@de.ibm.com>2016-01-05 12:33:52 +0100
committerMartin Peschke <mpeschke@de.ibm.com>2016-01-21 06:55:10 -0600
commit7c6b4af8ea3632e9f8d115d31302626bc9c76cd6 (patch)
tree9b56c03a5da4a0a099325a5e4d29eaf1359346dd /sbe/image
parent1366580dec312e84acfaf85dd8397abf4e328d36 (diff)
downloadtalos-sbe-7c6b4af8ea3632e9f8d115d31302626bc9c76cd6.tar.gz
talos-sbe-7c6b4af8ea3632e9f8d115d31302626bc9c76cd6.zip
P9-XIP: SBE IPL image build now shares P9-XIP code with ekb repo
All users of the P9-XIP headers and code have been changed to use the P9-XIP code imported from ekb. The SBE IPL Image build flow has been adapted to the new location of the P9-XIP code. Some renaming was needed (SBE XIP -> P9-XIP), too. Change-Id: Ia68cfe7c3599f8b4364778158731f91097ea466f Reviewed-on: http://gfw160.aus.stglabs.ibm.com:8080/gerrit/23025 Tested-by: Jenkins Server Reviewed-by: Martin Peschke <mpeschke@de.ibm.com>
Diffstat (limited to 'sbe/image')
-rw-r--r--sbe/image/Makefile37
-rw-r--r--sbe/image/base_loader.c6
-rw-r--r--sbe/image/base_main.C1
-rw-r--r--sbe/image/base_ppe_header.S66
-rw-r--r--sbe/image/base_sbe_fixed.S2
-rw-r--r--sbe/image/fapi_sbe_common.H47
-rw-r--r--sbe/image/img_defs.mk10
-rw-r--r--sbe/image/sbe_common.H22
-rw-r--r--sbe/image/sbe_loader.c6
-rw-r--r--sbe/image/sbe_xip_image.c2460
-rw-r--r--sbe/image/sbe_xip_image.h1724
11 files changed, 82 insertions, 4299 deletions
diff --git a/sbe/image/Makefile b/sbe/image/Makefile
index 39f84e83..22ae0657 100644
--- a/sbe/image/Makefile
+++ b/sbe/image/Makefile
@@ -93,7 +93,9 @@ LIB_DIRS += -L$(OBJDIR)/nest
NESTLIB := $(OBJDIR)/nest/libnest.a
LLIBS += -lnest
-SBE_TOOLS := $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(TOOLS_IMAGE_DIR)/sbe_default_tool
+SBE_TOOLS := $(TOOLS_IMAGE_DIR)/sbe_default_tool
+
+P9_XIP_TOOL := $(P9_XIP_BINDIR)/p9_xip_tool
LINK_OBJS = $(OBJS) $(SBEFWLIB) $(PKLIB) $(FAPI2LIB) $(CACHELIB) $(CORELIB) $(HWPLIB) $(P2PLIB) $(PERVLIB) $(NESTLIB)
@@ -175,19 +177,19 @@ endif
all: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(OBJDIR)/$(IMAGE_SBE_NAME).bin $(OBJDIR)/$(IMAGE_LOADER_NAME).bin $(SBE_TOOLS) normalize defaultset $(OBJDIR)/fixed.bin appendbase appendloader add_entry_offset add_entry_address_sbe symbols tracehash
-add_entry_offset: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin set entry_offset 0x`nm $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out | grep sbe_loader | cut -f 1 -d " "`
+add_entry_offset: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin set entry_offset 0x`nm $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out | grep sbe_loader | cut -f 1 -d " "`
-add_entry_address_sbe: $(OBJDIR)/$(IMAGE_LOADER_NAME).out
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin set entry_address_sbe 0x`nm $(OBJDIR)/$(IMAGE_LOADER_NAME).out | grep base_loader | cut -f 1 -d " "`
+add_entry_address_sbe: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_LOADER_NAME).out
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin set entry_address_sbe 0x`nm $(OBJDIR)/$(IMAGE_LOADER_NAME).out | grep base_loader | cut -f 1 -d " "`
symbols: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out $(OBJDIR)/$(IMAGE_LOADER_NAME).out $(OBJDIR)/$(IMAGE_SBE_NAME).out
$(NM) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out > $(OBJDIR)/$(SBE_SYMBOLS_NAME)
$(NM) $(OBJDIR)/$(IMAGE_LOADER_NAME).out >> $(OBJDIR)/$(SBE_SYMBOLS_NAME)
$(NM) $(OBJDIR)/$(IMAGE_SBE_NAME).out >> $(OBJDIR)/$(SBE_SYMBOLS_NAME)
-seeprom: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(SBE_TOOLS) normalize defaultset $(OBJDIR)/fixed.bin
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin report > $(OBJDIR)/$(IMAGE_SEEPROM_NAME).rpt
+seeprom: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(SBE_TOOLS) normalize defaultset $(OBJDIR)/fixed.bin
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin report > $(OBJDIR)/$(IMAGE_SEEPROM_NAME).rpt
# Create build Info file
buildInfo:
@@ -283,8 +285,12 @@ endif
$(SBE_TOOLS):
$(MAKE) -C $(TOOLS_IMAGE_DIR) -f Makefile
-normalize: $(SBE_TOOLS) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin normalize
+# Build the P9-XIP Tool
+$(P9_XIP_TOOL):
+ $(MAKE) -I $(P9_XIP_SRCDIR) -C $(P9_XIP_SRCDIR) -f Makefile #$(P9_XIP_TOOL)
+
+normalize: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin normalize
defaultset: $(SBE_TOOLS) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin normalize
$(TOOLS_IMAGE_DIR)/ppeSetFixed.pl $(TOOLS_IMAGE_DIR) $(BASE_OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(IMPORT_XML_DIR)/attribute_info/p9_sbe_attributes.xml $(ATTRFILES)
@@ -311,17 +317,17 @@ $(FAPI_RC): $(TOOLS_ATTR_DIR)/parseErrorInfo.pl $(ERROR_XML_FILES)
# The above is commented out as the current version of make produces errors
# This was taken from the P8 SBE Makefile which worked.
-$(OBJDIR)/fixed.bin: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin extract .fixed $(BASE_OBJDIR)/fixed.bin
+$(OBJDIR)/fixed.bin: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin extract .fixed $(BASE_OBJDIR)/fixed.bin
-appendbase: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(OBJDIR)/$(IMAGE_SBE_NAME).bin
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin append .base $(OBJDIR)/$(IMAGE_SBE_NAME).bin
+appendbase: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(OBJDIR)/$(IMAGE_SBE_NAME).bin
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin append .base $(OBJDIR)/$(IMAGE_SBE_NAME).bin
-appendloader: $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(OBJDIR)/$(IMAGE_LOADER_NAME).bin
- $(TOOLS_IMAGE_DIR)/sbe_xip_tool $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin append .baseloader $(OBJDIR)/$(IMAGE_LOADER_NAME).bin
+appendloader: $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin $(OBJDIR)/$(IMAGE_LOADER_NAME).bin
+ $(P9_XIP_TOOL) $(OBJDIR)/$(IMAGE_SEEPROM_NAME).bin append .baseloader $(OBJDIR)/$(IMAGE_LOADER_NAME).bin
#/afs/bb/proj/cte/tools/ppetools/prod/powerpc-eabi/bin/objcopy -O binary --only-section=.fixed $(OBJDIR)/$(IMAGE_SEEPROM_NAME).out $(OBJDIR)/fixed.bin
@@ -339,6 +345,7 @@ clean:
rm -fr $(OBJDIR)
rm -f $(TOP-FIXED-HEADERS)
$(MAKE) -C $(TOOLS_IMAGE_DIR) -f Makefile clean
+ $(MAKE) -C $(P9_XIP_SRCDIR) -f Makefile clean
rm -f *.dump
rm -f hwp_return_codes.H hwp_error_info.H hwp_ffdc_classes.H collect_reg_ffdc.C set_sbe_error.H sbe_build_info.H
rm -f $(GEN-CREATEATTRGETSETMACROS)
diff --git a/sbe/image/base_loader.c b/sbe/image/base_loader.c
index ce47a903..0e67a482 100644
--- a/sbe/image/base_loader.c
+++ b/sbe/image/base_loader.c
@@ -1,4 +1,4 @@
-#include "sbe_xip_image.h"
+#include "p9_xip_image.h"
#include "sbetrace.H"
int32_t base_loader();
@@ -8,11 +8,11 @@ int32_t base_loader() {
int32_t rc = 0;
- SbeXipHeader *hdr = 0;//getXipHdr();
+ P9XipHeader *hdr = 0;//getXipHdr();
uint32_t idx;
- for(idx = 0; idx < SBE_XIP_SECTIONS; idx++) {
+ for(idx = 0; idx < P9_XIP_SECTIONS; idx++) {
hdr++;
}
diff --git a/sbe/image/base_main.C b/sbe/image/base_main.C
index 5ade739c..97a9633b 100644
--- a/sbe/image/base_main.C
+++ b/sbe/image/base_main.C
@@ -13,7 +13,6 @@ extern "C" {
#include "pk.h"
#include "pk_trace.h"
#include "base_ppe_main.h"
-#include "sbe_xip_image.h"
}
#define KERNEL_STACK_SIZE 256
#define MAIN_THREAD_STACK_SIZE 256
diff --git a/sbe/image/base_ppe_header.S b/sbe/image/base_ppe_header.S
index 0f56c532..92fb606b 100644
--- a/sbe/image/base_ppe_header.S
+++ b/sbe/image/base_ppe_header.S
@@ -7,9 +7,9 @@
/// \file base_ppe_header.S
/// \brief code to create header, toc, strings, fixed and fixed_toc sections
///
-/// function SbeXipHeader creates header section, function .proc_sbe_fixed
+/// function P9XipHeader creates header section, function .proc_sbe_fixed
/// creates fixed, fixed_toc sections
-#include "sbe_xip_image.h"
+#include "p9_xip_image.h"
#include "proc_sbe_fixed.H"
@@ -62,9 +62,9 @@
.endm
-// .macro SbeXipHeader, magic, link_address, entry_point, image_size
+// .macro P9XipHeader, magic, link_address, entry_point, image_size
- .macro SbeXipSection, s:req, alignment=1, empty=0
+ .macro P9XipSection, s:req, alignment=1, empty=0
__\s\()_section:
.if \empty
.long 0
@@ -78,7 +78,7 @@ __\s\()_section:
.endm
- .macro SbeXipHeader, magic, link_address, entry_point, image_size
+ .macro P9XipHeader, magic, link_address, entry_point, image_size
.section .header, "a", @progbits
@@ -98,29 +98,29 @@ __entry_address_sbe:
__header_64_reserved:
.quad 0, 0, 0, 0
- .xip_toc magic, SBE_XIP_UINT64, __magic
- .xip_toc entry_offset, SBE_XIP_UINT64, __entry_offset
- .xip_toc link_address, SBE_XIP_UINT64, __link_address
- .xip_toc entry_address_sbe, SBE_XIP_UINT64, __entry_address_sbe
+ .xip_toc magic, P9_XIP_UINT64, __magic
+ .xip_toc entry_offset, P9_XIP_UINT64, __entry_offset
+ .xip_toc link_address, P9_XIP_UINT64, __link_address
+ .xip_toc entry_address_sbe, P9_XIP_UINT64, __entry_address_sbe
//////////////////////////////////////////////////////////////////////
// Section Table - 8-byte aligned; 16 entries; Not TOC-Indexed
//////////////////////////////////////////////////////////////////////
- SbeXipSection header
- SbeXipSection fixed, 8
- SbeXipSection fixed_toc, 8
- SbeXipSection loader_text, 4
- SbeXipSection loader_data, 8
- SbeXipSection text, 4
- SbeXipSection data, 8
- SbeXipSection toc, 4
- SbeXipSection strings
- SbeXipSection base, 4, empty=1
- SbeXipSection baseloader, 8, empty=1
- SbeXipSection overlay, 8, empty=1
- SbeXipSection rings, 8, empty=1
- SbeXipSection hbbl, 8, empty=1
+ P9XipSection header
+ P9XipSection fixed, 8
+ P9XipSection fixed_toc, 8
+ P9XipSection loader_text, 4
+ P9XipSection loader_data, 8
+ P9XipSection text, 4
+ P9XipSection data, 8
+ P9XipSection toc, 4
+ P9XipSection strings
+ P9XipSection base, 4, empty=1
+ P9XipSection baseloader, 8, empty=1
+ P9XipSection overlay, 8, empty=1
+ P9XipSection rings, 8, empty=1
+ P9XipSection hbbl, 8, empty=1
//////////////////////////////////////////////////////////////////////
@@ -136,9 +136,9 @@ __build_time:
__header_32_reserved:
.long 0, 0, 0, 0, 0
- .xip_toc image_size, SBE_XIP_UINT32, __image_size
- .xip_toc build_date, SBE_XIP_UINT32, __build_date
- .xip_toc build_time, SBE_XIP_UINT32, __build_time
+ .xip_toc image_size, P9_XIP_UINT32, __image_size
+ .xip_toc build_date, P9_XIP_UINT32, __build_date
+ .xip_toc build_time, P9_XIP_UINT32, __build_time
//////////////////////////////////////////////////////////////////////
@@ -146,7 +146,7 @@ __header_32_reserved:
//////////////////////////////////////////////////////////////////////
__header_version:
- .byte SBE_XIP_HEADER_VERSION
+ .byte P9_XIP_HEADER_VERSION
__toc_normalized:
.byte 0
__toc_sorted:
@@ -154,9 +154,9 @@ __toc_sorted:
__header_8_reserved:
.byte 0, 0, 0, 0, 0
- .xip_toc header_version, SBE_XIP_UINT8, __header_version
- .xip_toc toc_normalized, SBE_XIP_UINT8, __toc_normalized
- .xip_toc toc_sorted, SBE_XIP_UINT8, __toc_sorted
+ .xip_toc header_version, P9_XIP_UINT8, __header_version
+ .xip_toc toc_normalized, P9_XIP_UINT8, __toc_normalized
+ .xip_toc toc_sorted, P9_XIP_UINT8, __toc_sorted
//////////////////////////////////////////////////////////////////////
@@ -170,8 +170,8 @@ __build_host:
__header_string_reserved:
.space 24, 0
- .xip_toc build_user, SBE_XIP_STRING, __build_user
- .xip_toc build_host, SBE_XIP_STRING, __build_host
+ .xip_toc build_user, P9_XIP_STRING, __build_user
+ .xip_toc build_host, P9_XIP_STRING, __build_host
.endm
@@ -186,7 +186,7 @@ __header_string_reserved:
.section .strings, "aS", @progbits
..set_default_space IMAGE_SPACE_SEEPROM
- SbeXipHeader SBE_SEEPROM_MAGIC, 0xFFF00000, 0xFFF00C78, _seeprom_size
+ P9XipHeader P9_SEEPROM_MAGIC, 0xFFF00000, 0xFFF00C78, _seeprom_size
// Create the .fixed section
.proc_sbe_fixed_system
diff --git a/sbe/image/base_sbe_fixed.S b/sbe/image/base_sbe_fixed.S
index 496b7e82..eb88482f 100644
--- a/sbe/image/base_sbe_fixed.S
+++ b/sbe/image/base_sbe_fixed.S
@@ -1,7 +1,7 @@
/// \file sbefixed.S
/// \brief code to generated fixed section in pibmem image
///
-#include "sbe_xip_image.h"
+#include "p9_xip_image.h"
#include "proc_sbe_fixed.H"
diff --git a/sbe/image/fapi_sbe_common.H b/sbe/image/fapi_sbe_common.H
deleted file mode 100644
index 29376c81..00000000
--- a/sbe/image/fapi_sbe_common.H
+++ /dev/null
@@ -1,47 +0,0 @@
-//-----------------------------------------------------------------------------
-// *! (C) Copyright International Business Machines Corp. 2014
-// *! All Rights Reserved -- Property of IBM
-// *! *** IBM Confidential ***
-//-----------------------------------------------------------------------------
-
-/// \file fapi_sbe_common.H
-/// \brief provides several preprocessor macros used functions in fixed secion.
-///
-/// Several preprocessor macros are required to have different definitions in
-/// C, C++ and SBE assembly procedures. These common forms are collected here.
-
-#ifndef __FAPI_SBE_COMMON_H
-#define __FAPI_SBE_COMMON_H
-
-/// Several preprocessor macros are required to have different definitions in
-/// C, C++ and SBE assembly procedures. These common forms are collected here.
-
-#if defined __ASSEMBLER__
-
-#define CONST_UINT8_T(name, expr) .set name, (expr)
-#define CONST_UINT32_T(name, expr) .set name, (expr)
-#define CONST_UINT64_T(name, expr) .set name, (expr)
-
-#define ULL(x) x
-
-#elif defined __cplusplus
-
-#include <stdint.h>
-
-#define CONST_UINT8_T(name, expr) const uint8_t name = (expr);
-#define CONST_UINT32_T(name, expr) const uint32_t name = (expr);
-#define CONST_UINT64_T(name, expr) const uint64_t name = (expr);
-
-#define ULL(x) x##ull
-
-#else // C code
-
-// CONST_UINT[8,3,64]_T() can't be used in C code/headers; Use
-//
-// #define <symbol> <value> [ or ULL(<value>) for 64-bit constants
-
-#define ULL(x) x##ull
-
-#endif // __ASSEMBLER__
-
-#endif // __FAPI_SBE_COMMON_H
diff --git a/sbe/image/img_defs.mk b/sbe/image/img_defs.mk
index 5ce99c80..dca2b5cd 100644
--- a/sbe/image/img_defs.mk
+++ b/sbe/image/img_defs.mk
@@ -70,8 +70,16 @@ ifndef HWPLIB_SRCDIR
export HWPLIB_SRCDIR = $(abspath ../../import/chips/p9/procedures/hwp/lib)
endif
+ifndef P9_XIP_SRCDIR
+export P9_XIP_SRCDIR = $(abspath ../../import/chips/p9/xip)
+endif
+
+ifndef P9_XIP_BINDIR
+export P9_XIP_BINDIR = $(P9_XIP_SRCDIR)/bin
+endif
+
ifndef IMG_INCLUDES
-export IMG_INCLUDES = -I$(IMAGE_SRCDIR) -I$(CACHE_SRCDIR) -I$(CORE_SRCDIR) -I$(PERV_SRCDIR) -I$(NEST_SRCDIR)
+export IMG_INCLUDES = -I$(P9_XIP_SRCDIR) -I$(IMAGE_SRCDIR) -I$(CACHE_SRCDIR) -I$(CORE_SRCDIR) -I$(PERV_SRCDIR) -I$(NEST_SRCDIR)
endif
ifndef BASE_OBJDIR
diff --git a/sbe/image/sbe_common.H b/sbe/image/sbe_common.H
index 4e48339b..c9745afb 100644
--- a/sbe/image/sbe_common.H
+++ b/sbe/image/sbe_common.H
@@ -11,7 +11,7 @@
#include "sbe_link.H"
-#include "sbe_xip_image.h"
+#include "p9_xip_image.h"
//#include "sbe_xip_header.H"
/// Macros for generating the .fixed section
@@ -24,7 +24,7 @@
/// In assembler each invocation also creates space in the .fixed_toc section
/// for a fixed TOC entry. Unlike the normal TOC no data is generated for
/// .fixed_toc by the data declaration. Instead, the fixed TOC table is
-/// filled in during image normalization by normalizeToc (sbe_xip_image.c)
+/// filled in during image normalization by normalizeToc (p9_xip_image.c)
/// which requires that there be one and only one fixed TOC entery allocated
/// per TOC entry referencing the .fixed section. This means that in the
/// current implementation it is not possible to create .fixed_toc entries
@@ -39,7 +39,7 @@
.byte 0
.endr
- .xip_toc \symbol, SBE_XIP_UINT8, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_UINT8, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -54,7 +54,7 @@
.byte 0
.endr
- .xip_toc \symbol, SBE_XIP_INT8, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_INT8, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -71,7 +71,7 @@
.byte 0,0
.endr
- .xip_toc \symbol, SBE_XIP_UINT16, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_UINT16, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -88,7 +88,7 @@
.byte 0,0
.endr
- .xip_toc \symbol, SBE_XIP_INT16, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_INT16, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -105,7 +105,7 @@
.long 0
.endr
- .xip_toc \symbol, SBE_XIP_UINT32, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_UINT32, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -122,7 +122,7 @@
.long 0
.endr
- .xip_toc \symbol, SBE_XIP_INT32, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_INT32, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -138,7 +138,7 @@
.quad 0
.endr
- .xip_toc \symbol, SBE_XIP_UINT64, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_UINT64, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -154,7 +154,7 @@
.quad 0
.endr
- .xip_toc \symbol, SBE_XIP_INT64, \symbol, ((\tnumber)*(\elements))
+ .xip_toc \symbol, P9_XIP_INT64, \symbol, ((\tnumber)*(\elements))
.pushsection .fixed_toc
.space 8
@@ -167,7 +167,7 @@
\symbol\():
.quadia (\space), (\address)
- .xip_toc \symbol, SBE_XIP_UINT64, \symbol
+ .xip_toc \symbol, P9_XIP_UINT64, \symbol
.pushsection .fixed_toc
.space 8
diff --git a/sbe/image/sbe_loader.c b/sbe/image/sbe_loader.c
index 9f944615..184ead21 100644
--- a/sbe/image/sbe_loader.c
+++ b/sbe/image/sbe_loader.c
@@ -1,4 +1,4 @@
-#include "sbe_xip_image.h"
+#include "p9_xip_image.h"
int32_t sbe_loader() __attribute__ ((section (".loader_text")));
@@ -7,11 +7,11 @@ int32_t sbe_loader() {
int32_t rc = 0;
- SbeXipHeader *hdr = 0;//getXipHdr();
+ P9XipHeader *hdr = 0;//getXipHdr();
uint32_t idx;
- for(idx = 0; idx < SBE_XIP_SECTIONS; idx++) {
+ for(idx = 0; idx < P9_XIP_SECTIONS; idx++) {
hdr++;
}
diff --git a/sbe/image/sbe_xip_image.c b/sbe/image/sbe_xip_image.c
deleted file mode 100644
index d800650b..00000000
--- a/sbe/image/sbe_xip_image.c
+++ /dev/null
@@ -1,2460 +0,0 @@
-/// \file sbe_xip_image.c
-/// \brief APIs for validating, normalizing, searching and manipulating
-/// SBE-XIP images.
-///
-/// The background, APIs and implementation details are documented in the
-/// document "SBE-XIP Binary format" currently available at this link:
-///
-/// - https://mcdoc.boeblingen.de.ibm.com/out/out.ViewDocument.php?documentid=2678
-///
-/// \bug The sbe_xip_validate() API should be carefully reviewed to ensure
-/// that validating even a corrupt image can not lead to a segfault, i.e., to
-/// ensure that no memory outside of the putative bounds of the image is ever
-/// referenced during validation.
-
-#ifndef PLIC_MODULE
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#endif // PLIC_MODULE
-
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <string.h>
-#include "sbe_xip_image.h"
-
-
-////////////////////////////////////////////////////////////////////////////
-// Local Functions
-////////////////////////////////////////////////////////////////////////////
-
-#ifdef DEBUG_SBE_XIP_IMAGE
-
-// Debugging support, normally disabled. All of the formatted I/O you see in
-// the code is effectively under this switch.
-
-#ifdef __FAPI
-
-#include "fapi.H"
-#define fprintf(stream, ...) FAPI_ERR(__VA_ARGS__)
-#define printf(...) FAPI_INF(__VA_ARGS__)
-#define TRACE_NEWLINE ""
-
-#else // __FAPI
-
-#include <stdio.h>
-#define TRACE_NEWLINE "\n"
-
-#endif // __FAPI
-
-// Portable formatting of uint64_t. The ISO C99 standard requires
-// __STDC_FORMAT_MACROS to be defined in order for PRIx64 etc. to be defined.
-
-#define __STDC_FORMAT_MACROS
-#include <inttypes.h>
-
-#define F0x016llx "0x%016" PRIx64
-#define F0x012llx "0x%012" PRIx64
-
-XIP_STATIC SBE_XIP_ERROR_STRINGS(sbe_xip_error_strings);
-
-#define TRACE_ERROR(x) \
- ({ \
- fprintf(stderr, "%s:%d : Returning error code %d : %s" TRACE_NEWLINE, \
- __FILE__, __LINE__, (x), \
- SBE_XIP_ERROR_STRING(sbe_xip_error_strings, (x))); \
- (x); \
- })
-
-#define TRACE_ERRORX(x, ...) \
- ({ \
- TRACE_ERROR(x); \
- fprintf(stderr, ##__VA_ARGS__); \
- (x); \
- })
-
-
-// Uncomment these if required for debugging, otherwise we get warnings from
-// GCC as they are not otherwise used.
-
-#if 0
-
-XIP_STATIC uint32_t xipRevLe32(const uint32_t i_x);
-
-XIP_STATIC SBE_XIP_TYPE_STRINGS(type_strings);
-
-XIP_STATIC void
-dumpToc(int index, SbeXipToc* toc)
-{
- printf("TOC entry %d @ %p\n"
- " iv_id = 0x%08x\n"
- " iv_data = 0x%08x\n"
- " iv_type = %s\n"
- " iv_section = 0x%02x\n"
- " iv_elements = %d\n",
- index, toc,
- xipRevLe32(toc->iv_id),
- xipRevLe32(toc->iv_data),
- SBE_XIP_TYPE_STRING(type_strings, toc->iv_type),
- toc->iv_section,
- toc->iv_elements);
-}
-
-#endif
-
-#if 0
-
-XIP_STATIC void
-dumpItem(SbeXipItem* item)
-{
- printf("SbeXipItem @ %p\n"
- " iv_toc = %p\n"
- " iv_address = " F0x016llx "\n"
- " iv_imageData = %p\n"
- " iv_id = %s\n"
- " iv_type = %s\n"
- " iv_elements = %d\n",
- item,
- item->iv_toc,
- item->iv_address,
- item->iv_imageData,
- item->iv_id,
- SBE_XIP_TYPE_STRING(type_strings, item->iv_type),
- item->iv_elements);
- dumpToc(-1, item->iv_toc);
-}
-
-#endif /* 0 */
-
-XIP_STATIC void
-dumpSectionTable(const void* i_image)
-{
- int i, rc;
- SbeXipSection section;
-
- printf("Section table dump of image @ %p\n"
- " Entry Offset Size\n"
- "-------------------------------\n",
- i_image);
-
- for (i = 0; i < SBE_XIP_SECTIONS; i++) {
- rc = sbe_xip_get_section(i_image, i, &section);
- if (rc) {
- printf(">>> dumpSectionTable got error at entry %d : %s\n",
- i, SBE_XIP_ERROR_STRING(sbe_xip_error_strings, rc));
- break;
- }
- printf("%7d 0x%08x 0x%08x\n",
- i, section.iv_offset, section.iv_size);
- }
-}
-
-#else
-
-#define TRACE_ERROR(x) (x)
-#define TRACE_ERRORX(x, ...) (x)
-#define dumpToc(...)
-#define dumpItem(...)
-#define dumpSectionTable(...)
-
-#endif
-
-
-// Note: For maximum flexibility we provide private versions of
-// endian-conversion routines rather than counting on a system-specific header
-// to provide these.
-
-/// Byte-reverse a 16-bit integer if on a little-endian machine
-
-XIP_STATIC uint16_t
-xipRevLe16(const uint16_t i_x)
-{
- uint16_t rx;
-
-#ifndef _BIG_ENDIAN
- uint8_t *pix = (uint8_t*)(&i_x);
- uint8_t *prx = (uint8_t*)(&rx);
-
- prx[0] = pix[1];
- prx[1] = pix[0];
-#else
- rx = i_x;
-#endif
-
- return rx;
-}
-
-
-/// Byte-reverse a 32-bit integer if on a little-endian machine
-
-XIP_STATIC uint32_t
-xipRevLe32(const uint32_t i_x)
-{
- uint32_t rx;
-
-#ifndef _BIG_ENDIAN
- uint8_t *pix = (uint8_t*)(&i_x);
- uint8_t *prx = (uint8_t*)(&rx);
-
- prx[0] = pix[3];
- prx[1] = pix[2];
- prx[2] = pix[1];
- prx[3] = pix[0];
-#else
- rx = i_x;
-#endif
-
- return rx;
-}
-
-
-/// Byte-reverse a 64-bit integer if on a little-endian machine
-
-XIP_STATIC uint64_t
-xipRevLe64(const uint64_t i_x)
-{
- uint64_t rx;
-
-#ifndef _BIG_ENDIAN
- uint8_t *pix = (uint8_t*)(&i_x);
- uint8_t *prx = (uint8_t*)(&rx);
-
- prx[0] = pix[7];
- prx[1] = pix[6];
- prx[2] = pix[5];
- prx[3] = pix[4];
- prx[4] = pix[3];
- prx[5] = pix[2];
- prx[6] = pix[1];
- prx[7] = pix[0];
-#else
- rx = i_x;
-#endif
-
- return rx;
-}
-
-
-/// What is the image link address?
-
-XIP_STATIC uint64_t
-xipLinkAddress(const void* i_image)
-{
- return xipRevLe64(((SbeXipHeader*)i_image)->iv_linkAddress);
-}
-
-
-/// What is the image size?
-
-XIP_STATIC uint32_t
-xipImageSize(const void* i_image)
-{
- return xipRevLe32(((SbeXipHeader*)i_image)->iv_imageSize);
-}
-
-
-/// Set the image size
-
-XIP_STATIC void
-xipSetImageSize(void* io_image, const size_t i_size)
-{
- ((SbeXipHeader*)io_image)->iv_imageSize = xipRevLe32(i_size);
-}
-
-
-/// Re-establish the required final alignment
-
-XIP_STATIC void
-xipFinalAlignment(void* io_image)
-{
- uint32_t size;
-
- size = xipImageSize(io_image);
-
- if ((size % SBE_XIP_FINAL_ALIGNMENT) != 0) {
- xipSetImageSize(io_image,
- size + (SBE_XIP_FINAL_ALIGNMENT -
- (size % SBE_XIP_FINAL_ALIGNMENT)));
- }
-}
-
-
-/// Compute a host address from an image address and offset
-
-XIP_STATIC void*
-xipHostAddressFromOffset(const void* i_image, const uint32_t offset)
-{
- return (void*)((unsigned long)i_image + offset);
-}
-
-
-/// Convert a IMAGE address to a host address
-
-XIP_STATIC void*
-xipImage2Host(const void* i_image, const uint64_t i_imageAddress)
-{
- return xipHostAddressFromOffset(i_image,
- i_imageAddress - xipLinkAddress(i_image));
-}
-
-
-XIP_STATIC int
-xipValidateImageAddress(const void* i_image,
- const uint64_t i_imageAddress,
- const uint32_t size)
-{
- int rc;
-
- if ((i_imageAddress < xipLinkAddress(i_image)) ||
- (i_imageAddress > (xipLinkAddress(i_image) +
- xipImageSize(i_image) -
- size))) {
- rc = TRACE_ERRORX(SBE_XIP_INVALID_ARGUMENT,
- "The IMAGE address " F0x012llx
- " is outside the bounds "
- "of the image ("
- F0x012llx ":" F0x012llx
- ") for %u-byte access.\n",
- i_imageAddress,
- xipLinkAddress(i_image),
- xipLinkAddress(i_image) + xipImageSize(i_image) - 1,
- size);
- } else {
- rc = 0;
- }
- return rc;
-}
-
-
-/// Get the magic number from the image
-
-XIP_STATIC uint64_t
-xipMagic(const void* i_image)
-{
- return xipRevLe64(((SbeXipHeader*)i_image)->iv_magic);
-}
-
-
-/// Get the header version from the image
-
-XIP_STATIC uint8_t
-xipHeaderVersion(const void* i_image)
-{
- return ((SbeXipHeader*)i_image)->iv_headerVersion;
-}
-
-
-/// Has the image been normalized?
-
-XIP_STATIC uint8_t
-xipNormalized(const void* i_image)
-{
- return ((SbeXipHeader*)i_image)->iv_normalized;
-}
-
-
-/// Has the image TOC been sorted?
-
-XIP_STATIC uint8_t
-xipSorted(const void* i_image)
-{
- return ((SbeXipHeader*)i_image)->iv_tocSorted;
-}
-
-
-/// A quick check that the image exists, has the correct magic and header
-/// version, and optionally is normalized.
-
-XIP_STATIC int
-xipQuickCheck(const void* i_image, const int i_normalizationRequired)
-{
- int rc;
-
- do {
- rc = 0;
-
- if (i_image == 0) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "Image pointer is NULL (0)\n");
- break;
- }
- if ((xipMagic(i_image) >> 32) != SBE_XIP_MAGIC) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "Magic number mismatch; Found "
- "" F0x016llx ", expected 0x%08x........\n",
- xipMagic(i_image), SBE_XIP_MAGIC);
- break;
- }
- if ((xipHeaderVersion(i_image)) != SBE_XIP_HEADER_VERSION) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "Header version mismatch; Expecting %d, "
- "found %d\n",
- SBE_XIP_HEADER_VERSION,
- xipHeaderVersion(i_image));
- break;
- }
- if (i_normalizationRequired && !xipNormalized(i_image)) {
- rc = TRACE_ERRORX(SBE_XIP_NOT_NORMALIZED,
- "Image not normalized\n");
- break;
- }
- } while(0);
-
- return rc;
-}
-
-
-/// Convert a 32-bit relocatable offset to a full IMAGE 48-bit address
-
-XIP_STATIC uint64_t
-xipFullAddress(const void* i_image, uint32_t offset)
-{
- return (xipLinkAddress(i_image) & 0x0000ffff00000000ull) + offset;
-}
-
-
-/// Translate a section table entry
-
-XIP_STATIC void
-xipTranslateSection(SbeXipSection* o_dest, const SbeXipSection* i_src)
-{
-#ifndef _BIG_ENDIAN
-
-#if SBE_XIP_HEADER_VERSION != 8
-#error This code assumes the SBE-XIP header version 8 layout
-#endif
-
- o_dest->iv_offset = xipRevLe32(i_src->iv_offset);
- o_dest->iv_size = xipRevLe32(i_src->iv_size);
- o_dest->iv_alignment = i_src->iv_alignment;
- o_dest->iv_reserved8[0] = 0;
- o_dest->iv_reserved8[1] = 0;
- o_dest->iv_reserved8[2] = 0;
-#else
- if (o_dest != i_src) {
- *o_dest = *i_src;
- }
-#endif /* _BIG_ENDIAN */
-}
-
-
-/// Translate a TOC entry
-
-XIP_STATIC void
-xipTranslateToc(SbeXipToc* o_dest, SbeXipToc* i_src)
-{
-#ifndef _BIG_ENDIAN
-
-#if SBE_XIP_HEADER_VERSION != 8
-#error This code assumes the SBE-XIP header version 8 layout
-#endif
-
- o_dest->iv_id = xipRevLe32(i_src->iv_id);
- o_dest->iv_data = xipRevLe32(i_src->iv_data);
- o_dest->iv_type = i_src->iv_type;
- o_dest->iv_section = i_src->iv_section;
- o_dest->iv_elements = i_src->iv_elements;
- o_dest->iv_pad = 0;
-#else
- if (o_dest != i_src) {
- *o_dest = *i_src;
- }
-#endif /* _BIG_ENDIAN */
-}
-
-
-/// Find the final (highest-address) section of the image
-
-XIP_STATIC int
-xipFinalSection(const void* i_image, int* o_sectionId)
-{
- int i, rc, found;
- uint32_t offset;
- SbeXipHeader hostHeader;
-
- sbe_xip_translate_header(&hostHeader, (SbeXipHeader*)i_image);
-
- found = 0;
- offset = 0;
- *o_sectionId = 0; /* Make GCC -O3 happy */
- for (i = 0; i < SBE_XIP_SECTIONS; i++) {
- if ((hostHeader.iv_section[i].iv_size != 0) &&
- (hostHeader.iv_section[i].iv_offset >= offset)) {
- *o_sectionId = i;
- offset = hostHeader.iv_section[i].iv_offset;
- found = 1;
- }
- }
- if (!found) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR, "The image is empty\n");
- } else {
- rc = 0;
- }
- return rc;
-}
-
-
-/// Return a pointer to an image-format section table entry
-
-XIP_STATIC int
-xipGetSectionPointer(const void* i_image,
- const int i_sectionId,
- SbeXipSection** o_imageSection)
-{
- int rc;
-
- if ((i_sectionId < 0) || (i_sectionId >= SBE_XIP_SECTIONS)) {
- rc = TRACE_ERROR(SBE_XIP_INVALID_ARGUMENT);
- } else {
- *o_imageSection =
- &(((SbeXipHeader*)i_image)->iv_section[i_sectionId]);
- rc = 0;
- }
- return rc;
-}
-
-
-/// Restore a section table entry from host format to image format.
-
-XIP_STATIC int
-xipPutSection(const void* i_image,
- const int i_sectionId,
- SbeXipSection* i_hostSection)
-{
- int rc;
- SbeXipSection *imageSection;
-
- rc = xipGetSectionPointer(i_image, i_sectionId, &imageSection);
-
- if (!rc) {
- xipTranslateSection(imageSection, i_hostSection);
- }
-
- return rc;
-}
-
-
-/// Set the offset of a section
-
-XIP_STATIC int
-xipSetSectionOffset(void* io_image, const int i_section,
- const uint32_t i_offset)
-{
- SbeXipSection* section;
- int rc;
-
- rc = xipGetSectionPointer(io_image, i_section, &section);
- if (!rc) {
- section->iv_offset = xipRevLe32(i_offset);
- }
- return rc;
-}
-
-
-/// Set the size of a section
-
-XIP_STATIC int
-xipSetSectionSize(void* io_image, const int i_section, const uint32_t i_size)
-{
- SbeXipSection* section;
- int rc;
-
- rc = xipGetSectionPointer(io_image, i_section, &section);
- if (!rc) {
- section->iv_size = xipRevLe32(i_size);
- }
- return rc;
-}
-
-
-/// Translate a IMAGE address in the image to a section and offset
-
-// We first check to be sure that the IMAGE address is contained in the image,
-// using the full 48-bit form. Then we scan the section table to see which
-// section contains the address - if none then the image is corrupted. We can
-// (must) use the 32-bit offset form of the address here.
-
-XIP_STATIC int
-xipImage2Section(const void* i_image,
- const uint64_t i_imageAddress,
- int* o_section,
- uint32_t* o_offset)
-{
- int rc, sectionId;
- SbeXipSection section;
- uint32_t addressOffset;
-
- do {
- rc = 0;
-
- if ((i_imageAddress < xipLinkAddress(i_image)) ||
- (i_imageAddress >
- (xipLinkAddress(i_image) + xipImageSize(i_image)))) {
- rc = TRACE_ERRORX(SBE_XIP_INVALID_ARGUMENT,
- "image2section: The i_imageAddress argument "
- "(" F0x016llx ")\nis outside the bounds of the "
- "image (" F0x016llx ":" F0x016llx ")\n",
- i_imageAddress,
- xipLinkAddress(i_image),
- xipLinkAddress(i_image) + xipImageSize(i_image));
- break;
- }
-
- addressOffset = (i_imageAddress - xipLinkAddress(i_image)) & 0xffffffff;
-
- for (sectionId = 0; sectionId < SBE_XIP_SECTIONS; sectionId++) {
- rc = sbe_xip_get_section(i_image, sectionId, &section);
- if (rc) {
- rc = TRACE_ERROR(SBE_XIP_BUG); /* Can't happen */
- break;
- }
- if ((section.iv_size != 0) &&
- (addressOffset >= section.iv_offset) &&
- (addressOffset < (section.iv_offset + section.iv_size))) {
- break;
- }
- }
- if (rc) break;
-
- if (sectionId == SBE_XIP_SECTIONS) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "Error processing IMAGE address " F0x016llx ". "
- "The address is not mapped in any section.\n"
- "A section table dump appears below\n",
- i_imageAddress);
- dumpSectionTable(i_image);
- break;
- }
-
- *o_section = sectionId;
- *o_offset = addressOffset - section.iv_offset;
-
- } while(0);
-
- return rc;
-}
-
-
-/// Get the information required to search the TOC.
-///
-/// All return values are optional.
-
-XIP_STATIC int
-xipGetToc(void* i_image,
- SbeXipToc** o_toc,
- size_t* o_entries,
- int* o_sorted,
- char** o_strings)
-{
- int rc;
- SbeXipSection tocSection, stringsSection;
-
- do {
- rc = sbe_xip_get_section(i_image, SBE_XIP_SECTION_TOC, &tocSection);
- if (rc) break;
-
- rc = sbe_xip_get_section(i_image, SBE_XIP_SECTION_STRINGS,
- &stringsSection);
- if (rc) break;
-
- if (o_toc) {
- *o_toc = (SbeXipToc*)((uint8_t*)i_image + tocSection.iv_offset);
- }
- if (o_entries) {
- *o_entries = tocSection.iv_size / sizeof(SbeXipToc);
- }
- if (o_sorted) {
- *o_sorted = xipSorted(i_image);
- }
- if (o_strings) {
- *o_strings = (char*)i_image + stringsSection.iv_offset;
- }
- } while (0);
- return rc;
-}
-
-
-/// Compare two normalized TOC entries for sorting.
-
-XIP_STATIC int
-xipCompareToc(const SbeXipToc* i_a, const SbeXipToc* i_b,
- const char* i_strings)
-{
- return strcmp(i_strings + xipRevLe32(i_a->iv_id),
- i_strings + xipRevLe32(i_b->iv_id));
-}
-
-
-/// Iterative quicksort of the TOC
-
-// Note: The stack requirement is limited to 256 bytes + minor local storage.
-
-XIP_STATIC void
-xipQuickSort(SbeXipToc* io_toc, int i_left, int i_right,
- const char* i_strings)
-{
- int i, j, left, right, sp;
- SbeXipToc pivot, temp;
- uint32_t stack[64];
-
- sp = 0;
- stack[sp++] = i_left;
- stack[sp++] = i_right;
-
- while (sp) {
-
- right = stack[--sp];
- left = stack[--sp];
-
- i = left;
- j = right;
-
- pivot = io_toc[(i + j) / 2];
-
- while (i <= j) {
- while (xipCompareToc(&(io_toc[i]), &pivot, i_strings) < 0) {
- i++;
- }
- while (xipCompareToc(&(io_toc[j]), &pivot, i_strings) > 0) {
- j--;
- }
- if (i <= j) {
- temp = io_toc[i];
- io_toc[i] = io_toc[j];
- io_toc[j] = temp;
- i++;
- j--;
- }
- }
- if (left < j) {
- stack[sp++] = left;
- stack[sp++] = j;
- }
- if (i < right) {
- stack[sp++] = i;
- stack[sp++] = right;
- }
- }
-}
-
-
-/// TOC linear search
-
-XIP_STATIC int
-xipLinearSearch(void* i_image, const char* i_id, SbeXipToc** o_entry)
-{
- int rc;
- SbeXipToc *imageToc, hostToc;
- size_t entries;
- char* strings;
-
- *o_entry = 0;
- rc = xipGetToc(i_image, &imageToc, &entries, 0, &strings);
- if (!rc) {
- for (; entries; entries--, imageToc++) {
- xipTranslateToc(&hostToc, imageToc);
- if (strcmp(i_id, strings + hostToc.iv_id) == 0) {
- break;
- }
- }
- if (entries) {
- *o_entry = imageToc;
- rc = 0;
- } else {
- *o_entry = 0;
- rc = TRACE_ERROR(SBE_XIP_ITEM_NOT_FOUND);
- }
- }
- return rc;
-}
-
-
-/// A classic binary search of a (presumed) sorted array
-
-XIP_STATIC int
-xipBinarySearch(void* i_image, const char* i_id, SbeXipToc** o_entry)
-{
- int rc;
- SbeXipToc *imageToc;
- size_t entries;
- char* strings;
- int sorted, left, right, next, sort;
-
- do {
- *o_entry = 0;
-
- rc = xipGetToc(i_image, &imageToc, &entries, &sorted, &strings);
- if (rc) break;
-
- if (!sorted) {
- rc = TRACE_ERROR(SBE_XIP_BUG);
- break;
- }
-
- left = 0;
- right = entries - 1;
- while (left <= right) {
- next = (left + right) / 2;
- sort = strcmp(i_id, strings + xipRevLe32(imageToc[next].iv_id));
- if (sort == 0) {
- *o_entry = &(imageToc[next]);
- break;
- } else if (sort < 0) {
- right = next - 1;
- } else {
- left = next + 1;
- }
- }
- if (*o_entry == 0) {
- rc = TRACE_ERROR(SBE_XIP_ITEM_NOT_FOUND);
- break;
- }
- } while (0);
- return rc;
-}
-
-
-/// Validate a TOC entry as a mapping function
-///
-/// The TOC is validated by searching for the entry, which will uncover
-/// duplicate entries or problems with sorting/searching.
-
-XIP_STATIC int
-xipValidateTocEntry(void* io_image, const SbeXipItem* i_item, void* io_arg)
-{
- int rc;
- SbeXipItem found;
-
- do {
- rc = sbe_xip_find(io_image, i_item->iv_id, &found);
- if (rc) {
- rc = TRACE_ERRORX(rc, "TOC entry for %s not found\n",
- i_item->iv_id);
- } else if (found.iv_toc != i_item->iv_toc) {
- rc = TRACE_ERRORX(SBE_XIP_TOC_ERROR,
- "Duplicate TOC entry for '%s'\n", i_item->iv_id);
- }
- break;
- } while (0);
- return rc;
-}
-
-
-// This is the FNV-1a hash, used for hashing symbol names in the .fixed
-// section into 32-bit hashes for the mini-TOC.
-
-// According to the authors:
-
-// "FNV hash algorithms and source code have been released into the public
-// domain. The authors of the FNV algorithmm look deliberate steps to disclose
-// the algorhtm (sic) in a public forum soon after it was invented. More than
-// a year passed after this public disclosure and the authors deliberatly took
-// no steps to patent the FNV algorithm. Therefore it is safe to say that the
-// FNV authors have no patent claims on the FNV algorithm as published."
-
-#define FNV_OFFSET_BASIS 2166136261u
-#define FNV_PRIME32 16777619u
-
-uint32_t
-xipHash32(const char* s)
-{
- uint32_t hash;
-
- hash = FNV_OFFSET_BASIS;
- while (*s) {
- hash ^= *s++;
- hash *= FNV_PRIME32;
- }
- return hash;
-}
-
-
-// Normalize a TOC entry
-
-// Normalize the TOC entry by converting relocatable pointers into 32-bit
-// offsets from the beginning of the section containing the data. All
-// addresses in the TOC are actually 32-bit offsets in the address space named
-// in bits 16:31 of the link address of the image.
-
-XIP_STATIC int
-xipNormalizeToc(void* io_image, SbeXipToc *io_imageToc,
- SbeXipHashedToc** io_fixedTocEntry,
- size_t* io_fixedEntriesRemaining)
-{
- SbeXipToc hostToc;
- int idSection, dataSection;
- uint32_t idOffset, dataOffset;
- char* hostString;
- int rc;
-
- do {
-
- // Translate the TOC entry to host format. Then locate the
- // sections/offsets of the Id string (which must be in .strings) and
- // the data.
-
- xipTranslateToc(&hostToc, io_imageToc);
-
- hostString =
- (char*)xipImage2Host(io_image,
- xipFullAddress(io_image, hostToc.iv_id));
-
- rc = xipImage2Section(io_image,
- xipFullAddress(io_image, hostToc.iv_id),
- &idSection,
- &idOffset);
- if (rc) break;
-
- if (idSection != SBE_XIP_SECTION_STRINGS) {
- rc = TRACE_ERROR(SBE_XIP_IMAGE_ERROR);
- break;
- }
-
- rc = xipImage2Section(io_image,
- xipFullAddress(io_image, hostToc.iv_data),
- &dataSection,
- &dataOffset);
- if (rc) break;
-
- // Now replace the Id and data pointers with their offsets, and update
- // the data section in the TOC entry.
-
- hostToc.iv_id = idOffset;
- hostToc.iv_data = dataOffset;
- hostToc.iv_section = dataSection;
-
- // If this TOC entry is from .fixed, create a new record in .fixed_toc
-
- if (hostToc.iv_section == SBE_XIP_SECTION_FIXED) {
-
- if (*io_fixedEntriesRemaining == 0) {
- rc = TRACE_ERRORX(SBE_XIP_TOC_ERROR,
- "Too many TOC entries for .fixed\n");
- break;
- }
- if (hostToc.iv_data != (uint16_t)hostToc.iv_data) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "The .fixed section is too big to index\n");
- break;
- }
-
- (*io_fixedTocEntry)->iv_hash = xipRevLe32(xipHash32(hostString));
- (*io_fixedTocEntry)->iv_offset = xipRevLe16(hostToc.iv_data);
- (*io_fixedTocEntry)->iv_type = hostToc.iv_type;
- (*io_fixedTocEntry)->iv_elements = hostToc.iv_elements;
-
- (*io_fixedTocEntry)++;
- (*io_fixedEntriesRemaining)--;
- }
-
- // Finally update the TOC entry
-
- xipTranslateToc(io_imageToc, &hostToc);
-
- } while (0);
-
- return rc;
-}
-
-
-// Check for hash collisions in the .fixed mini-TOC. Note that endianness is
-// not an issue here, as we're comparing for equality.
-
-XIP_STATIC int
-xipHashCollision(SbeXipHashedToc* i_fixedToc, size_t i_entries)
-{
- int rc;
- size_t i, j;
-
- rc = 0;
-
- for (i = 0; i < i_entries; i++) {
- for (j = i + 1; j < i_entries; j++) {
- if (i_fixedToc[i].iv_hash == i_fixedToc[j].iv_hash) {
- rc = TRACE_ERRORX(SBE_XIP_HASH_COLLISION,
- "Hash collision at index %d\n",
- i);
- break;
- }
- }
- if (rc) break;
- }
-
- return rc;
-}
-
-
-/// Decode a normalized image-format TOC entry into a host-format SbeXipItem
-/// structure
-
-XIP_STATIC int
-xipDecodeToc(void* i_image,
- SbeXipToc* i_imageToc,
- SbeXipItem* o_item)
-{
- int rc;
- SbeXipToc hostToc;
- SbeXipSection dataSection, stringsSection;
-
- do {
- if (!xipNormalized(i_image)) {
- rc = TRACE_ERROR(SBE_XIP_NOT_NORMALIZED);
- break;
- }
-
-
- // Translate the TOC entry and set the TOC pointer, data type and
- // number of elements in the outgoing structure. The Id string is
- // always located in the TOC_STRINGS section.
-
- xipTranslateToc(&hostToc, i_imageToc);
-
- o_item->iv_toc = i_imageToc;
- o_item->iv_type = hostToc.iv_type;
- o_item->iv_elements = hostToc.iv_elements;
-
- sbe_xip_get_section(i_image, SBE_XIP_SECTION_STRINGS, &stringsSection);
- o_item->iv_id =
- (char*)i_image + stringsSection.iv_offset + hostToc.iv_id;
-
-
- // The data (or text address) are addressed by relative offsets from
- // the beginning of their section. The TOC entry may remain in the TOC
- // even though the section has been removed from the image, so this
- // case needs to be covered.
-
- rc = sbe_xip_get_section(i_image, hostToc.iv_section, &dataSection);
- if (rc) break;
-
- if (dataSection.iv_size == 0) {
- rc = TRACE_ERROR(SBE_XIP_DATA_NOT_PRESENT);
- break;
- }
-
- o_item->iv_imageData =
- (void*)((uint8_t*)i_image +
- dataSection.iv_offset + hostToc.iv_data);
-
- o_item->iv_address =
- xipLinkAddress(i_image) + dataSection.iv_offset + hostToc.iv_data;
-
- o_item->iv_partial = 0;
-
- } while (0);
- return rc;
-}
-
-
-/// Sort the TOC
-
-XIP_STATIC int
-xipSortToc(void* io_image)
-{
- int rc;
- SbeXipToc *hostToc;
- size_t entries;
- char* strings;
-
- do {
- rc = xipQuickCheck(io_image, 1);
- if (rc) break;
-
- if (xipSorted(io_image)) break;
-
- rc = xipGetToc(io_image, &hostToc, &entries, 0, &strings);
- if (rc) break;
-
- xipQuickSort(hostToc, 0, entries - 1, strings);
-
- ((SbeXipHeader*)io_image)->iv_tocSorted = 1;
-
- } while (0);
-
- return rc;
-}
-
-
-// Pad the image with 0 to a given power-of-2 alignment. The image size is
-// modified to reflect the pad, but the caller must modify the section size to
-// reflect the pad.
-
-XIP_STATIC int
-xipPadImage(void* io_image, uint32_t i_allocation,
- uint32_t i_align, uint32_t* pad)
-{
- int rc;
-
- do {
- rc = 0;
-
- if ((i_align == 0) || ((i_align & (i_align - 1)) != 0)) {
- rc = TRACE_ERRORX(SBE_XIP_INVALID_ARGUMENT,
- "Alignment specification (%u) "
- "not a power-of-2\n",
- i_align);
- break;
- }
-
- *pad = xipImageSize(io_image) % i_align;
- if (*pad != 0) {
- *pad = i_align - *pad;
-
- if ((xipImageSize(io_image) + *pad) > i_allocation) {
- rc = TRACE_ERROR(SBE_XIP_WOULD_OVERFLOW);
- break;
- }
-
- memset((void*)((unsigned long)io_image + xipImageSize(io_image)),
- 0, *pad);
- xipSetImageSize(io_image, xipImageSize(io_image) + *pad);
- }
- } while (0);
-
- return rc;
-}
-
-
-// Get the .fixed_toc section
-
-XIP_STATIC int
-xipGetFixedToc(void* io_image,
- SbeXipHashedToc** o_imageToc,
- size_t* o_entries)
-{
- int rc;
- SbeXipSection section;
-
- rc = sbe_xip_get_section(io_image, SBE_XIP_SECTION_FIXED_TOC, &section);
- if (!rc) {
-
- *o_imageToc =
- (SbeXipHashedToc*)((unsigned long)io_image + section.iv_offset);
-
- *o_entries = section.iv_size / sizeof(SbeXipHashedToc);
- }
-
- return rc;
-}
-
-
-// Search for an item in the fixed TOC, and populate a partial TOC entry if
-// requested. This table is small and unsorted so a linear search is
-// adequate. The TOC structures are also small so all byte-reversal is done
-// 'by hand' rather than with a translate-type API.
-
-XIP_STATIC int
-xipFixedFind(void* i_image, const char* i_id, SbeXipItem* o_item)
-{
- int rc;
- SbeXipHashedToc* toc;
- size_t entries;
- uint32_t hash;
- SbeXipSection fixedSection;
- uint32_t offset;
-
- do {
- rc = xipGetFixedToc(i_image, &toc, &entries);
- if (rc) break;
-
- for (hash = xipRevLe32(xipHash32(i_id)); entries != 0; entries--, toc++) {
- if (toc->iv_hash == hash) break;
- }
-
- if (entries == 0) {
- rc = SBE_XIP_ITEM_NOT_FOUND;
- break;
- } else {
- rc = 0;
- }
-
- // The caller may have requested a lookup only (o_item == 0), in which
- // case we're done. Otherwise we create a partial SbeXipItem and
- // populate the non-0 fields analogously to the xipDecodeToc()
- // routine. The data resides in the .fixed section in this case.
-
- if (o_item == 0) break;
-
- o_item->iv_partial = 1;
- o_item->iv_toc = 0;
- o_item->iv_id = 0;
-
- o_item->iv_type = toc->iv_type;
- o_item->iv_elements = toc->iv_elements;
-
- rc = sbe_xip_get_section(i_image, SBE_XIP_SECTION_FIXED, &fixedSection);
- if (rc) break;
-
- if (fixedSection.iv_size == 0) {
- rc = TRACE_ERROR(SBE_XIP_DATA_NOT_PRESENT);
- break;
- }
-
- offset = fixedSection.iv_offset + xipRevLe16(toc->iv_offset);
-
- o_item->iv_imageData = (void*)((uint8_t*)i_image + offset);
- o_item->iv_address = xipLinkAddress(i_image) + offset;
-
- } while (0);
-
- return rc;
-}
-
-
-// Search for an item in the special built-in TOC of header fields, and
-// populate a partial TOC entry if requested.
-//
-// This facility was added to allow header data to be searched by name even
-// when the TOC has been stripped. This API will only be used in the case of a
-// stripped TOC since the header fields are also indexed in the main TOC.
-//
-// The table is allocated on the stack in order to make this code concurrently
-// patchable in PHYP (although PHYP applications will never use this code).
-// The table is small and unsorted so a linear search is adequate, and the
-// stack requirememts are small.
-
-XIP_STATIC int
-xipHeaderFind(void* i_image, const char* i_id, SbeXipItem* o_item)
-{
- int rc;
- unsigned i;
- uint32_t offset;
- SbeXipSection headerSection;
-
-#define HEADER_TOC(id, field, type) \
- {#id, offsetof(SbeXipHeader, field), type}
-
- struct HeaderToc {
-
- const char* iv_id;
- uint16_t iv_offset;
- uint8_t iv_type;
-
- } toc[] = {
-
- HEADER_TOC(magic, iv_magic, SBE_XIP_UINT64),
- HEADER_TOC(entry_offset, iv_entryOffset, SBE_XIP_UINT64),
- HEADER_TOC(link_address, iv_linkAddress, SBE_XIP_UINT64),
-
- HEADER_TOC(image_size, iv_imageSize, SBE_XIP_UINT32),
- HEADER_TOC(build_date, iv_buildDate, SBE_XIP_UINT32),
- HEADER_TOC(build_time, iv_buildTime, SBE_XIP_UINT32),
-
- HEADER_TOC(header_version, iv_headerVersion, SBE_XIP_UINT8),
- HEADER_TOC(toc_normalized, iv_normalized, SBE_XIP_UINT8),
- HEADER_TOC(toc_sorted, iv_tocSorted, SBE_XIP_UINT8),
-
- HEADER_TOC(build_user, iv_buildUser, SBE_XIP_STRING),
- HEADER_TOC(build_host, iv_buildHost, SBE_XIP_STRING),
-
- };
-
- do {
-
- rc = SBE_XIP_ITEM_NOT_FOUND;
- for (i = 0; i < (sizeof(toc) / sizeof(struct HeaderToc)); i++) {
- if (strcmp(i_id, toc[i].iv_id) == 0) {
- rc = 0;
- break;
- }
- }
-
- if (rc) break;
-
- // The caller may have requested a lookup only (o_item == 0), in which
- // case we're done. Otherwise we create a partial SbeXipItem and
- // populate the non-0 fields analogously to the xipDecodeToc()
- // routine. The data resides in the .fixed section in this case.
-
- if (o_item == 0) break;
-
- o_item->iv_partial = 1;
- o_item->iv_toc = 0;
- o_item->iv_id = 0;
-
- o_item->iv_type = toc[i].iv_type;
- o_item->iv_elements = 1; /* True for now... */
-
- rc = sbe_xip_get_section(i_image, SBE_XIP_SECTION_HEADER,
- &headerSection);
- if (rc) break;
-
- if (headerSection.iv_size == 0) {
- rc = TRACE_ERROR(SBE_XIP_DATA_NOT_PRESENT);
- break;
- }
-
- offset = headerSection.iv_offset + toc[i].iv_offset;
-
- o_item->iv_imageData = (void*)((uint8_t*)i_image + offset);
- o_item->iv_address = xipLinkAddress(i_image) + offset;
-
- } while (0);
-
- return rc;
-}
-
-
-////////////////////////////////////////////////////////////////////////////
-// Published API
-////////////////////////////////////////////////////////////////////////////
-
-int
-sbe_xip_validate(void* i_image, const uint32_t i_size)
-{
- SbeXipHeader hostHeader;
- int rc = 0, i;
- uint32_t linkAddress, imageSize, extent, offset, size;
- uint8_t alignment;
-
- sbe_xip_translate_header(&hostHeader, (SbeXipHeader*)i_image);
-
- do {
-
- // Validate C/Assembler constraints.
-
- if (sizeof(SbeXipSection) != SIZE_OF_SBE_XIP_SECTION) {
- rc = TRACE_ERRORX(SBE_XIP_BUG,
- "C/Assembler size mismatch(%d/%d) "
- "for SbeXipSection\n",
- sizeof(SbeXipSection), SIZE_OF_SBE_XIP_SECTION);
- break;
- }
-
- if (sizeof(SbeXipToc) != SIZE_OF_SBE_XIP_TOC) {
- rc = TRACE_ERRORX(SBE_XIP_BUG,
- "C/Assembler size mismatch(%d/%d) "
- "for SbeXipToc\n",
- sizeof(SbeXipToc), SIZE_OF_SBE_XIP_TOC);
- break;
- }
-
- if (sizeof(SbeXipHashedToc) != SIZE_OF_SBE_XIP_HASHED_TOC) {
- rc = TRACE_ERRORX(SBE_XIP_BUG,
- "C/Assembler size mismatch(%d/%d) "
- "for SbeXipHashedToc\n",
- sizeof(SbeXipHashedToc),
- SIZE_OF_SBE_XIP_HASHED_TOC);
- break;
- }
-
- // Validate the image pointer and magic number
-
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- // Validate the image size
-
- linkAddress = hostHeader.iv_linkAddress;
- imageSize = hostHeader.iv_imageSize;
- extent = linkAddress + imageSize;
-
- if (imageSize < sizeof(SbeXipHeader)) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "sbe_xip_validate(%p, %u) : "
- "The image size recorded in the image "
- "(%u) is smaller than the header size.\n",
- i_image, i_size, imageSize);
- break;
- }
- if (imageSize != i_size) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "sbe_xip_validate(%p, %u) : "
- "The image size recorded in the image "
- "(%u) does not match the i_size parameter.\n",
- i_image, i_size, imageSize);
- break;
- }
- if (extent <= linkAddress) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "sbe_xip_validate(%p, %u) : "
- "Given the link address (%u) and the "
- "image size, the image wraps the address space\n",
- i_image, i_size, linkAddress);
- break;
- }
- if ((imageSize % SBE_XIP_FINAL_ALIGNMENT) != 0) {
- rc = TRACE_ERRORX(SBE_XIP_ALIGNMENT_ERROR,
- "sbe_xip_validate(%p, %u) : "
- "The image size (%u) is not a multiple of %u\n",
- i_image, i_size, imageSize,
- SBE_XIP_FINAL_ALIGNMENT);
- break;
- }
-
- // Validate that all sections appear to be within the image
- // bounds, and are aligned correctly.
-
- for (i = 0; i < SBE_XIP_SECTIONS; i++) {
-
- offset = hostHeader.iv_section[i].iv_offset;
- size = hostHeader.iv_section[i].iv_size;
- alignment = hostHeader.iv_section[i].iv_alignment;
-
- if ((offset > imageSize) ||
- ((offset + size) > imageSize) ||
- ((offset + size) < offset)) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "Section %d does not appear to be within "
- "the bounds of the image\n"
- "offset = %u, size = %u, image size = %u\n",
- i, offset, size, imageSize);
- break;
- }
- if ((offset % alignment) != 0) {
- rc = TRACE_ERRORX(SBE_XIP_ALIGNMENT_ERROR,
- "Section %d requires %d-byte initial "
- "alignment but the section offset is %u\n",
- i, alignment, offset);
- break;
- }
- }
- if (rc) break;
-
- // If the TOC exists and the image is normalized, validate each TOC
- // entry.
-
- size = hostHeader.iv_section[SBE_XIP_SECTION_TOC].iv_size;
- if (size != 0) {
- if (xipNormalized(i_image)) {
- rc = sbe_xip_map_toc(i_image, xipValidateTocEntry, 0);
- if (rc) break;
- }
- }
- } while (0);
- return rc;
-}
-
-
-int
-sbe_xip_validate2(void* i_image, const uint32_t i_size, const uint32_t i_maskIgnores)
-{
- SbeXipHeader hostHeader;
- int rc = 0, i;
- uint32_t linkAddress, imageSize, extent, offset, size;
- uint8_t alignment;
-
- sbe_xip_translate_header(&hostHeader, (SbeXipHeader*)i_image);
-
- do {
-
- // Validate C/Assembler constraints.
-
- if (sizeof(SbeXipSection) != SIZE_OF_SBE_XIP_SECTION) {
- rc = TRACE_ERRORX(SBE_XIP_BUG,
- "C/Assembler size mismatch(%d/%d) "
- "for SbeXipSection\n",
- sizeof(SbeXipSection), SIZE_OF_SBE_XIP_SECTION);
- break;
- }
-
- if (sizeof(SbeXipToc) != SIZE_OF_SBE_XIP_TOC) {
- rc = TRACE_ERRORX(SBE_XIP_BUG,
- "C/Assembler size mismatch(%d/%d) "
- "for SbeXipToc\n",
- sizeof(SbeXipToc), SIZE_OF_SBE_XIP_TOC);
- break;
- }
-
- if (sizeof(SbeXipHashedToc) != SIZE_OF_SBE_XIP_HASHED_TOC) {
- rc = TRACE_ERRORX(SBE_XIP_BUG,
- "C/Assembler size mismatch(%d/%d) "
- "for SbeXipHashedToc\n",
- sizeof(SbeXipHashedToc),
- SIZE_OF_SBE_XIP_HASHED_TOC);
- break;
- }
-
- // Validate the image pointer and magic number
-
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- // Validate the image size
-
- linkAddress = hostHeader.iv_linkAddress;
- imageSize = hostHeader.iv_imageSize;
- extent = linkAddress + imageSize;
-
- if (imageSize < sizeof(SbeXipHeader)) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "sbe_xip_validate2(%p, %u) : "
- "The image size recorded in the image "
- "(%u) is smaller than the header size.\n",
- i_image, i_size, imageSize);
- break;
- }
- if (imageSize != i_size && !(i_maskIgnores & SBE_XIP_IGNORE_FILE_SIZE)) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "sbe_xip_validate2(%p, %u) : "
- "The image size recorded in the image "
- "(%u) does not match the i_size parameter.\n",
- i_image, i_size, imageSize);
- break;
- }
- if (extent <= linkAddress) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "sbe_xip_validate2(%p, %u) : "
- "Given the link address (%u) and the "
- "image size, the image wraps the address space\n",
- i_image, i_size, linkAddress);
- break;
- }
- if ((imageSize % SBE_XIP_FINAL_ALIGNMENT) != 0) {
- rc = TRACE_ERRORX(SBE_XIP_ALIGNMENT_ERROR,
- "sbe_xip_validate2(%p, %u) : "
- "The image size (%u) is not a multiple of %u\n",
- i_image, i_size, imageSize,
- SBE_XIP_FINAL_ALIGNMENT);
- break;
- }
-
- // Validate that all sections appear to be within the image
- // bounds, and are aligned correctly.
-
- for (i = 0; i < SBE_XIP_SECTIONS; i++) {
-
- offset = hostHeader.iv_section[i].iv_offset;
- size = hostHeader.iv_section[i].iv_size;
- alignment = hostHeader.iv_section[i].iv_alignment;
-
- if ((offset > imageSize) ||
- ((offset + size) > imageSize) ||
- ((offset + size) < offset)) {
- rc = TRACE_ERRORX(SBE_XIP_IMAGE_ERROR,
- "Section %d does not appear to be within "
- "the bounds of the image\n"
- "offset = %u, size = %u, image size = %u\n",
- i, offset, size, imageSize);
- break;
- }
- if ((offset % alignment) != 0) {
- rc = TRACE_ERRORX(SBE_XIP_ALIGNMENT_ERROR,
- "Section %d requires %d-byte initial "
- "alignment but the section offset is %u\n",
- i, alignment, offset);
- break;
- }
- }
- if (rc) break;
-
- // If the TOC exists and the image is normalized, validate each TOC
- // entry.
-
- size = hostHeader.iv_section[SBE_XIP_SECTION_TOC].iv_size;
- if (size != 0) {
- if (xipNormalized(i_image)) {
- rc = sbe_xip_map_toc(i_image, xipValidateTocEntry, 0);
- if (rc) break;
- }
- }
- } while (0);
- return rc;
-}
-
-
-// Normalization:
-//
-// 1. Normalize the TOC, unless the image is already normalized. The image
-// must be marked as normalized before sorting.
-//
-// 2. Sort the TOC.
-//
-// 3. Clear the section offsets of any empty sections to make the section
-// table reports less confusing.
-//
-// 4. Clear normalization status on any failure.
-
-int
-sbe_xip_normalize(void* io_image)
-{
- int rc, i;
- SbeXipSection section;
- SbeXipToc* imageToc;
- SbeXipHashedToc* fixedImageToc;
- SbeXipHashedToc* fixedTocEntry;
- size_t tocEntries, fixedTocEntries, fixedEntriesRemaining;
-
- do {
- rc = xipQuickCheck(io_image, 0);
- if (rc) break;
-
- if (!xipNormalized(io_image)) {
-
- rc = xipGetToc(io_image, &imageToc, &tocEntries, 0, 0);
- if (rc) break;
-
- rc = xipGetFixedToc(io_image, &fixedImageToc, &fixedTocEntries);
- if (rc) break;
-
- fixedTocEntry = fixedImageToc;
- fixedEntriesRemaining = fixedTocEntries;
-
- for (; tocEntries--; imageToc++) {
- rc = xipNormalizeToc(io_image, imageToc,
- &fixedTocEntry, &fixedEntriesRemaining);
- if (rc) break;
-
- }
- if (rc) break;
-
- if (fixedEntriesRemaining != 0) {
- rc = TRACE_ERRORX(SBE_XIP_TOC_ERROR,
- "Not enough TOC entries for .fixed");
- break;
- }
-
- rc = xipHashCollision(fixedImageToc, fixedTocEntries);
- if (rc) break;
-
- ((SbeXipHeader*)io_image)->iv_normalized = 1;
- }
-
- rc = xipSortToc(io_image);
- if (rc) break;
-
- for (i = 0; i < SBE_XIP_SECTIONS; i++) {
- rc = sbe_xip_get_section(io_image, i, &section);
- if (rc) break;
- if (section.iv_size == 0) {
- xipSetSectionOffset(io_image, i, 0);
- }
- }
- if (rc) break;
-
- } while(0);
-
- ((SbeXipHeader*)io_image)->iv_normalized = (rc == 0);
-
- return rc;
-}
-
-
-int
-sbe_xip_image_size(void* io_image, uint32_t* o_size)
-{
- int rc;
-
- rc = xipQuickCheck(io_image, 0);
- if (!rc) {
- *o_size = xipImageSize(io_image);
- }
- return rc;
-}
-
-
-int
-sbe_xip_get_section(const void* i_image,
- const int i_sectionId,
- SbeXipSection* o_hostSection)
-{
- int rc;
- SbeXipSection *imageSection;
-
- rc = xipGetSectionPointer(i_image, i_sectionId, &imageSection);
-
- if (!rc) {
- xipTranslateSection(o_hostSection, imageSection);
- }
-
- return rc;
-}
-
-
-// If the 'big' TOC is not present, search the mini-TOCs that only index the
-// .fixed and .header sections.
-
-int
-sbe_xip_find(void* i_image,
- const char* i_id,
- SbeXipItem* o_item)
-{
- int rc;
- SbeXipToc* toc;
- SbeXipItem item, *pitem;
- SbeXipSection* tocSection;
-
- do {
- rc = xipQuickCheck(i_image, 1);
- if (rc) break;
-
- rc = xipGetSectionPointer(i_image, SBE_XIP_SECTION_TOC, &tocSection);
- if (rc) break;
-
- if (tocSection->iv_size == 0) {
- rc = xipFixedFind(i_image, i_id, o_item);
- if (rc) {
- rc = xipHeaderFind(i_image, i_id, o_item);
- }
- break;
- }
-
- if (xipSorted(i_image)) {
- rc = xipBinarySearch(i_image, i_id, &toc);
- } else {
- rc = xipLinearSearch(i_image, i_id, &toc);
- }
- if (rc) break;
-
- if (o_item) {
- pitem = o_item;
- } else {
- pitem = &item;
- }
- rc = xipDecodeToc(i_image, toc, pitem);
- if (rc) break;
-
- } while (0);
-
- return rc;
-}
-
-
-
-
-int
-sbe_xip_get_scalar(void *i_image, const char* i_id, uint64_t* o_data)
-{
- int rc;
- SbeXipItem item;
-
- rc = sbe_xip_find(i_image, i_id, &item);
- if (!rc) {
- switch (item.iv_type) {
- case SBE_XIP_UINT8:
- *o_data = *((uint8_t*)(item.iv_imageData));
- break;
- case SBE_XIP_UINT16:
- *o_data = xipRevLe16(*((uint16_t*)(item.iv_imageData)));
- break;
- case SBE_XIP_UINT32:
- *o_data = xipRevLe32(*((uint32_t*)(item.iv_imageData)));
- break;
- case SBE_XIP_UINT64:
- *o_data = xipRevLe64(*((uint64_t*)(item.iv_imageData)));
- break;
- case SBE_XIP_INT8:
- *o_data = *((int8_t*)(item.iv_imageData));
- break;
- case SBE_XIP_INT16:
- *o_data = xipRevLe16(*((int16_t*)(item.iv_imageData)));
- break;
- case SBE_XIP_INT32:
- *o_data = xipRevLe32(*((int32_t*)(item.iv_imageData)));
- break;
- case SBE_XIP_INT64:
- *o_data = xipRevLe64(*((int64_t*)(item.iv_imageData)));
- break;
- case SBE_XIP_ADDRESS:
- *o_data = item.iv_address;
- break;
- default:
- rc = TRACE_ERROR(SBE_XIP_TYPE_ERROR);
- break;
- }
- }
- return rc;
-}
-
-
-int
-sbe_xip_get_element(void *i_image,
- const char* i_id,
- const uint32_t i_index,
- uint64_t* o_data)
-{
- int rc;
- SbeXipItem item;
-
- do {
- rc = sbe_xip_find(i_image, i_id, &item);
- if (rc) break;
-
- if ((item.iv_elements != 0) && (i_index >= item.iv_elements)) {
- rc = TRACE_ERROR(SBE_XIP_BOUNDS_ERROR);
- break;
- }
-
- switch (item.iv_type) {
- case SBE_XIP_UINT8:
- *o_data = ((uint8_t*)(item.iv_imageData))[i_index];
- break;
- case SBE_XIP_UINT16:
- *o_data = xipRevLe16(((uint16_t*)(item.iv_imageData))[i_index]);
- break;
- case SBE_XIP_UINT32:
- *o_data = xipRevLe32(((uint32_t*)(item.iv_imageData))[i_index]);
- break;
- case SBE_XIP_UINT64:
- *o_data = xipRevLe64(((uint64_t*)(item.iv_imageData))[i_index]);
- break;
- case SBE_XIP_INT8:
- *o_data = ((int8_t*)(item.iv_imageData))[i_index];
- break;
- case SBE_XIP_INT16:
- *o_data = xipRevLe16(((int16_t*)(item.iv_imageData))[i_index]);
- break;
- case SBE_XIP_INT32:
- *o_data = xipRevLe32(((int32_t*)(item.iv_imageData))[i_index]);
- break;
- case SBE_XIP_INT64:
- *o_data = xipRevLe64(((int64_t*)(item.iv_imageData))[i_index]);
- break;
- default:
- rc = TRACE_ERROR(SBE_XIP_TYPE_ERROR);
- break;
- }
- if (rc) break;
-
- } while (0);
- return rc;
-}
-
-
-int
-sbe_xip_get_string(void *i_image, const char* i_id, char** o_data)
-{
- int rc;
- SbeXipItem item;
-
- rc = sbe_xip_find(i_image, i_id, &item);
- if (!rc) {
- switch (item.iv_type) {
- case SBE_XIP_STRING:
- *o_data = (char*)(item.iv_imageData);
- break;
- default:
- rc = TRACE_ERROR(SBE_XIP_TYPE_ERROR);
- break;
- }
- }
- return rc;
-}
-
-
-int
-sbe_xip_read_uint64(const void *i_image,
- const uint64_t i_imageAddress,
- uint64_t* o_data)
-{
- int rc;
-
- do {
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- rc = xipValidateImageAddress(i_image, i_imageAddress, 8);
- if (rc) break;
-
- if (i_imageAddress % 8) {
- rc = TRACE_ERROR(SBE_XIP_ALIGNMENT_ERROR);
- break;
- }
-
- *o_data =
- xipRevLe64(*((uint64_t*)xipImage2Host(i_image, i_imageAddress)));
-
- } while(0);
-
- return rc;
-}
-
-
-int
-sbe_xip_set_scalar(void* io_image, const char* i_id, const uint64_t i_data)
-{
- int rc;
- SbeXipItem item;
-
- rc = sbe_xip_find(io_image, i_id, &item);
- if (!rc) {
- switch(item.iv_type) {
- case SBE_XIP_UINT8:
- *((uint8_t*)(item.iv_imageData)) = (uint8_t)i_data;
- break;
- case SBE_XIP_UINT16:
- *((uint16_t*)(item.iv_imageData)) = xipRevLe16((uint16_t)i_data);
- break;
- case SBE_XIP_UINT32:
- *((uint32_t*)(item.iv_imageData)) = xipRevLe32((uint32_t)i_data);
- break;
- case SBE_XIP_UINT64:
- *((uint64_t*)(item.iv_imageData)) = xipRevLe64((uint64_t)i_data);
- break;
- case SBE_XIP_INT8:
- *((int8_t*)(item.iv_imageData)) = (int8_t)i_data;
- break;
- case SBE_XIP_INT16:
- *((int16_t*)(item.iv_imageData)) = xipRevLe16((int16_t)i_data);
- break;
- case SBE_XIP_INT32:
- *((int32_t*)(item.iv_imageData)) = xipRevLe32((int32_t)i_data);
- break;
- case SBE_XIP_INT64:
- *((int64_t*)(item.iv_imageData)) = xipRevLe64((int64_t)i_data);
- break;
- default:
- rc = TRACE_ERROR(SBE_XIP_TYPE_ERROR);
- break;
- }
- }
- return rc;
-}
-
-
-int
-sbe_xip_set_element(void *i_image,
- const char* i_id,
- const uint32_t i_index,
- const uint64_t i_data)
-{
- int rc;
- SbeXipItem item;
-
- do {
- rc = sbe_xip_find(i_image, i_id, &item);
- if (rc) break;
-
- if ((item.iv_elements != 0) && (i_index >= item.iv_elements)) {
- rc = TRACE_ERROR(SBE_XIP_BOUNDS_ERROR);
- break;
- }
-
- switch (item.iv_type) {
- case SBE_XIP_UINT8:
- ((uint8_t*)(item.iv_imageData))[i_index] = (uint8_t)i_data;
- break;
- case SBE_XIP_UINT16:
- ((uint16_t*)(item.iv_imageData))[i_index] =
- xipRevLe16((uint16_t)i_data);
- break;
- case SBE_XIP_UINT32:
- ((uint32_t*)(item.iv_imageData))[i_index] =
- xipRevLe32((uint32_t)i_data);
- break;
- case SBE_XIP_UINT64:
- ((uint64_t*)(item.iv_imageData))[i_index] =
- xipRevLe64((uint64_t)i_data);
- break;
- case SBE_XIP_INT8:
- ((int8_t*)(item.iv_imageData))[i_index] = (int8_t)i_data;
- break;
- case SBE_XIP_INT16:
- ((int16_t*)(item.iv_imageData))[i_index] =
- xipRevLe16((uint16_t)i_data);
- break;
- case SBE_XIP_INT32:
- ((int32_t*)(item.iv_imageData))[i_index] =
- xipRevLe32((uint32_t)i_data);
- break;
- case SBE_XIP_INT64:
- ((int64_t*)(item.iv_imageData))[i_index] =
- xipRevLe64((uint64_t)i_data);
- break;
- default:
- rc = TRACE_ERROR(SBE_XIP_TYPE_ERROR);
- break;
- }
- if (rc) break;
-
- } while (0);
-
- return rc;
-}
-
-
-int
-sbe_xip_set_string(void *i_image, const char* i_id, const char* i_data)
-{
- int rc;
- SbeXipItem item;
- char* dest;
-
- rc = sbe_xip_find(i_image, i_id, &item);
- if (!rc) {
- switch (item.iv_type) {
- case SBE_XIP_STRING:
- dest = (char*)(item.iv_imageData);
- if (strlen(dest) < strlen(i_data)) {
- memcpy(dest, i_data, strlen(dest));
- } else {
- strcpy(dest, i_data);
- }
- break;
- default:
- rc = TRACE_ERROR(SBE_XIP_TYPE_ERROR);
- break;
- }
- }
- return rc;
-}
-
-
-int
-sbe_xip_write_uint64(void *io_image,
- const uint64_t i_imageAddress,
- const uint64_t i_data)
-{
- int rc;
-
- do {
- rc = xipQuickCheck(io_image, 0);
- if (rc) break;
-
- rc = xipValidateImageAddress(io_image, i_imageAddress, 8);
- if (rc) break;
-
- if (i_imageAddress % 8) {
- rc = TRACE_ERROR(SBE_XIP_ALIGNMENT_ERROR);
- break;
- }
-
- *((uint64_t*)xipImage2Host(io_image, i_imageAddress)) =
- xipRevLe64(i_data);
-
- } while(0);
-
- return rc;
-}
-
-
-int
-sbe_xip_delete_section(void* io_image, const int i_sectionId)
-{
- int rc, final;
- SbeXipSection section;
-
- do {
- rc = xipQuickCheck(io_image, 1);
- if (rc) break;
-
- rc = sbe_xip_get_section(io_image, i_sectionId, &section);
- if (rc) break;
-
-
- // Deleting an empty section is a NOP. Otherwise the section must be
- // the final section of the image. Update the sizes and re-establish
- // the final image alignment.
-
- if (section.iv_size == 0) break;
-
- rc = xipFinalSection(io_image, &final);
- if (rc) break;
-
- if (final != i_sectionId) {
- rc = TRACE_ERRORX(SBE_XIP_SECTION_ERROR,
- "Attempt to delete non-final section %d\n",
- i_sectionId);
- break;
- }
-
- xipSetSectionOffset(io_image, i_sectionId, 0);
- xipSetSectionSize(io_image, i_sectionId, 0);
-
-
- // For cleanliness we also remove any alignment padding that had been
- // appended between the now-last section and the deleted section, then
- // re-establish the final alignment. The assumption is that all images
- // always have the correct final alignment, so there is no way this
- // could overflow a designated buffer space since the image size is
- // the same or has been reduced.
-
- rc = xipFinalSection(io_image, &final);
- if (rc) break;
-
- rc = sbe_xip_get_section(io_image, final, &section);
- if (rc) break;
-
- xipSetImageSize(io_image, section.iv_offset + section.iv_size);
- xipFinalAlignment(io_image);
-
- } while (0);
-
- return rc;
-}
-
-
-#ifndef PPC_HYP
-
-// This API is not needed by PHYP procedures, and is elided since PHYP does
-// not support malloc().
-
-int
-sbe_xip_duplicate_section(const void* i_image,
- const int i_sectionId,
- void** o_duplicate,
- uint32_t* o_size)
-{
- SbeXipSection section;
- int rc;
-
- *o_duplicate = 0;
-
- do {
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- rc = sbe_xip_get_section(i_image, i_sectionId, &section);
- if (rc) break;
-
- if (section.iv_size == 0) {
- rc = TRACE_ERRORX(SBE_XIP_SECTION_ERROR,
- "Attempt to duplicate empty section %d\n",
- i_sectionId);
- break;
- }
-
- *o_duplicate = malloc(section.iv_size);
- *o_size = section.iv_size;
-
- if (*o_duplicate == 0) {
- rc = TRACE_ERROR(SBE_XIP_NO_MEMORY);
- break;
- }
-
- memcpy(*o_duplicate,
- xipHostAddressFromOffset(i_image, section.iv_offset),
- section.iv_size);
-
-
- } while (0);
-
- if (rc) {
- free(*o_duplicate);
- *o_duplicate = 0;
- *o_size = 0;
- }
-
- return rc;
-}
-
-#endif // PPC_HYP
-
-
-// The append must be done in such a way that if the append fails, the image
-// is not modified. This behavior is required by applications that
-// speculatively append until the allocation fails, but still require the
-// final image to be valid. To accomplish this the initial image size and
-// section statistics are captured at entry, and restored in the event of an
-// error.
-
-int
-sbe_xip_append(void* io_image,
- const int i_sectionId,
- const void* i_data,
- const uint32_t i_size,
- const uint32_t i_allocation,
- uint32_t* o_sectionOffset)
-{
- SbeXipSection section, initialSection;
- int rc, final, restoreOnError;
- void* hostAddress;
- uint32_t pad, initialSize;
-
- do {
- restoreOnError = 0;
-
- rc = xipQuickCheck(io_image, 1);
- if (rc) break;
-
- rc = sbe_xip_get_section(io_image, i_sectionId, &section);
- if (rc) break;
-
- if (i_size == 0) break;
-
- initialSection = section;
- initialSize = xipImageSize(io_image);
- restoreOnError = 1;
-
- if (section.iv_size == 0) {
-
- // The section is empty, and now becomes the final section. Pad
- // the image to the specified section alignment. Note that the
- // size of the previously final section does not change.
-
- rc = xipPadImage(io_image, i_allocation, section.iv_alignment,
- &pad);
- if (rc) break;
- section.iv_offset = xipImageSize(io_image);
-
- } else {
-
- // Otherwise, the section must be the final section in order to
- // continue. Remove any padding from the image.
-
- rc = xipFinalSection(io_image, &final);
- if (rc) break;
-
- if (final != i_sectionId) {
- rc = TRACE_ERRORX(SBE_XIP_SECTION_ERROR,
- "Attempt to append to non-final section "
- "%d\n", i_sectionId);
- break;
- }
- xipSetImageSize(io_image, section.iv_offset + section.iv_size);
- }
-
-
- // Make sure the allocated space won't overflow. Set the return
- // parameter o_sectionOffset and copy the new data into the image (or
- // simply clear the space).
-
- if ((xipImageSize(io_image) + i_size) > i_allocation) {
- rc = TRACE_ERROR(SBE_XIP_WOULD_OVERFLOW);
- break;
- }
- if (o_sectionOffset != 0) {
- *o_sectionOffset = section.iv_size;
- }
-
- hostAddress =
- xipHostAddressFromOffset(io_image, xipImageSize(io_image));
- if (i_data == 0) {
- memset(hostAddress, 0, i_size);
- } else {
- memcpy(hostAddress, i_data, i_size);
- }
-
-
- // Update the image size and section table. Note that the final
- // alignment may push out of the allocation.
-
- xipSetImageSize(io_image, xipImageSize(io_image) + i_size);
- xipFinalAlignment(io_image);
-
- if (xipImageSize(io_image) > i_allocation) {
- rc = TRACE_ERROR(SBE_XIP_WOULD_OVERFLOW);
- break;
- }
-
- section.iv_size += i_size;
-
- if (xipPutSection(io_image, i_sectionId, &section) != 0) {
- rc = TRACE_ERROR(SBE_XIP_BUG); /* Can't happen */
- break;
- }
-
-
- // Special case
-
- if (i_sectionId == SBE_XIP_SECTION_TOC) {
- ((SbeXipHeader*)io_image)->iv_tocSorted = 0;
- }
-
- } while (0);
-
- if (rc && restoreOnError) {
- if (xipPutSection(io_image, i_sectionId, &initialSection) != 0) {
- rc = TRACE_ERROR(SBE_XIP_BUG); /* Can't happen */
- }
- xipSetImageSize(io_image, initialSize);
- }
-
- return rc;
-}
-
-
-int
-sbe_xip_section2image(const void* i_image,
- const int i_sectionId,
- const uint32_t i_offset,
- uint64_t* o_imageAddress)
-{
- int rc;
- SbeXipSection section;
-
- do {
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- rc = sbe_xip_get_section(i_image, i_sectionId, &section);
- if (rc) break;
-
- if (section.iv_size == 0) {
- rc = TRACE_ERROR(SBE_XIP_SECTION_ERROR);
- break;
- }
-
- if (i_offset > (section.iv_offset + section.iv_size)) {
- rc = TRACE_ERROR(SBE_XIP_INVALID_ARGUMENT);
- break;
- }
-
- *o_imageAddress = xipLinkAddress(i_image) + section.iv_offset + i_offset;
-
- if (*o_imageAddress % 4) {
- rc = TRACE_ERROR(SBE_XIP_ALIGNMENT_ERROR);
- break;
- }
-
- } while(0);
-
- return rc;
-}
-
-
-int
-sbe_xip_image2section(const void* i_image,
- const uint64_t i_imageAddress,
- int* i_section,
- uint32_t* i_offset)
-{
- int rc;
-
- do {
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- rc = xipImage2Section(i_image, i_imageAddress, i_section, i_offset);
-
- } while(0);
-
- return rc;
-}
-
-
-int
-sbe_xip_image2host(const void* i_image,
- const uint64_t i_imageAddress,
- void** o_hostAddress)
-{
- int rc;
-
- do {
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- if ((i_imageAddress < xipLinkAddress(i_image)) ||
- (i_imageAddress >
- (xipLinkAddress(i_image) + xipImageSize(i_image)))) {
- rc = TRACE_ERROR(SBE_XIP_INVALID_ARGUMENT);
- break;
- }
-
- *o_hostAddress =
- xipHostAddressFromOffset(i_image,
- i_imageAddress - xipLinkAddress(i_image));
- } while(0);
-
- return rc;
-}
-
-
-int
-sbe_xip_host2image(const void* i_image,
- void* i_hostAddress,
- uint64_t* o_imageAddress)
-{
- int rc;
-
- do {
- rc = xipQuickCheck(i_image, 0);
- if (rc) break;
-
- if ((i_hostAddress < i_image) ||
- (i_hostAddress >
- xipHostAddressFromOffset(i_image, xipImageSize(i_image)))) {
- rc = TRACE_ERROR(SBE_XIP_INVALID_ARGUMENT);
- break;
- }
-
- *o_imageAddress = xipLinkAddress(i_image) +
- ((unsigned long)i_hostAddress - (unsigned long)i_image);
- if (*o_imageAddress % 4) {
- rc = TRACE_ERROR(SBE_XIP_ALIGNMENT_ERROR);
- break;
- }
- } while(0);
-
- return rc;
-}
-
-
-void
-sbe_xip_translate_header(SbeXipHeader* o_dest, const SbeXipHeader* i_src)
-{
-#ifndef _BIG_ENDIAN
- int i;
- SbeXipSection* destSection;
- const SbeXipSection* srcSection;
-
-#if SBE_XIP_HEADER_VERSION != 8
-#error This code assumes the SBE-XIP header version 8 layout
-#endif
-
- o_dest->iv_magic = xipRevLe64(i_src->iv_magic);
- o_dest->iv_entryOffset = xipRevLe64(i_src->iv_entryOffset);
- o_dest->iv_linkAddress = xipRevLe64(i_src->iv_linkAddress);
-
- for (i = 0; i < 5; i++) {
- o_dest->iv_reserved64[i] = 0;
- }
-
- for (i = 0, destSection = o_dest->iv_section,
- srcSection = i_src->iv_section;
- i < SBE_XIP_SECTIONS;
- i++, destSection++, srcSection++) {
- xipTranslateSection(destSection, srcSection);
- }
-
- o_dest->iv_imageSize = xipRevLe32(i_src->iv_imageSize);
- o_dest->iv_buildDate = xipRevLe32(i_src->iv_buildDate);
- o_dest->iv_buildTime = xipRevLe32(i_src->iv_buildTime);
-
- for (i = 0; i < 5; i++) {
- o_dest->iv_reserved32[i] = 0;
- }
-
- o_dest->iv_headerVersion = i_src->iv_headerVersion;
- o_dest->iv_normalized = i_src->iv_normalized;
- o_dest->iv_tocSorted = i_src->iv_tocSorted;
-
- for (i = 0; i < 3; i++) {
- o_dest->iv_reserved8[i] = 0;
- }
-
- memcpy(o_dest->iv_buildUser, i_src->iv_buildUser,
- sizeof(i_src->iv_buildUser));
- memcpy(o_dest->iv_buildHost, i_src->iv_buildHost,
- sizeof(i_src->iv_buildHost));
- memcpy(o_dest->iv_reservedChar, i_src->iv_reservedChar,
- sizeof(i_src->iv_reservedChar));
-
-#else
- if (o_dest != i_src) {
- *o_dest = *i_src;
- }
-#endif /* _BIG_ENDIAN */
-}
-
-
-int
-sbe_xip_map_toc(void* io_image,
- int (*i_fn)(void* io_image,
- const SbeXipItem* i_item,
- void* io_arg),
- void* io_arg)
-{
- int rc;
- SbeXipToc *imageToc;
- SbeXipItem item;
- size_t entries;
-
- do {
- rc = xipQuickCheck(io_image, 0);
- if (rc) break;
-
- rc = xipGetToc(io_image, &imageToc, &entries, 0, 0);
- if (rc) break;
-
- for (; entries--; imageToc++) {
- rc = xipDecodeToc(io_image, imageToc, &item);
- if (rc) break;
- rc = i_fn(io_image, &item, io_arg);
- if (rc) break;
- }
- } while(0);
-
- return rc;
-}
diff --git a/sbe/image/sbe_xip_image.h b/sbe/image/sbe_xip_image.h
deleted file mode 100644
index b295a569..00000000
--- a/sbe/image/sbe_xip_image.h
+++ /dev/null
@@ -1,1724 +0,0 @@
-//-----------------------------------------------------------------------------
-// *! (C) Copyright International Business Machines Corp. 2014
-// *! All Rights Reserved -- Property of IBM
-// *! *** IBM Confidential ***
-//-----------------------------------------------------------------------------
-
-/// \file sbe_xip_image.h
-/// \brief definition of structs in sections
-///
-/// Contains struct ProcSbeFixed which contains functions, rings and
-/// attributes whose pointers are stored in the fixed and fixed_toc section
-/// Everything related to creating and manipulating SBE-XIP binary images
-
-#ifndef __SBE_XIP_IMAGE_H
-#define __SBE_XIP_IMAGE_H
-
-#include "fapi_sbe_common.H"
-
-/// Current version (fields, layout, sections) of the SBE_XIP header
-///
-/// If any changes are made to this file or to sbe_xip_header.H, please update
-/// the header version and follow-up on all of the error messages.
-
-#define SBE_XIP_HEADER_VERSION 8
-
-/// \defgroup sbe_xip_magic_numbers SBE-XIP magic numbers
-///
-/// An SBE-XIP magic number is a 64-bit constant. The 4 high-order bytes
-/// contain the ASCII characters "XIP " and identify the image as an SBE-XIP
-/// image, while the 4 low-order bytes identify the type of the image.
-///
-/// @{
-
-#define SBE_XIP_MAGIC 0x58495020 // "XIP "
-#define SBE_BASE_MAGIC ULL(0x5849502042415345) // "XIP BASE"
-#define SBE_SEEPROM_MAGIC ULL(0x584950205345504d) // "XIP SEPM"
-#define SBE_CENTAUR_MAGIC ULL(0x58495020434e5452) // "XIP CNTR"
-
-/// @}
-
-
-/// \defgroup sbe_xip_sections SBE-XIP Image Section Indexes
-///
-/// These constants define the order that the SbeXipSection structures appear
-/// in the header, which is not necessarily the order the sections appear in
-/// the binary image. Given that SBE-XIP image contents are tightly
-/// controlled, we use this simple indexing scheme for the allowed sections
-/// rather than a more general approach, e.g., allowing arbitrary sections
-/// identified by their names.
-///
-/// @{
-
-// -*- DO NOT REORDER OR EDIT THIS SET OF CONSTANTS WITHOUT ALSO EDITING -*-
-// -*- THE ASSEMBLER LAYOUT IN sbe_xip_header.H. -*-
-
-#define SBE_XIP_SECTION_HEADER 0
-#define SBE_XIP_SECTION_FIXED 1
-#define SBE_XIP_SECTION_FIXED_TOC 2
-#define SBE_XIP_SECTION_LOADER_TEXT 3
-#define SBE_XIP_SECTION_LOADER_DATA 4
-#define SBE_XIP_SECTION_TEXT 5
-#define SBE_XIP_SECTION_DATA 6
-#define SBE_XIP_SECTION_TOC 7
-#define SBE_XIP_SECTION_STRINGS 8
-#define SBE_XIP_SECTION_BASE 9
-#define SBE_XIP_SECTION_BASELOADER 10
-#define SBE_XIP_SECTION_OVERLAYS 11
-#define SBE_XIP_SECTION_RINGS 12
-#define SBE_XIP_SECTION_HBBL 13
-
-#define SBE_XIP_SECTIONS 14
-
-/// @}
-
-
-/// \defgroup sbe_xip_validate() ignore masks.
-///
-/// These defines, when matched in sbe_xip_validate(), cause the validation
-/// to skip the check of the corresponding property. The purpose is to more
-/// effectively debug images that may be damaged and which have excess info
-/// before or after the image. The latter will be the case when dumping the
-/// image as a memory block without knowing where the image starts and ends.
-///
-/// @{
-
-#define SBE_XIP_IGNORE_FILE_SIZE (uint32_t)0x00000001
-#define SBE_XIP_IGNORE_ALL (uint32_t)0x80000000
-
-/// @}
-
-
-#ifndef __ASSEMBLER__
-
-/// Applications can expand this macro to create an array of section names.
-#define SBE_XIP_SECTION_NAMES(var) \
- const char* var[] = { \
- ".header", \
- ".fixed", \
- ".fixed_toc", \
- ".loader_text", \
- ".loader_data", \
- ".text", \
- ".data", \
- ".toc", \
- ".strings", \
- ".base", \
- ".baseloader", \
- ".overlays", \
- ".rings", \
- ".hbbl", \
- }
-
-/// Applications can use this macro to safely index the array of section
-/// names.
-#define SBE_XIP_SECTION_NAME(var, n) \
- ((((n) < 0) || ((n) > (int)(sizeof(var) / sizeof(char*)))) ? \
- "Bug : Invalid SBE-XIP section name" : var[n])
-
-
-#endif /* __ASSEMBLER__ */
-
-
-/// Maximum section alignment for SBE-XIP sections
-#define SBE_XIP_MAX_SECTION_ALIGNMENT 128
-
-/// \defgroup sbe_xip_toc_types SBE-XIP Table of Contents data types
-///
-/// These are the data types stored in the \a iv_type field of the SbeXipToc
-/// objects. These must be defined as manifest constants because they are
-/// required to be recognized as manifest constants in C (as opposed to C++)
-/// code.
-///
-/// NB: The 0x0 code is purposefully left undefined to catch bugs.
-///
-/// @{
-
-/// Data is a single unsigned byte
-#define SBE_XIP_UINT8 0x01
-
-/// Data is a 16-bit unsigned integer
-#define SBE_XIP_UINT16 0x02
-
-/// Data is a 32-bit unsigned integer
-#define SBE_XIP_UINT32 0x03
-
-/// Data is a 64-bit unsigned integer
-#define SBE_XIP_UINT64 0x04
-
-/// Data is a single signed byte
-#define SBE_XIP_INT8 0x05
-
-/// Data is a 16-bit signed integer
-#define SBE_XIP_INT16 0x06
-
-/// Data is a 32-bit signed integer
-#define SBE_XIP_INT32 0x07
-
-/// Data is a 64-bit signed integer
-#define SBE_XIP_INT64 0x08
-
-/// Data is a 0-byte terminated ASCII string
-#define SBE_XIP_STRING 0x09
-
-/// Data is an address
-#define SBE_XIP_ADDRESS 0x0A
-
-/// The maximum type number
-#define SBE_XIP_MAX_TYPE_INDEX 0x0A
-
-/// Applications can expand this macro to get access to string forms of the
-/// SBE-XIP data types if desired.
-#define SBE_XIP_TYPE_STRINGS(var) \
- const char* var[] = { \
- "Illegal 0 Code", \
- "SBE_XIP_UINT8", \
- "SBE_XIP_UINT16", \
- "SBE_XIP_UINT32", \
- "SBE_XIP_UINT64", \
- "SBE_XIP_INT8", \
- "SBE_XIP_INT16", \
- "SBE_XIP_INT32", \
- "SBE_XIP_INT64", \
- "SBE_XIP_STRING", \
- "SBE_XIP_ADDRESS", \
- }
-
-/// Applications can expand this macro to get access to abbreviated string
-/// forms of the SBE-XIP data types if desired.
-#define SBE_XIP_TYPE_ABBREVS(var) \
- const char* var[] = { \
- "Illegal 0 Code", \
- "u8 ", \
- "u16", \
- "u32", \
- "u64", \
- "i8 ", \
- "i16", \
- "i32", \
- "i64", \
- "str", \
- "adr", \
- }
-
-/// Applications can use this macro to safely index either array of SBE-XIP
-/// type strings.
-#define SBE_XIP_TYPE_STRING(var, n) \
- (((n) > (sizeof(var) / sizeof(char*))) ? \
- "Invalid SBE-XIP type specification" : var[n])
-
-/// @}
-
-
-/// Final alignment constraint for SBE-XIP images.
-///
-/// images are required to be multiples of 8 bytes in length, to
-/// gaurantee that the something will be able to complete any 8-byte load/store.
-#define SBE_XIP_FINAL_ALIGNMENT 8
-
-
-////////////////////////////////////////////////////////////////////////////
-// C Definitions
-////////////////////////////////////////////////////////////////////////////
-
-#ifndef __ASSEMBLER__
-
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#if 0
-} /* So __cplusplus doesn't mess w/auto-indent */
-#endif
-
-/// SBE-XIP Section information
-///
-/// This structure defines the data layout of section table entries in the
-/// SBE-XIP image header.
-
-// -*- DO NOT REORDER OR EDIT THIS STRUCTURE DEFINITION WITHOUT ALSO -*-
-// -*- EDITING THE ASSEMBLER LAYOUT IN sbe_xip_header.H -*-
-
-typedef struct {
-
- /// The offset (in bytes) of the section from the beginning of the image
- ///
- /// In normalized images the section offset will always be 0 if the
- /// section size is also 0.
- uint32_t iv_offset;
-
- /// The size of the section in bytes, exclusive of alignment padding
- ///
- /// This is the size of the program-significant data in the section,
- /// exclusive of any alignment padding or reserved or extra space. The
- /// alignment padding (reserved space) is not represented explicitly, but
- /// is only implied by the offset of any subsequent non-empty section, or
- /// in the case of the final section in the image, the image size.
- ///
- /// Regardless of the \a iv_offset, if the \a iv_size of a section is 0 it
- /// should be considered "not present" in the image. In normalized images
- /// the section offset will always be 0 if the section size is also 0.
- uint32_t iv_size;
-
- /// The required initial alignment for the section offset
- ///
- /// The image and the applications using SBE-XIP images have strict
- /// alignment/padding requirements. The image does not handle any type of
- /// unaligned instruction or data fetches. Some sections and subsections
- /// must also be POWER cache-line aligned. The \a iv_alignment applies to
- /// the first byte of the section. image images are also required to be
- /// multiples of 8 bytes in length, to gaurantee that the something will be
- /// able to complete any 8-byte load/store. These constraints are checked
- /// by sbe_xip_validate() and enforced by sbe_xip_append(). The alignment
- /// constraints may force a section to be padded, which may create "holes"
- /// in the image as explained in the comments for the \a iv_size field.
- ///
- /// Note that alignment constraints are always checked relative to the
- /// first byte of the image for in-memory images, not relative to the host
- /// address. Alignment specifications are required to be a power-of-2.
- uint8_t iv_alignment;
-
- /// Reserved structure alignment padding; Pad to 12 bytes
- uint8_t iv_reserved8[3];
-
-} SbeXipSection;
-
-/// The SbeXipSection structure is created by assembler code and is expected
-/// to have the same size in C code. This constraint is checked in
-/// sbe_xip_validate().
-#define SIZE_OF_SBE_XIP_SECTION 12
-
-
-/// SBE-XIP binary image header
-///
-/// This header occupies the initial bytes of an SBE-XIP binary image.
-/// The header contents are documented here, however the structure is actually
-/// defined in the file sbe_xip_header.S, and these two definitions must be
-/// kept consistent.
-///
-/// The header is a fixed-format representation of the most critical
-/// information about the image. The large majority of information about the
-/// image and its contents are available through the searchable table of
-/// contents. image code itself normally accesses the data directly through
-/// global symbols.
-///
-/// The header only contains information 1) required by OTPROM code (e.g., the
-/// entry point); 2) required by search and updating APIs (e.g., the
-/// locations and sizes of all of the sections.); a few pieces of critical
-/// meta-data (e.g., information about the image build process).
-///
-/// Any entries that are accessed by image code are required to be 64 bits, and
-/// will appear at the beginning of the header.
-///
-/// The header also contains bytewise offsets and sizes of all of the sections
-/// that are assembled to complete the image. The offsets are relative to the
-/// start of the image (where the header is loaded). The sizes include any
-/// padding inserted by the link editor to guarantee section alignment.
-///
-/// Every field of the header is also accesssible through the searchable table
-/// of contents as documented in sbe_xip_header.S.
-
-// -*- DO NOT REORDER OR EDIT THIS STRUCTURE DEFINITION WITHOUT ALSO -*-
-// -*- EDITING THE ASSEMBLER LAYOUT IN sbe_xip_header.S, AND WITHOUT -*-
-// -*- UPDATING THE sbe_xip_translate_header() API IN sbe_xip_image.c. -*-
-
-typedef struct {
-
- //////////////////////////////////////////////////////////////////////
- // Identification - 8-byte aligned; 8 entries
- //////////////////////////////////////////////////////////////////////
-
- /// Contains SBE_XIP_MAGIC to identify an SBE-XIP image
- uint64_t iv_magic;
-
- /// The offset of the SBE-XIP entry point from the start of the image
- uint64_t iv_entryOffset;
-
- /// The base address used to link the image, as a full relocatable image
- /// address
- uint64_t iv_linkAddress;
-
- /// The entry address of base loader
- uint64_t iv_entryAddressSBE;
-
- /// Reserved for future expansion
- uint64_t iv_reserved64[4];
-
- //////////////////////////////////////////////////////////////////////
- // Section Table - 4-byte aligned; 16 entries
- //////////////////////////////////////////////////////////////////////
-
- SbeXipSection iv_section[SBE_XIP_SECTIONS];
-
- //////////////////////////////////////////////////////////////////////
- // Other information - 4-byte aligned; 8 entries
- //////////////////////////////////////////////////////////////////////
-
- /// The size of the image (including padding) in bytes
- uint32_t iv_imageSize;
-
- /// Build date generated by `date +%Y%m%d`, e.g., 20110630
- uint32_t iv_buildDate;
-
- /// Build time generated by `date +%H%M`, e.g., 0756
- uint32_t iv_buildTime;
-
- /// Reserved for future expansion
- uint32_t iv_reserved32[5];
-
- //////////////////////////////////////////////////////////////////////
- // Other Information - 1-byte aligned; 8 entries
- //////////////////////////////////////////////////////////////////////
-
- /// Header format version number
- uint8_t iv_headerVersion;
-
- /// Indicates whether the image has been normalized (0/1)
- uint8_t iv_normalized;
-
- /// Indicates whether the TOC has been sorted to speed searching (0/1)
- uint8_t iv_tocSorted;
-
- /// Reserved for future expansion
- uint8_t iv_reserved8[5];
-
- //////////////////////////////////////////////////////////////////////
- // Strings; 64 characters allocated
- //////////////////////////////////////////////////////////////////////
-
- /// Build user, generated by `id -un`
- char iv_buildUser[16];
-
- /// Build host, generated by `hostname`
- char iv_buildHost[24];
-
- /// Reserved for future expansion
- char iv_reservedChar[24];
-
-} SbeXipHeader;
-
-
-
-/// A C-structure form of the SBE-XIP Table of Contents (TOC) entries
-///
-/// The .toc section consists entirely of an array of these structures.
-/// TOC entries are never accessed by image code.
-///
-/// These structures store indexing information for global data required to be
-/// manipulated by external tools. The actual data is usually allocated in a
-/// data section and manipulated by the SBE code using global or local symbol
-/// names. Each TOC entry contains a pointer to a keyword string naming the
-/// data, the address of the data (or the data itself), the data type,
-/// meta-information about the data, and for vectors the vector size.
-
-// -*- DO NOT REORDER OR EDIT THIS STRUCTURE DEFINITION WITHOUT ALSO -*-
-// -*- EDITING THE ASSEMBLER MACROS (BELOW) THAT CREATE THE TABLE OF -*-
-// -*- CONTENTS ENTRIES. -*-
-
-typedef struct {
-
- /// A pointer to a 0-byte terminated ASCII string identifying the data.
- ///
- /// When allocated by the .xip_toc macro this is a pointer to the string
- /// form of the symbol name for the global or local symbol associated with
- /// the data which is allocated in the .strings section. This pointer is
- /// not aligned.
- ///
- /// When the image is normalized this pointer is replaced by the offset of
- /// the string in the .strings section.
- uint32_t iv_id;
-
- /// A 32-bit pointer locating the data
- ///
- /// This field is initially populated by the link editor. For scalar,
- /// vector and string types this is the final relocated address of the
- /// first byte of the data. For address types, this is the relocated
- /// address. When the image is normalized, these addresses are converted
- /// into the equivalent offsets from the beginning of the section holding
- /// the data.
- uint32_t iv_data;
-
- /// The type of the data; See \ref sbe_xip_toc_types.
- uint8_t iv_type;
-
- /// The section containing the data; See \ref sbe_xip_sections.
- uint8_t iv_section;
-
- /// The number of elements for vector types, otherwise 1 for scalar types
- /// and addresses.
- ///
- /// Vectors are naturally limited in size, e.g. to the number of cores,
- /// chips in a node, DD-levels etc. If \a iv_elements is 0 then no bounds
- /// checking is done on get/set accesses of the data.
- uint8_t iv_elements;
-
- /// Structure alignment padding; Pad to 12 bytes
- uint8_t iv_pad;
-
-} SbeXipToc;
-
-/// The SbeXipToc structure is created by assembler code and is expected
-/// to have the same size in C code. This constraint is checked in
-/// sbe_xip_validate().
-#define SIZE_OF_SBE_XIP_TOC 12
-
-
-/// A C-structure form of hashed SBE-XIP Table of Contents (TOC) entries
-///
-/// This structure was introduced in order to allow a small TOC for the .fixed
-/// section to support minimum-sized SEEPROM images in which the global TOC
-/// and all strings have been stripped out. In this structure the index
-/// string has been replaced by a 32-bit hash, and there is no longer a record
-/// of the original data name other then the hash. The section of the data is
-/// assumed to be .fixed, with a maximum 16-bit offset.
-///
-/// These structures are created when entries are made in the .fixed section.
-/// They are created empty, then filled in during image normalization.
-///
-/// This structure allows the sbe_xip_get*() and sbe_xip_set*() APIs to work
-/// even on highly-stripped SEEPROM images.
-
-typedef struct {
-
- /// A 32-bit hash (FNV-1a) of the Id string.
- uint32_t iv_hash;
-
- /// The offset in bytes from the start of the (implied) section of the data
- uint16_t iv_offset;
-
- /// The type of the data; See \ref sbe_xip_toc_types.
- uint8_t iv_type;
-
- /// The number of elements for vector types, otherwise 1 for scalar types
- /// and addresses.
- ///
- /// Vectors are naturally limited in size, e.g. to the number of cores,
- /// chips in a node, DD-levels etc. If \a iv_elements is 0 then no bounds
- /// checking is done on get/set accesses of the data.
- uint8_t iv_elements;
-
-} SbeXipHashedToc;
-
-/// The SbeXipHashedToc structure is created by assembler code and is expected
-/// to have the same size in C code. This constraint is checked in
-/// sbe_xip_validate().
-#define SIZE_OF_SBE_XIP_HASHED_TOC 8
-
-
-/// A decoded TOC entry for use by applications
-///
-/// This structure is a decoded form of a normalized TOC entry, filled in by
-/// the sbe_xip_decode_toc() and sbe_xip_find() APIs. This structure is
-/// always returned with data elements in host-endian format.
-///
-/// In the event that the TOC has been removed from the image, this structure
-/// will also be returned by sbe_xip_find() with information populated from
-/// the .fixed_toc section if possible. In this case the field \a iv_partial
-/// will be set and only the fields \a iv_address, \a iv_imageData, \a iv_type
-/// and \a iv_elements will be populated (all other fields will be set to 0).
-///
-/// \note Only special-purpose applications will ever need to use this
-/// structure given that the higher-level APIs sbe_xip_get_*() and
-/// sbe_xip_set_*() are provided and should be used if possible, especially
-/// given that the information may be truncated as described above.
-
-typedef struct {
-
- /// A pointer to the associated TOC entry as it exists in the image
- ///
- /// If \a iv_partial is set this field is returned as 0.
- SbeXipToc* iv_toc;
-
- /// The full relocatable image address
- ///
- /// All relocatable addresses are computed from the \a iv_linkAddress
- /// stored in the header. For scalar and string data, this is the
- /// relocatable address of the data. For address-only entries, this is
- /// the indexed address itself.
- uint64_t iv_address;
-
- /// A host pointer to the first byte of text or data within the image
- ///
- /// For scalar or string types this is a host pointer to the first byte of
- /// the data. For code pointers (addresses) this is host pointer to the
- /// first byte of code. Note that any use of this field requires the
- /// caller to handle conversion of the data to host endian-ness if
- /// required. Only 8-bit and string data can be used directly on all
- /// hosts.
- void* iv_imageData;
-
- /// The item name
- ///
- /// This is a pointer in host memory to a string that names the TOC entry
- /// requested. This field is set to a pointer to the ID string of the TOC
- /// entry inside the image. If \a iv_partial is set this field is returned
- /// as 0.
- char* iv_id;
-
- /// The data type, one of the SBE_XIP_* constants
- uint8_t iv_type;
-
- /// The number of elements in a vector
- ///
- /// This field is set from the TOC entry when the TOC entry is
- /// decoded. This value is stored as 1 for scalar declarations, and may be
- /// set to 0 for vectors with large or undeclared sizes. Otherwise it is
- /// used to bounds check indexed accesses.
- uint8_t iv_elements;
-
- /// Is this record only partially populated?
- ///
- /// This field is set to 0 normally, and only set to 1 if a lookup is made
- /// in an image that only has the fixed TOC and the requested Id hashes to
- /// the fixed TOC.
- uint8_t iv_partial;
-
-} SbeXipItem;
-
-
-/// Validate an SBE-XIP image
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory.
-///
-/// \param[in] i_size The putative size of the image
-///
-/// \param[in] i_maskIgnores Array of ignore bits representing which properties
-/// should not be checked for in sbe_xip_validate2().
-///
-/// This API should be called first by all applications that manipulate
-/// SBE-XIP images in host memory. The magic number is validated, and
-/// the image is checked for consistency of the section table and table of
-/// contents. The \a iv_imageSize field of the header must also match the
-/// provided \a i_size parameter. Validation does not modify the image.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_validate(void* i_image, const uint32_t i_size);
-
-int
-sbe_xip_validate2(void* i_image, const uint32_t i_size, const uint32_t i_maskIgnores);
-
-
-/// Normalize the SBE-XIP image
-///
-/// \param[in] io_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections.
-///
-/// SBE-XIP images must be normalized before any other APIs are allowed to
-/// operate on the image. Since normalization modifies the image, an explicit
-/// call to normalize the image is required. Briefly, normalization modifies
-/// the TOC entries created by the final link to simplify search, updates,
-/// modification and relocation of the image. Normalization is explained in
-/// the written documentation of the SBE-XIP binary format. Normalization does
-/// not modify the size of the image.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_normalize(void* io_image);
-
-
-/// Return the size of an SBE-XIP image from the image header
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections.
-///
-/// \param[out] o_size A pointer to a variable returned as the size of the
-/// image in bytes, as recorded in the image header.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_image_size(void* i_image, uint32_t* o_size);
-
-
-/// Locate a section table entry and translate into host format
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory.
-///
-/// \param[in] i_sectionId Identifies the section to be queried. See \ref
-/// sbe_xip_sections.
-///
-/// \param[out] o_hostSection Updated to contain the section table entry
-/// translated to host byte order.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_get_section(const void* i_image,
- const int i_sectionId,
- SbeXipSection* o_hostSection);
-
-
-/// Endian translation of an SbeXipHeader object
-///
-/// \param[out] o_hostHeader The destination object.
-///
-/// \param[in] i_imageHeader The source object.
-///
-/// Translation of a SbeXipHeader includes translation of all data members
-/// including traslation of the embedded section table. This translation
-/// works even if \a o_src == \a o_dest, i.e., in the destructive case.
-void
-sbe_xip_translate_header(SbeXipHeader* o_hostHeader,
- const SbeXipHeader* i_imageHeader);
-
-
-/// Get scalar data from an SBE-XIP image
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_id A pointer to a 0-terminated ASCII string naming the item
-/// requested.
-///
-/// \param[out] o_data A pointer to an 8-byte integer to receive the scalar
-/// data. Assuming the item is located this variable is assigned by the call.
-/// In the event of an error the final state of \a o_data is not specified.
-///
-/// This API searches the SBE-XIP Table of Contents (TOC) for the item named
-/// \a i_id, assigning \a o_data from the image if the item is found and is a
-/// scalar value. Scalar values include 8- 32- and 64-bit integers and image
-/// addresses. Image data smaller than 64 bits are extracted as unsigned
-/// types, and it is the caller's responsibility to cast or convert the
-/// returned data as appropriate.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_get_scalar(void *i_image, const char* i_id, uint64_t* o_data);
-
-
-/// Get an integral element from a vector held in an SBE-XIP image
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_id A pointer to a 0-terminated ASCII string naming the item
-/// requested.
-///
-/// \param[in] i_index The index of the vector element to return.
-///
-/// \param[out] o_data A pointer to an 8-byte integer to receive the
-/// data. Assuming the item is located this variable is assigned by the call.
-/// In the event of an error the final state of \a o_data is not specified.
-///
-/// This API searches the SBE-XIP Table of Contents (TOC) for the \a i_index
-/// element of the item named \a i_id, assigning \a o_data from the image if
-/// the item is found, is a vector of an integral type, and the \a i_index is
-/// in bounds. Vector elements smaller than 64 bits are extracted as unsigned
-/// types, and it is the caller's responsibility to cast or convert the
-/// returned data as appropriate.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_get_element(void *i_image,
- const char* i_id,
- const uint32_t i_index,
- uint64_t* o_data);
-
-
-/// Get string data from an SBE-XIP image
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_id A pointer to a 0-terminated ASCII string naming the item
-/// requested.
-///
-/// \param[out] o_data A pointer to a character pointer. Assuming the
-/// item is located this variable is assigned by the call to point to the
-/// string as it exists in the \a i_image. In the event of an error the final
-/// state of \a o_data is not specified.
-///
-/// This API searches the SBE-XIP Table of Contents (TOC) for the item named
-/// \a i_id, assigning \a o_data if the item is found and is a string. It is
-/// the caller's responsibility to copy the string from the \a i_image memory
-/// space if necessary.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_get_string(void *i_image, const char* i_id, char** o_data);
-
-
-/// Directly read 64-bit data from the image based on a image address
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections.
-///
-/// \param[in] i_imageAddress A relocatable IMAGE address contained in the
-/// image, presumably of an 8-byte data area. The \a i_imageAddress is
-/// required to be 8-byte aligned, otherwise the SBE_XIP_ALIGNMENT_ERROR code
-/// is returned.
-///
-/// \param[out] o_data The 64 bit data in host format that was found at \a
-/// i_imageAddress.
-///
-/// This API is provided for applications that need to manipulate SBE-XIP
-/// images in terms of their relocatable IMAGE addresses. The API checks that
-/// the \a i_imageAddress is properly aligned and contained in the image, then
-/// reads the contents of \a i_imageAddress into \a o_data, performing
-/// image-to-host endianess conversion if required.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_read_uint64(const void *i_image,
- const uint64_t i_imageAddress,
- uint64_t* o_data);
-
-
-/// Set scalar data in an SBE-XIP image
-///
-/// \param[in,out] io_image A pointer to an SBE-XIP image in host memory.
-/// The image is assumed to be consistent with the information contained in
-/// the header regarding the presence of and sizes of all sections. The image
-/// is also required to have been normalized.
-///
-/// \param[in] i_id A pointer to a 0-terminated ASCII string naming the item
-/// to be modified.
-///
-/// \param[in] i_data The new scalar data.
-///
-/// This API searches the SBE-XIP Table of Contents (TOC) for the item named
-/// by \a i_id, updating the image from \a i_data if the item is found, has
-/// a scalar type and can be modified. For this API the scalar types include
-/// 8- 32- and 64-bit integers. Although IMAGE addresses are considered a
-/// scalar type for sbe_xip_get_scalar(), IMAGE addresses can not be modified
-/// by this API. The caller is responsible for ensuring that the \a i_data is
-/// of the correct size for the underlying data element in the image.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_set_scalar(void* io_image, const char* i_id, const uint64_t i_data);
-
-
-/// Set an integral element in a vector held in an SBE-XIP image
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_id A pointer to a 0-terminated ASCII string naming the item
-/// to be updated.
-///
-/// \param[in] i_index The index of the vector element to update.
-///
-/// \param[out] i_data The new vector element.
-///
-/// This API searches the SBE-XIP Table of Contents (TOC) for the \a i_index
-/// element of the item named \a i_id, update the image from \a i_data if the
-/// item is found, is a vector of an integral type, and the \a i_index is in
-/// bounds. The caller is responsible for ensuring that the \a i_data is of
-/// the correct size for the underlying data element in the image.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_set_element(void *i_image,
- const char* i_id,
- const uint32_t i_index,
- const uint64_t i_data);
-
-
-/// Set string data in an SBE-XIP image
-///
-/// \param[in,out] io_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_id A pointer to a 0-terminated ASCII string naming the item
-/// to be modified.
-///
-/// \param[in] i_data A pointer to the new string data.
-///
-/// This API searches the SBE-XIP Table of Contents (TOC) for the item named
-/// \a i_id, which must be a string variable. If found, then the string data
-/// in the image is overwritten with \a i_data. Strings are held 0-terminated
-/// in the image, and the SBE-XIP format does not maintain a record of the
-/// amount of memory allocated for an individual string. If a string is
-/// overwritten by a shorter string then the 'excess' storage is effectively
-/// lost. If the length of \a i_data is longer that the current strlen() of
-/// the string data then \a i_data is silently truncated to the first
-/// strlen(old_string) characters.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_set_string(void *io_image, const char* i_id, const char* i_data);
-
-
-/// Directly write 64-bit data into the image based on a IMAGE address
-///
-/// \param[in, out] io_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections.
-///
-/// \param[in] i_imageAddress A relocatable IMAGE address contained in the
-/// image, presumably of an 8-byte data area. The \a i_imageAddress is
-/// required to be 8-byte aligned, otherwise the SBE_XIP_ALIGNMENT_ERROR code
-/// is returned.
-///
-/// \param[in] i_data The 64 bit data in host format to be written to \a
-/// i_imageAddress.
-///
-/// This API is provided for applications that need to manipulate SBE-XIP
-/// images in terms of their relocatable IMAGE addresses. The API checks that
-/// the \a i_imageAddress is properly aligned and contained in the image, then
-/// updates the contents of \a i_imageAddress with \a i_data, performing
-/// host-to-image endianess conversion if required.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_write_uint64(void *io_image,
- const uint64_t i_imageAddress,
- const uint64_t i_data);
-
-
-/// Map over an SBE-XIP image Table of Contents
-///
-/// \param[in,out] io_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_fn A pointer to a function to call on each TOC entry. The
-/// function has the prototype:
-///
-/// \code
-/// int (*i_fn)(void* io_image,
-/// const SbeXipItem* i_item,
-/// void* io_arg)
-/// \endcode
-///
-/// \param[in,out] io_arg The private argument of \a i_fn.
-///
-/// This API iterates over each entry of the TOC, calling \a i_fn with
-/// pointers to the image, an SbeXipItem* pointer, and a private argument. The
-/// iteration terminates either when all TOC entries have been mapped, or \a
-/// i_fn returns a non-zero code.
-///
-/// \retval 0 Success; All TOC entries were mapped, including the case that
-/// the .toc section is empty.
-///
-/// \retval non-0 May be either one of the SBE-XIP image error codes (see \ref
-/// sbe_xip_image_errors), or a non-zero code from \a i_fn. Since the standard
-/// SBE_XIP return codes are > 0, application-defined codes should be < 0.
-int
-sbe_xip_map_toc(void* io_image,
- int (*i_fn)(void* io_image,
- const SbeXipItem* i_item,
- void* io_arg),
- void* io_arg);
-
-
-/// Find an SBE-XIP TOC entry
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_id A 0-byte terminated ASCII string naming the item to be
-/// searched for.
-///
-/// \param[out] o_item If the search is successful, then the object
-/// pointed to by \a o_item is filled in with the decoded form of the
-/// TOC entry for \a i_id. If the API returns a non-0 error code then the
-/// final state of the storage at \a o_item is undefined. This parameter may
-/// be suppied as 0, in which case sbe_xip_find() serves as a simple predicate
-/// on whether an item is indexded in the TOC.
-///
-/// This API searches the TOC of a normalized SBE-XIP image for the item named
-/// \a i_id, and if found, fills in the structure pointed to by \a
-/// o_item with a decoded form of the TOC entry. If the item is not found,
-/// the following two return codes may be considered non-error codes:
-///
-/// - SBE_XIP_ITEM_NOT_FOUND : No TOC record for \a i_id was found.
-///
-/// - SBE_XIP_DATA_NOT_PRESENT : The item appears in the TOC, however the
-/// section containing the data is no longer present in the image.
-///
-/// If the TOC section has been deleted from the image, then the search is
-/// restricted to the abbreviated TOC that indexes data in the .fixed section.
-/// In this case the \a o_item structure is marked with a 1 in the \a
-/// iv_partial field since the abbreviated TOC can not populate the entire
-/// SbeXipItem structure.
-///
-/// \note This API should typically only be used as a predicate, not as a way
-/// to access the image via the returned SbeXipItem structure. To obtain data
-/// from the image or update data in the image use the sbe_xip_get_*() and
-/// sbe_xip_set_*() APIs respectively.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_find(void* i_image,
- const char* i_id,
- SbeXipItem* o_item);
-
-
-
-/// Delete a section from an SBE-XIP image in host memory
-///
-/// \param[in,out] io_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_sectionId Identifies the section to be deleted. See \ref
-/// sbe_xip_sections.
-///
-/// This API effectively deletes a section from an SBE-XIP image held in host
-/// memory. Unless the requested section \a i_section is already empty, only
-/// the final (highest address offset) section of the image may be deleted.
-/// Deleting the final section of the image means that the section size is set
-/// to 0, and the size of the image recorded in the header is reduced by the
-/// section size. Any alignment padding of the now-last section is also
-/// removed.
-///
-/// \note This API does not check for or warn if other sections in the image
-/// reference the deleted section.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_delete_section(void* io_image, const int i_sectionId);
-
-
-#ifndef PPC_HYP
-
-/// Duplicate a section from an SBE-XIP image in host memory
-///
-/// \param[in,out] i_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections.
-///
-/// \param[in] i_sectionId Identifies the section to be duplicated. See \ref
-/// sbe_xip_sections.
-///
-/// \param[out] o_duplicate At exit, points to the newly allocated and
-/// initialized duplicate of the given section. The caller is responsible for
-/// free()-ing this memory when no longer required.
-///
-/// \param[out] o_size At exit, contains the size (in bytes) of the duplicated
-/// section.
-///
-/// This API creates a bytewise duplicate of a non-empty section into newly
-/// malloc()-ed memory. At exit \a o_duplicate points to the duplicate, and \a
-/// o_size is set the the size of the duplicated section. The caller is
-/// responsible for free()-ing the memory when no longer required. The
-/// pointer at \a o_duplicate is set to NULL (0) and the \a o_size is set to 0
-/// in the event of any failure.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_duplicate_section(const void* i_image,
- const int i_sectionId,
- void** o_duplicate,
- uint32_t* o_size);
-
-#endif // PPC_HYP
-
-
-/// Append binary data to an SBE-XIP image held in host memory
-///
-/// \param[in,out] io_image A pointer to an SBE-XIP image in host memory. The
-/// image is assumed to be consistent with the information contained in the
-/// header regarding the presence of and sizes of all sections. The image is
-/// also required to have been normalized.
-///
-/// \param[in] i_sectionId Identifies the section to contain the new data.
-///
-/// \param[in] i_data A pointer to the data to be appended to the image. If
-/// this pointer is NULL (0), then the effect is as if \a i_data were a
-/// pointer to an \a i_size array of 0 bytes.
-///
-/// \param[in] i_size The size of the data to be appended in bytes. If \a
-/// i_data is 0, then this is the number of bytes to clear.
-///
-/// \param[in] i_allocation The size of the memory region containing the
-/// image, measured from the first byte of the image. The call will fail if
-/// appending the new data plus any alignment padding would overflow the
-/// allocated memory.
-///
-/// \param[out] o_sectionOffset If non-0 at entry, then the API updates the
-/// location pointed to by \a o_sectionOffset with the offset of the first
-/// byte of the appended data within the indicated section. This return value
-/// is invalid in the event of a non-0 return code.
-///
-/// This API copies data from \a i_data to the end of the indicated \a
-/// i_section. The section \a i_section must either be empty, or must be the
-/// final (highest address) section in the image. If the section is initially
-/// empty and \a i_size is non-0 then the section is created at the end of the
-/// image. The size of \a i_section and the size of the image are always
-/// adjusted to reflect the newly added data. This is a simple binary copy
-/// without any interpretation (e.g., endian-translation) of the copied data.
-/// The caller is responsible for insuring that the host memory area
-/// containing the SBE-XIP image is large enough to hold the newly appended
-/// data without causing addressing errors or buffer overrun errors.
-///
-/// The final parameter \a o_sectionOffset is optional, and may be passed as
-/// NULL (0) if the application does not require the information. This return
-/// value is provided to simplify typical use cases of this API:
-///
-/// - A scan program is appended to the image, or a run-time data area is
-/// allocated and cleared at the end of the image.
-///
-/// - Pointer variables in the image are updated with IMAGE addresses obtained
-/// via sbe_xip_section2image(), or
-/// other procedure code initializes a newly allocated and cleared data area
-/// via host addresses obtained from sbe_xip_section2host().
-///
-/// Regarding alignment, note that the SBE-XIP format requires that sections
-/// maintain an initial alignment that varies by section, and the API will
-/// enforce these alignment constraints for all sections created by the API.
-/// All alignment is relative to the first byte of the image (\a io_image) -
-/// \e not to the current in-memory address of the image. By specification
-/// SBE-XIP images must be loaded at a 4K alignment in order for IMAGE hardware
-/// relocation to work, however the APIs don't require this 4K alignment for
-/// in-memory manipulation of images. Images to be executed on ImageVe will
-/// normally require at least 8-byte final aligment in order to guarantee that
-/// the ImageVe can execute an 8-byte fetch or load/store of the final
-/// doubleword.
-///
-/// \note If the TOC section is modified then the image is marked as having an
-/// unsorted TOC.
-///
-/// \note If the call fails for any reason (other than a bug in the API
-/// itself) then the \a io_image data is returned unmodified.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_append(void* io_image,
- const int i_sectionId,
- const void* i_data,
- const uint32_t i_size,
- const uint32_t i_allocation,
- uint32_t* o_sectionOffset);
-
-
-/// Convert an SBE-XIP section offset to a relocatable IMAGE address
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory
-///
-/// \param[in] i_sectionId A valid SBE-XIP section identifier; The section
-/// must be non-empty.
-///
-/// \param[in] i_offset An offset (in bytes) within the section. At least one
-/// byte at \a i_offset must be currently allocated in the section.
-///
-/// \param[in] o_imageAddress The equivalent relocatable IMAGE address is
-/// returned via this pointer. Since valid IMAGE addresses are always either
-/// 4-byte (code) or 8-byte (data) aligned, this API checks the aligment of
-/// the translated address and returns SBE_XIP_ALIGNMENT_ERROR if the IMAGE
-/// address is not at least 4-byte aligned. Note that the translated address
-/// is still returned even if incorrectly aligned.
-///
-/// This API is typically used to translate section offsets returned from
-/// sbe_xip_append() into relocatable IMAGE addresses.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_section2image(const void* i_image,
- const int i_sectionId,
- const uint32_t i_offset,
- uint64_t* o_imageAddress);
-
-
-/// Convert an SBE-XIP relocatable image address to a host memory address
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory.
-///
-/// \param[in] i_imageAddress A relocatable image address putatively addressing
-/// relocatable memory contained in the image.
-///
-/// \param[out] o_hostAddress The API updates the location pointed to by \a
-/// o_hostAddress with the host address of the memory addressed by \a
-/// i_imageAddress. In the event of an error (non-0 return code) the final
-/// content of \a o_hostAddress is undefined.
-///
-/// This API is typically used to translate relocatable image addresses stored
-/// in the SBE-XIP image into the equivalent host address of the in-memory
-/// image, allowing host-code to manipulate arbitrary data structures in the
-/// image. If the \a i_imageAddress does not refer to memory within the image
-/// (as determined by the link address and image size) then the
-/// SBE_XIP_INVALID_ARGUMENT error code is returned.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_image2host(const void* i_image,
- const uint64_t i_imageAddress,
- void** o_hostAddress);
-
-
-/// Convert an SBE-XIP relocatable image address to section Id and offset
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory.
-///
-/// \param[in] i_imageAddress A relocatable image address putatively addressing
-/// relocatable memory contained in the image.
-///
-/// \param[out] o_section The API updates the location pointed to by \a
-/// o_section with the section Id of the memory addressed by \a
-/// i_imageAddress. In the event of an error (non-0 return code) the final
-/// content of \a o_section is undefined.
-///
-/// \param[out] o_offset The API updates the location pointed to by \a
-/// o_offset with the byte offset of the memory addressed by \a i_imageAddress
-/// within \a o_section. In the event of an error (non-0 return code) the
-/// final content of \a o_offset is undefined.
-///
-/// This API is typically used to translate relocatable image addresses stored
-/// in the SBE-XIP image into the equivalent section + offset form, allowing
-/// host-code to manipulate arbitrary data structures in the image. If the \a
-/// i_imageAddress does not refer to memory within the image (as determined by
-/// the link address and image size) then the SBE_XIP_INVALID_ARGUMENT error
-/// code is returned.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_image2section(const void* i_image,
- const uint64_t i_imageAddress,
- int* o_section,
- uint32_t* o_offset);
-
-
-/// Convert an in-memory SBE-XIP host address to a relocatable image address
-///
-/// \param[in] i_image A pointer to an SBE-XIP image in host memory
-///
-/// \param[in] i_hostAddress A host address addressing data within the image.
-///
-/// \param[out] o_imageAddress The API updates the location pointed to by \a
-/// o_imageAddress with the equivelent relocatable image address of the memory
-/// addressed by i_hostAddress. Since valid image addresses are always either
-/// 4-byte (code) or 8-byte (data) aligned, this API checks the aligment of
-/// the translated address and returns SBE_XIP_ALIGNMENT_ERROR if the image
-/// address is not at least 4-byte aligned. Note that the translated address
-/// is still returned evn if incorrectly aligned.
-///
-/// This API is provided as a convenient way to convert host memory addresses
-/// for an in-memory SBE-XIP image into image addresses correctly relocated for
-/// the image, for example to update pointer variables in the image. If the
-/// \a i_hostAddress does not refer to memory within the image (as determined
-/// by the image address and image size) then the SBE_XIP_INVALID_ARGUMENT
-/// error code is returned.
-///
-/// \retval 0 Success
-///
-/// \retval non-0 See \ref sbe_xip_image_errors
-int
-sbe_xip_host2image(const void* i_image,
- void* i_hostAddress,
- uint64_t* o_imageAddress);
-
-
-
-// PHYP has their own way of implementing the <string.h> functions. PHYP also
-// does not allow static functions or data, so all of the XIP_STATIC functions
-// defined here are global to PHYP.
-
-#ifdef PPC_HYP
-
-#ifdef PLIC_MODULE
-
-#define strcpy(dest, src) hvstrcpy(dest, src)
-#define strlen(s) hvstrlen(s)
-#define strcmp(s1, s2) hvstrcmp(s1, s2)
-#endif //PLIC_MODULE
-
-#define XIP_STATIC
-
-#else // PPC_HYP
-
-// #define XIP_STATIC static
-#define XIP_STATIC
-
-#endif // PPC_HYP
-
-// Note: For maximum flexibility we provide private versions of
-// endian-conversion routines rather than counting on a system-specific header
-// to provide these.
-
-/// Byte-reverse a 16-bit integer if on a little-endian machine
-XIP_STATIC uint16_t
-xipRevLe16(const uint16_t i_x);
-
-/// Byte-reverse a 32-bit integer if on a little-endian machine
-XIP_STATIC uint32_t
-xipRevLe32(const uint32_t i_x);
-
-
-/// Byte-reverse a 64-bit integer if on a little-endian machine
-XIP_STATIC uint64_t
-xipRevLe64(const uint64_t i_x);
-
-/// \defgroup sbe_xip_image_errors Error codes from SBE-XIP image APIs
-///
-/// @{
-
-/// A putative SBE-XIP image does not have the correct magic number, or
-/// contains some other major inconsistency.
-#define SBE_XIP_IMAGE_ERROR 1
-
-/// The TOC may be missing, partially present or may have an alignment problem.
-#define SBE_XIP_TOC_ERROR 2
-
-/// A named item was not found in the SBE-XIP TOC, or a putative HALT address
-/// is not associated with a halt code in .halt.
-#define SBE_XIP_ITEM_NOT_FOUND 3
-
-/// A named item appears in the SBE-XIP TOC, but the data is not present in
-/// the image. This error can occur if sections have been deleted from the
-/// image.
-#define SBE_XIP_DATA_NOT_PRESENT 4
-
-/// A named item appears in the SBE-XIP TOC, but the data can not be
-/// modified. This error will occur if an attempt is made to modify an
-/// address-only entry.
-#define SBE_XIP_CANT_MODIFY 5
-
-/// A direct or implied argument is invalid, e.g. an illegal data type or
-/// section identifier, or an address not contained within the image.
-#define SBE_XIP_INVALID_ARGUMENT 6
-
-/// A data type mismatch or an illegal type was specified or implied for an
-/// operation.
-#define SBE_XIP_TYPE_ERROR 7
-
-/// A bug in an SBE-XIP image API
-#define SBE_XIP_BUG 8
-
-/// The image must first be normalized with sbe_xip_normalize().
-#define SBE_XIP_NOT_NORMALIZED 9
-
-/// Attempt to delete a non-empty section that is not the final section of the
-/// image, or an attempt to append data to a non-empty section that is not the
-/// final section of the image, or an attempt to operate on an empty section
-/// for those APIs that prohibit this.
-#define SBE_XIP_SECTION_ERROR 10
-
-/// An address translation API returned a image address that was not at least
-/// 4-byte aligned, or alignment violations were observed by
-/// sbe_xip_validate() or sbe_xip_append().
-#define SBE_XIP_ALIGNMENT_ERROR 11
-
-/// An API that performs dynamic memory allocation was unable to allocate
-/// memory.
-#define SBE_XIP_NO_MEMORY 12
-
-/// Attempt to get or set a vector element with an index that is outside of
-/// the declared bounds of the vector.
-#define SBE_XIP_BOUNDS_ERROR 13
-
-/// Attempt to grow the image past its defined memory allocation
-#define SBE_XIP_WOULD_OVERFLOW 14
-
-/// Error associated with the disassembler occured.
-#define SBE_XIP_DISASSEMBLER_ERROR 15
-
-/// hash collision creating the .fixed_toc section
-#define SBE_XIP_HASH_COLLISION 16
-
-/// Applications can expand this macro to declare an array of string forms of
-/// the error codes if desired.
-#define SBE_XIP_ERROR_STRINGS(var) \
- const char* var[] = { \
- "Success", \
- "SBE_XIP_IMAGE_ERROR", \
- "SBE_XIP_TOC_ERROR", \
- "SBE_XIP_ITEM_NOT_FOUND", \
- "SBE_XIP_DATA_NOT_PRESENT", \
- "SBE_XIP_CANT_MODIFY", \
- "SBE_XIP_INVALID_ARGUMENT", \
- "SBE_XIP_TYPE_ERROR", \
- "SBE_XIP_BUG", \
- "SBE_XIP_NOT_NORMALIZED", \
- "SBE_XIP_SECTION_ERROR", \
- "SBE_XIP_ALIGNMENT_ERROR", \
- "SBE_XIP_NO_MEMORY", \
- "SBE_XIP_BOUNDS_ERROR", \
- "SBE_XIP_WOULD_OVERFLOW", \
- "SBE_XIP_DISASSEMBLER_ERROR", \
- "SBE_XIP_HASH_COLLISION", \
- }
-
-/// Applications can use this macro to safely index the array of error
-/// strings.
-#define SBE_XIP_ERROR_STRING(var, n) \
- ((((n) < 0) || ((n) > (int)(sizeof(var) / sizeof(char*)))) ? \
- "Bug : Invalid SBE-XIP error code" : var[n])
-
-/// @}
-
-/// Disassembler error codes.
-#define DIS_IMAGE_ERROR 1
-#define DIS_MEMORY_ERROR 2
-#define DIS_DISASM_ERROR 3
-#define DIS_RING_NAME_ADDR_MATCH_SUCCESS 4
-#define DIS_RING_NAME_ADDR_MATCH_FAILURE 5
-#define DIS_TOO_MANY_DISASM_WARNINGS 6
-#define DIS_DISASM_TROUBLES 7
-
-#define DIS_ERROR_STRINGS(var) \
- const char* var[] = { \
- "Success", \
- "DIS_IMAGE_ERROR", \
- "DIS_MEMORY_ERROR", \
- "DIS_DISASM_ERROR", \
- "DIS_RING_NAME_ADDR_MATCH_SUCCESS", \
- "DIS_RING_NAME_ADDR_MATCH_FAILURE", \
- "DIS_TOO_MANY_DISASM_WARNINGS", \
- "DIS_DISASM_TROUBLES", \
- }
-
-#define DIS_ERROR_STRING(var, n) \
- ((((n) < 0) || ((n) > (int)(sizeof(var) / sizeof(char*)))) ? \
- "Bug : Invalid DIS error code" : var[n])
-
-#if 0
-{ /* So __cplusplus doesn't mess w/auto-indent */
-#endif
-#ifdef __cplusplus
-}
-#endif
-
-#endif // __ASSEMBLER__
-
-
-////////////////////////////////////////////////////////////////////////////
-// Assembler Definitions
-////////////////////////////////////////////////////////////////////////////
-
-#ifdef __ASSEMBLER__
-
-/// Create an XIP TOC entry
-///
-/// \param[in] index The string form of the \a index symbol is created and
-/// linked from the TOC entry to allow external search procedures to locate
-/// the \a address.
-///
-/// \param[in] type One of the SBE_XIP_* type constants; See \ref
-/// sbe_xip_toc_types.
-///
-/// \param[in] address The address of the idexed code or data; This wlll
-/// typically be a symbol.
-///
-/// \param[in] elements <Optional> For vector types, number of elements in the
-/// vector, which is limited to an 8-bit unsigned integer. This parameter
-/// defaults to 1 which indicates a scalar type. Declaring a vector with 0
-/// elements disables bounds checking on vector accesses, and can be used if
-/// very large or indeterminate sized vectors are required. The TOC format
-/// does not support vectors of strings or addresses.
-///
-/// The \c .xip_toc macro creates a XIP Table of Contents (TOC) structure in
-/// the \c .toc section, as specified by the parameters. This macro is
-/// typically not used directly in assembly code. Instead programmers should
-/// use .xip_quad, .xip_quada, .xip_quadia, .xip_address, .xip_string or
-/// .xip_cvs_revision.
-
- .macro .xip_toc, index:req, type:req, address:req, elements=1
-
- .if (((\type) < 1) || ((\type) > SBE_XIP_MAX_TYPE_INDEX))
- .error ".xip_toc : Illegal type index"
- .endif
-
- // First push into the .strings section to lay down the
- // string form of the index name under a local label.
-
- .pushsection .strings
-7667862:
- .asciz "\index"
- .popsection
-
- // Now the 12-byte TOC entry is created. Push into the .toc section
- // and lay down the first 4 bytes which are always a pointer to the
- // string just declared. The next 4 bytes are the address of the data
- // (or the address itself in the case of address types). The final 4
- // bytes are the type, section (always 0 prior to normalization),
- // number of elements, and a padding byte.
-
- .pushsection .toc
-
- .long 7667862b, (\address)
- .byte (\type), 0, (\elements), 0
-
- .popsection
-
- .endm
-
-
-/// Allocate and initialize 64-bit global scalar or vector data and create the
-/// TOC entry.
-///
-/// \param[in] symbol The name of the scalar or vector; this name is also used
-/// as the TOC index of the data.
-///
-/// \param[in] init The initial value of (each element of) the data.
-/// This is a 64-bit integer; To allocate address pointers use .xip_quada.
-///
-/// \param[in] elements The number of 64-bit elements in the data structure,
-/// defaulting to 1, with a maximum value of 255.
-///
-/// \param[in] section The section where the data will be allocated,
-/// default depends on the memory space
-
- .macro .xip_quad, symbol:req, init:req, elements=1, section
-
- ..xip_quad_helper .quad, \symbol, (\init), (\elements), \section
-
- .endm
-
-
-/// Allocate and initialize 64-bit global scalar or vector data containing a
-/// relocatable address in and create the TOC entry.
-///
-/// \param[in] symbol The name of the scalar or vector; this name is also used
-/// as the TOC index of the data.
-///
-/// \param[in] init The initial value of (each element of) the data. This
-/// will typically be a symbolic address. If the intention is to define an
-/// address that will always be filled in later by image manipulation tools,
-/// then use the .xip_quad macro with a 0 initial value.
-///
-/// \param[in] elements The number of 64-bit elements in the data structure,
-/// defaulting to 1, with a maximum value of 255.
-///
-/// \param[in] section The section where the data will be allocated,
-/// default depends on the memory space
-
- .macro .xip_quada, symbol:req, offset:req, elements=1, section
-
- ..xip_quad_helper .quada, \symbol, (\offset), (\elements), \section
-
- .endm
-
-
-/// Helper for .xip_quad and .xip_quada
-
- .macro ..xip_quad_helper, directive, symbol, init, elements, section
-
- .if (((\elements) < 1) || ((\elements) > 255))
- .error "The number of vector elements must be in the range 1..255"
- .endif
-
- ..xip_pushsection \section
- .balign 8
-
- .global \symbol
-\symbol\():
- .rept (\elements)
- \directive (\init)
- .endr
-
- .popsection
-
- .xip_toc \symbol, SBE_XIP_UINT64, \symbol, (\elements)
-
- .endm
-
-
-/// Allocate and initialize 64-bit global scalar or vector data containing
-/// full 64-bit addresses and create a TOC entry
-///
-/// \param[in] symbol The name of the scalar or vector; this name is also used
-/// as the TOC index of the data.
-///
-/// \param[in] space A valid image memory space descriptor
-///
-/// \param[in] offset A 32-bit relocatable offset
-///
-/// \param[in] elements The number of 64-bit elements in the data structure,
-/// defaulting to 1, with a maximum value of 255.
-///
-/// \param[in] section The section where the data will be allocated,
-/// default depends on the memory space
-
- .macro .xip_quadia, symbol:req, space:req, offset:req, \
- elements=1, section
-
- .if (((\elements) < 1) || ((\elements) > 255))
- .error "The number of vector elements must be in the range 1..255"
- .endif
-
- ..xip_pushsection \section
- .balign 8
-
- .global \symbol
-\symbol\():
- .rept (\elements)
- .quadia (\space), (\offset)
- .endr
-
- .popsection
-
- .xip_toc \symbol, SBE_XIP_UINT64, \symbol, (\elements)
-
- .endm
-
-/// Default push into .ipl_data unless in an OCI space, then .data
-
- .macro ..xip_pushsection, section
-
- .ifnb \section
- .pushsection \section
- .else
- .if (_PGAS_DEFAULT_SPACE == PORE_SPACE_OCI)
- .pushsection .data
- .else
- .pushsection .ipl_data
- .endif
- .endif
-
- .balign 8
-
- .endm
-
-/// Allocate and initialize a string in .strings
-///
-/// \param[in] index The string will be stored in the TOC using this index
-/// symbol.
-///
-/// \param[in] string The string to be allocated in .strings. String space is
-/// fixed once allocated. Strings designed to be overwritten by external tools
-/// should be allocated to be as long as eventually needed (e.g., by a string
-/// of blanks.)
-
- .macro .xip_string, index:req, string:req
-
- .pushsection .strings
-7874647:
- .asciz "\string"
- .popsection
-
- .xip_toc \index, SBE_XIP_STRING, 7874647b
-
- .endm
-
-
-/// Allocate and initialize a CVS Revison string in .strings
-///
-/// \param[in] index The string will be stored in the TOC using this index
-/// symbol.
-///
-/// \param[in] string A CVS revision string to be allocated in .strings. CVS
-/// revision strings are formatted by stripping out and only storing the
-/// actual revision number :
-///
-/// \code
-/// "$Revision <n>.<m> $" -> "<n>.<m>"
-/// \endcode
-
-
- .macro .xip_cvs_revision, index:req, string:req
-
- .pushsection .strings
-7874647:
- ..cvs_revision_string "\string"
- .popsection
-
- .xip_toc \index, SBE_XIP_STRING, 7874647b
-
- .endm
-
-
-/// Shorthand to create a TOC entry for an address
-///
-/// \param[in] index The symbol will be indexed as this name
-///
-/// \param[in] symbol <Optional> The symbol to index; by default the same as
-/// the index.
-
- .macro .xip_address, index:req, symbol
-
- .ifb \symbol
- .xip_toc \index, SBE_XIP_ADDRESS, \index
- .else
- .xip_toc \index, SBE_XIP_ADDRESS, \symbol
- .endif
-
- .endm
-
-
-/// Edit and allocate a CVS revision string
-///
-/// CVS revision strings are formatted by stripping out and only storing the
-/// actual revision number :
-/// \code
-/// "$Revision <n>.<m> $" -> "<n>.<m>"
-/// \endcode
-
- .macro ..cvs_revision_string, rev:req
- .irpc c, \rev
- .ifnc "\c", "$"
- .ifnc "\c", "R"
- .ifnc "\c", "e"
- .ifnc "\c", "v"
- .ifnc "\c", "i"
- .ifnc "\c", "s"
- .ifnc "\c", "i"
- .ifnc "\c", "o"
- .ifnc "\c", "n"
- .ifnc "\c", ":"
- .ifnc "\c", " "
- .ascii "\c"
- .endif
- .endif
- .endif
- .endif
- .endif
- .endif
- .endif
- .endif
- .endif
- .endif
- .endif
- .endr
- .byte 0
- .endm
-
-#endif // __ASSEMBLER__
-
-#endif // __SBE_XIP_TOC_H
OpenPOWER on IntegriCloud