CMakeLists.txt

+#
+# Cmake Configuration
+#
+
+# Need 3.9 to support CXX_STANDARD=17 
+CMAKE_MINIMUM_REQUIRED(VERSION 3.9.0)
+
+
+PROJECT(ehp)
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib)
+
+option(USE_ELFIO "Use the elfio library to parse elf files" OFF)
+if(USE_ELFIO)
+   add_definitions(-DUSE_ELFIO)
+   include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third-party/elfio-code/)
+endif()
+
+# Use C++17
+set(CMAKE_CXX_STANDARD 17)
+# Error if it's not available
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+# Base include path for ehp
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/include)
+
+add_compile_options(-Werror)
+add_compile_options(-fPIC)
+add_subdirectory(src)
+
+# ---------------------------------------------------------------------------
+# Export config for use by other CMake projects
+# ---------------------------------------------------------------------------
+export(TARGETS ehp FILE "${CMAKE_CURRENT_BINARY_DIR}/ehpTargets.cmake")
+file(
+  WRITE "${CMAKE_CURRENT_BINARY_DIR}/ehpConfig.cmake"
+        "
+            include(\"\$\{CMAKE_CURRENT_LIST_DIR\}/ehpTargets.cmake\")
+            set_property(
+                TARGET ehp
+                APPEND PROPERTY
+                    INTERFACE_INCLUDE_DIRECTORIES \"${CMAKE_BINARY_DIR}/include\"
+            )
+        "
+    )
+export(PACKAGE ehp)
\ No newline at end of file

README.md

@@ -10,4 +10,23 @@ Notes:
 1. Additional documentation will be provided in later versions 
 1. API is incomplete and untested in some areas.  Future versions will improve stability.
 1. Use `git clone --recursive` to pull down required submodules
-1. Build with `scons`, add `debug=1` for debug build
+1. Build with `scons`, add `debug=1` for debug build, add '--no_elfio' to compile without the third party libraries
+
+## Compilation with cmake
+
+To compile with cmake type:
+
+```
+cmake . -Bbuild
+cd build
+cmake --build .
+```
+
+In contrast to scons, the default compilation in cmake is **without** the elfio library. If you want to compile with elfio
+use the following commands:
+
+```
+cmake . -Bbuild  -DUSE_ELFIO=ON
+cd build
+cmake --build .
+```
\ No newline at end of file

include/ehp.hpp

@@ -39,6 +39,8 @@ class EHProgramInstruction_t
 	public: 
 	virtual ~EHProgramInstruction_t() {}
 	virtual void print(uint64_t &pc, int64_t caf=1) const = 0;
+	virtual tuple<string, int64_t, int64_t> decode() const = 0;
+	virtual uint64_t getSize() const = 0;
 	virtual bool isNop() const = 0;
 	virtual bool isDefCFAOffset() const = 0;
 	virtual bool isRestoreState() const = 0;
@@ -68,9 +70,14 @@ class CIEContents_t
 	public:
 	virtual ~CIEContents_t() {}
 	virtual const EHProgram_t& getProgram() const =0;
+	virtual uint64_t getPosition() const = 0;
+	virtual uint64_t getLength() const = 0;
 	virtual uint64_t getCAF() const =0;
 	virtual int64_t getDAF() const =0;
 	virtual uint64_t getPersonality() const =0;
+	virtual uint8_t getPersonalityEncoding() const = 0;
+	virtual uint64_t getPersonalityPointerPosition() const = 0;
+	virtual uint64_t getPersonalityPointerSize() const = 0;
 	virtual uint64_t getReturnRegister() const =0;
 	virtual string getAugmentation() const =0;
 	virtual uint8_t getLSDAEncoding() const =0;
@@ -113,8 +120,12 @@ class LSDACallSite_t
 	virtual ~LSDACallSite_t() {}
 	virtual const LSDACallSiteActionVector_t* getActionTable() const =0;
 	virtual uint64_t getCallSiteAddress() const  =0;
+	virtual uint64_t getCallSiteAddressPosition() const = 0;
 	virtual uint64_t getCallSiteEndAddress() const  =0;
+	virtual uint64_t getCallSiteEndAddressPosition() const = 0;
 	virtual uint64_t getLandingPadAddress() const  =0;
+	virtual uint64_t getLandingPadAddressPosition() const = 0;
+	virtual uint64_t getLandingPadAddressEndPosition() const = 0;
 	virtual void print() const=0;
 };
 
@@ -130,8 +141,16 @@ class LSDA_t
 	virtual ~LSDA_t() {}
 	virtual uint8_t getTTEncoding() const =0;
 	virtual void print() const=0;
-        virtual const CallSiteVector_t* getCallSites() const =0;
-        virtual const TypeTableVector_t* getTypeTable() const =0;
+	virtual uint64_t getLandingPadBaseAddress() const = 0;
+    virtual const CallSiteVector_t* getCallSites() const =0;
+	virtual uint64_t getCallSiteTableAddress() const = 0;
+	virtual uint64_t getCallSiteTableAddressLocation() const = 0;
+	virtual uint8_t getCallSiteTableEncoding() const = 0;
+    virtual const TypeTableVector_t* getTypeTable() const =0;
+	virtual uint64_t getTypeTableAddress() const = 0;
+	virtual uint64_t getTypeTableAddressLocation() const = 0;
+    virtual uint64_t getCallSiteTableLength() const = 0;
+	virtual uint8_t getTypeTableEncoding() const = 0;
 	unique_ptr<LSDA_t> factory(const string lsda_data, const uint64_t lsda_start_addr);
 };
 
@@ -143,12 +162,20 @@ class FDEContents_t
 	FDEContents_t(const FDEContents_t&) {}
 	public:
 	virtual ~FDEContents_t() {}
+
+	virtual uint64_t getPosition() const =0;
+	virtual uint64_t getLength() const =0;
 	virtual uint64_t getStartAddress() const =0;
 	virtual uint64_t getEndAddress() const =0;
 	virtual const CIEContents_t& getCIE() const =0;
 	virtual const EHProgram_t& getProgram() const =0;
 	virtual const LSDA_t* getLSDA() const =0;
 	virtual uint64_t getLSDAAddress() const =0;
+	virtual uint64_t getStartAddressPosition() const = 0;
+    virtual uint64_t getEndAddressPosition() const = 0;
+    virtual uint64_t getEndAddressSize() const = 0;
+    virtual uint64_t getLSDAAddressPosition() const = 0;
+    virtual uint64_t getLSDAAddressSize() const = 0;
 	virtual void print() const=0;	// move to ostream?  toString?
 
 };
@@ -169,7 +196,9 @@ class EHFrameParser_t
 	virtual const CIEVector_t* getCIEs() const =0;
 	virtual const FDEContents_t* findFDE(uint64_t addr) const =0; 
 
+#ifdef USE_ELFIO
 	static unique_ptr<const EHFrameParser_t> factory(const string filename);
+#endif
 	static unique_ptr<const EHFrameParser_t> factory(
 		uint8_t ptrsize,
 		const string eh_frame_data, const uint64_t eh_frame_data_start_addr,

src/CMakeLists.txt

+SET(PROJECT_NAME ehp)
+
+
+set(${PROJECT_NAME}_H
+  ehp_dwarf2.hpp
+  ehp_priv.hpp
+  scoop_replacement.hpp
+)
+
+set(${PROJECT_NAME}_SRC
+  ehp.cpp
+)
+
+add_library(${PROJECT_NAME} SHARED
+		${${PROJECT_NAME}_H}
+		${${PROJECT_NAME}_SRC}
+	)
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+set(PUBLIC_HEADERS
+  ${CMAKE_SOURCE_DIR}/include/ehp.hpp
+  )
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+  COMMAND "${CMAKE_COMMAND}" -E remove_directory "${CMAKE_BINARY_DIR}/include")
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    COMMAND "${CMAKE_COMMAND}" -E make_directory "${CMAKE_BINARY_DIR}/include")
+add_custom_command(
+        TARGET ${PROJECT_NAME} POST_BUILD
+        COMMAND "${CMAKE_COMMAND}" -E copy
+                ${PUBLIC_HEADERS}
+                "${CMAKE_BINARY_DIR}/include/")

src/SConscript

@@ -26,11 +26,20 @@ cpppath='''
 	'''
 cpppath=cpppath+Dir('.').srcnode().abspath+'/../third-party/elfio-code'
 
+AddOption('--no_elfio',
+          dest='no_elfio',
+          action='store_true',
+          default=False,
+          help='Do not use Elfio library to parse elf files')
+
+cpp_defines={}
+if( not GetOption('no_elfio')):
+    cpp_defines['USE_ELFIO']=1
 
 LIBPATH="$SECURITY_TRANSFORMS_HOME/lib"
 LIBS=Split("")
 
-myenv=myenv.Clone(CPPPATH=Split(cpppath))
+myenv=myenv.Clone(CPPPATH=Split(cpppath),CPPDEFINES=cpp_defines)
 myenv.Append(CXXFLAGS = " -std=c++11 -Wall -Werror -fmax-errors=2 -fPIC ")
 
 lib1=myenv.Library("ehp",  Split(files), LIBPATH=LIBPATH, LIBS=LIBS)

src/ehp.cpp

@@ -29,12 +29,17 @@
 #include "ehp_priv.hpp"
 #include "scoop_replacement.hpp"
 
+#ifdef USE_ELFIO
 #include <elfio/elfio.hpp>
+#endif
 #include <elf.h>
 
 using namespace std;
 using namespace EHP;
+
+#ifdef USE_ELFIO
 using namespace ELFIO;
+#endif
 
 #define ALLOF(s) begin(s), end(s)
 
@@ -496,6 +501,170 @@ void eh_program_insn_t<ptrsize>::print(uint64_t &pc, int64_t caf) const
 
 }
 
+template <int ptrsize>
+std::tuple<std::string, int64_t, int64_t> eh_program_insn_t<ptrsize>::decode() const
+{
+    // make sure uint8_t is an unsigned char.
+    static_assert(std::is_same<unsigned char, uint8_t>::value, "uint8_t is not unsigned char");
+
+    auto& data = program_bytes;
+    auto opcode = program_bytes[0];
+    auto opcode_upper2 = (uint8_t)(opcode >> 6);
+    auto opcode_lower6 = (uint8_t)(opcode & (0x3f));
+    auto pos = uint32_t(1);
+    auto max = program_bytes.size();
+    uint64_t uleb = 0;
+    uint64_t uleb2 = 0;
+    int64_t sleb = 0;
+    switch(opcode_upper2)
+    {
+        case 1:
+            // case DW_CFA_advance_loc:
+            return std::make_tuple("cf_advance_loc", +opcode_lower6, 0);
+        case 2:
+            if(eh_frame_util_t<ptrsize>::read_uleb128(uleb, pos, (const uint8_t* const)data.data(),
+                                                      max))
+                return std::make_tuple("unexpected_error", 0, 0);
+            // case DW_CFA_offset:
+            return std::make_tuple("offset", +opcode_lower6, uleb);
+        case 3:
+            // case DW_CFA_restore (register #):
+            return std::make_tuple("restore", +opcode_lower6, 0);
+        case 0:
+            switch(opcode_lower6)
+            {
+                case DW_CFA_nop:
+                    return std::make_tuple("nop", 0, 0);
+                case DW_CFA_remember_state:
+                    return std::make_tuple("remember_state", 0, 0);
+                case DW_CFA_restore_state:
+                    return std::make_tuple("restore_state", 0, 0);
+                // takes single uleb128
+                case DW_CFA_undefined:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("undefined", uleb, 0);
+                case DW_CFA_same_value:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("same_value", uleb, 0);
+                case DW_CFA_restore_extended:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("restore_extended", uleb, 0);
+                case DW_CFA_def_cfa_register:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("def_cfa_register", uleb, 0);
+                case DW_CFA_def_cfa_offset:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("def_cfa_offset", uleb, 0);
+                case DW_CFA_set_loc:
+                {
+                    auto arg = uintptr_t(0xDEADBEEF);
+                    switch(ptrsize)
+                    {
+                        case 4:
+                            arg = *(uint32_t*)&data.data()[pos];
+                            break;
+                        case 8:
+                            arg = *(uint64_t*)&data.data()[pos];
+                            break;
+                    }
+                    return std::make_tuple("set_loc", arg, 0);
+                }
+                case DW_CFA_advance_loc1:
+                {
+                    auto loc = *(uint8_t*)(&data.data()[pos]);
+                    return std::make_tuple("advance_loc", loc, 0);
+                }
+
+                case DW_CFA_advance_loc2:
+                {
+                    auto loc = *(uint16_t*)(&data.data()[pos]);
+                    return std::make_tuple("advance_loc", loc, 0);
+                }
+
+                case DW_CFA_advance_loc4:
+                {
+                    auto loc = *(uint32_t*)(&data.data()[pos]);
+                    return std::make_tuple("advance_loc", loc, 0);
+                }
+                case DW_CFA_offset_extended:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb2, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("offset_extended", uleb, uleb2);
+                case DW_CFA_register:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb2, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("register", uleb, uleb2);
+
+                case DW_CFA_def_cfa:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb2, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("def_cfa", uleb, uleb2);
+
+                case DW_CFA_def_cfa_sf:
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    if(eh_frame_util_t<ptrsize>::read_sleb128(
+                           sleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("def_cfa_sf", uleb, sleb);
+                case DW_CFA_def_cfa_offset_sf:
+                {
+                    if(eh_frame_util_t<ptrsize>::read_sleb128(
+                           sleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("def_cfa_offset_sf", sleb, 0);
+                }
+                case DW_CFA_offset_extended_sf:
+                {
+                    if(eh_frame_util_t<ptrsize>::read_uleb128(
+                           uleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    if(eh_frame_util_t<ptrsize>::read_sleb128(
+                           sleb, pos, (const uint8_t* const)data.data(), max))
+                        return std::make_tuple("unexpected_error", 0, 0);
+                    return std::make_tuple("offset_extended_sf", uleb, sleb);
+                }
+
+                case DW_CFA_def_cfa_expression:
+                case DW_CFA_expression:
+                case DW_CFA_val_expression:
+                /* SGI/MIPS specific */
+                case DW_CFA_MIPS_advance_loc8:
+                /* GNU extensions */
+				case DW_CFA_GNU_args_size:
+                case DW_CFA_GNU_window_save:
+                case DW_CFA_GNU_negative_offset_extended:
+                default:
+                    return std::make_tuple("unhandled_instruction", 0, 0);
+            }
+		default:
+			return std::make_tuple("unhandled_instruction", 0, 0);
+    }
+}
+
 template <int ptrsize>
 void eh_program_insn_t<ptrsize>::push_byte(uint8_t c) { program_bytes.push_back(c); }
 
@@ -986,10 +1155,13 @@ bool cie_contents_t<ptrsize>::parse_cie(
 	}
 	auto personality_encoding=uint8_t(DW_EH_PE_omit);
 	auto personality=uint64_t(0);
+	auto personality_pointer_position=uint64_t(0);
+	auto personality_pointer_size=uint64_t(0);
 	if(augmentation.find("P") != string::npos)
 	{
 		if(this->read_type(personality_encoding, position, eh_frame_scoop_data, max))
 			return true;
+		personality_pointer_position=position;
 
 		// indirect is OK as a personality encoding, but we don't need to go that far.
 		// we just need to record what's in the CIE, regardless of whether it's the actual
@@ -997,6 +1169,7 @@ bool cie_contents_t<ptrsize>::parse_cie(
 		auto personality_encoding_sans_indirect = personality_encoding&(~DW_EH_PE_indirect);
 		if(this->read_type_with_encoding(personality_encoding_sans_indirect, personality, position, eh_frame_scoop_data, max, eh_addr))
 			return true;
+		personality_pointer_size=position - personality_pointer_position;
 	}
 
 	auto lsda_encoding=uint8_t(DW_EH_PE_omit);
@@ -1015,7 +1188,8 @@ bool cie_contents_t<ptrsize>::parse_cie(
 		return true;
 
 
-	c.cie_position=cie_position;
+	c.cie_position=cie_position +eh_addr;
+	c.length=length;
 	c.cie_id=cie_id;
 	c.cie_version=cie_version;
 	c.augmentation=augmentation;
@@ -1025,6 +1199,8 @@ bool cie_contents_t<ptrsize>::parse_cie(
 	c.augmentation_data_length=augmentation_data_length;
 	c.personality_encoding=personality_encoding;
 	c.personality=personality;
+	c.personality_pointer_position=personality_pointer_position + eh_addr;
+	c.personality_pointer_size=personality_pointer_size;
 	c.lsda_encoding=lsda_encoding;
 	c.fde_encoding=fde_encoding;
 
@@ -1203,15 +1379,20 @@ bool lsda_call_site_t<ptrsize>::parse_lcs(
 	const uint64_t landing_pad_base_addr,
 	const uint64_t gcc_except_table_max)
 {
-	
+	call_site_addr_position = pos + data_addr;
 	if(this->read_type_with_encoding(cs_table_encoding, call_site_offset, pos, data, max, data_addr))
 		return true;
 	call_site_addr=landing_pad_base_addr+call_site_offset;
+	call_site_end_addr_position = pos + data_addr;
+
 	if(this->read_type_with_encoding(cs_table_encoding, call_site_length, pos, data, max, data_addr))
 		return true;
 	call_site_end_addr=call_site_addr+call_site_length;
+	landing_pad_addr_position = pos + data_addr;
+
 	if(this->read_type_with_encoding(cs_table_encoding, landing_pad_offset, pos, data, max, data_addr))
 		return true;
+	landing_pad_addr_end_position = pos + data_addr;
 
 	// calc the actual addr.
 	if(landing_pad_offset == 0)
@@ -1331,17 +1512,22 @@ bool lsda_t<ptrsize>::parse_lsda(
 	auto type_table_pos=0;
 	if(type_table_encoding!=DW_EH_PE_omit)
 	{
+		type_table_addr_location = pos + data_addr;
 		if(this->read_uleb128(type_table_offset, pos, (const uint8_t* const)data.data(), max))
 			return true;
 		type_table_addr=lsda_addr+type_table_offset+(pos-start_pos);
 		type_table_pos=pos+type_table_offset;
 	}
 	else
+	{
 		type_table_addr=0;
+		type_table_addr_location=0;
+	}
 
 	if(this->read_type(cs_table_encoding, pos, (const uint8_t* const)data.data(), max))
 		return true;
 
+	cs_table_start_addr_location = pos + data_addr;
 	if(this->read_uleb128(cs_table_length, pos, (const uint8_t* const)data.data(), max))
 		return true;
 
@@ -1502,15 +1688,17 @@ bool fde_contents_t<ptrsize>::parse_fde(
 		return true;
 
 	auto fde_start_addr=uint64_t(0);
+	auto fde_start_addr_position = pos;
 	if(this->read_type_with_encoding(c.getCIE().getFDEEncoding(),fde_start_addr, pos, eh_frame_scoop_data, max, eh_addr))
 		return true;
 
 	auto fde_range_len=uint64_t(0);
+	auto fde_end_addr_position = pos;
 	if(this->read_type_with_encoding(c.getCIE().getFDEEncoding() & 0xf /* drop pc-rel bits */,fde_range_len, pos, eh_frame_scoop_data, max, eh_addr))
 		return true;
 
 	auto fde_end_addr=fde_start_addr+fde_range_len;
-
+	auto fde_end_addr_size = pos - fde_end_addr_position;
 	auto augmentation_data_length=uint64_t(0);
 	if(c.getCIE().getAugmentation().find("z") != string::npos)
 	{
@@ -1518,10 +1706,13 @@ bool fde_contents_t<ptrsize>::parse_fde(
 			return true;
 	}
 	auto lsda_addr=uint64_t(0);
+	auto fde_lsda_addr_position = pos;
+	auto fde_lsda_addr_size = 0;
 	if(c.getCIE().getLSDAEncoding()!= DW_EH_PE_omit)
 	{
 		if(this->read_type_with_encoding(c.getCIE().getLSDAEncoding(), lsda_addr, pos, eh_frame_scoop_data, max, eh_addr))
 			return true;
+		fde_lsda_addr_size = pos - fde_lsda_addr_position;
 		if(lsda_addr!=0)
 			if(c.lsda.parse_lsda(lsda_addr,gcc_except_scoop, fde_start_addr))
 				return true;
@@ -1530,7 +1721,7 @@ bool fde_contents_t<ptrsize>::parse_fde(
 	if(c.eh_pgm.parse_program(pos, eh_frame_scoop_data, end_pos))
 		return true;
 
-	c.fde_position=fde_position;
+	c.fde_position = fde_position + eh_addr;
 	c.cie_position=cie_position;
 	c.length=length;
 	c.id=id;
@@ -1538,6 +1729,11 @@ bool fde_contents_t<ptrsize>::parse_fde(
 	c.fde_end_addr=fde_end_addr;
 	c.fde_range_len=fde_range_len;
 	c.lsda_addr=lsda_addr;
+	c.fde_start_addr_position = fde_start_addr_position + eh_addr;
+	c.fde_end_addr_position = fde_end_addr_position + eh_addr;
+	c.fde_lsda_addr_position = fde_lsda_addr_position + eh_addr;
+	c.fde_end_addr_size = fde_end_addr_size;
+	c.fde_lsda_addr_size = fde_lsda_addr_size;
 
 	return false;
 }
@@ -1753,6 +1949,7 @@ const FDEContents_t* split_eh_frame_impl_t<ptrsize>::findFDE(uint64_t addr) cons
 	return raw_ret_ptr;
 }
 
+#ifdef USE_ELFIO
 unique_ptr<const EHFrameParser_t> EHFrameParser_t::factory(const string filename)
 {
 	auto elfiop=unique_ptr<elfio>(new elfio);
@@ -1789,6 +1986,7 @@ unique_ptr<const EHFrameParser_t> EHFrameParser_t::factory(const string filename
 			gcc_except_table_section.first, gcc_except_table_section.second);
 
 }
+#endif
 
 unique_ptr<const EHFrameParser_t> EHFrameParser_t::factory(
 	uint8_t ptrsize,

src/ehp_priv.hpp

@@ -89,7 +89,8 @@ class eh_program_insn_t  : public EHProgramInstruction_t
 	eh_program_insn_t(const string &s) ;
 
 	void print(uint64_t &pc, int64_t caf) const;
-
+	std::tuple<std::string, int64_t, int64_t> decode() const;
+	uint64_t getSize() const { return program_bytes.size(); }
 	void push_byte(uint8_t c) ;
 
 	static void print_uleb_operand(
@@ -165,6 +166,8 @@ class cie_contents_t : public CIEContents_t, private eh_frame_util_t<ptrsize>
 	uint64_t augmentation_data_length;
 	uint8_t personality_encoding;
 	uint64_t personality;
+	uint64_t personality_pointer_position;
+	uint64_t personality_pointer_size;
 	uint8_t lsda_encoding;
 	uint8_t fde_encoding;
 	eh_program_t<ptrsize> eh_pgm;
@@ -174,9 +177,14 @@ class cie_contents_t : public CIEContents_t, private eh_frame_util_t<ptrsize>
 	cie_contents_t() ;
 	
 	const eh_program_t<ptrsize>& getProgram() const ;
+	uint64_t getPosition() const { return cie_position; }
+	uint64_t getLength() const { return length; }
 	uint64_t getCAF() const ;
 	int64_t getDAF() const ;
+	uint8_t getPersonalityEncoding() const { return personality_encoding; }
 	uint64_t getPersonality() const ;
+	uint64_t getPersonalityPointerPosition() const { return personality_pointer_position; };
+	uint64_t getPersonalityPointerSize() const { return personality_pointer_size; };
 	uint64_t getReturnRegister() const ;
 
 	string getAugmentation() const ;
@@ -242,10 +250,14 @@ class lsda_call_site_t : public LSDACallSite_t, private eh_frame_util_t<ptrsize>
 	private:
 	uint64_t call_site_offset;
 	uint64_t call_site_addr;
+	uint64_t call_site_addr_position;
 	uint64_t call_site_length;
 	uint64_t call_site_end_addr;
+	uint64_t call_site_end_addr_position;
 	uint64_t landing_pad_offset;
 	uint64_t landing_pad_addr;
+	uint64_t landing_pad_addr_position;
+	uint64_t landing_pad_addr_end_position;
 	uint64_t action;
 	uint64_t action_table_offset;
 	uint64_t action_table_addr;
@@ -261,8 +273,12 @@ class lsda_call_site_t : public LSDACallSite_t, private eh_frame_util_t<ptrsize>
 	      vector<lsda_call_site_action_t <ptrsize> >& getActionTableInternal()       { return action_table; }
 
 	uint64_t getCallSiteAddress() const  { return call_site_addr ; } 
-	uint64_t getCallSiteEndAddress() const  { return call_site_end_addr ; } 
-	uint64_t getLandingPadAddress() const  { return landing_pad_addr ; } 
+	uint64_t getCallSiteAddressPosition() const { return call_site_addr_position; }
+	uint64_t getCallSiteEndAddress() const  { return call_site_end_addr ; }
+	uint64_t getCallSiteEndAddressPosition() const { return call_site_end_addr_position; }
+	uint64_t getLandingPadAddress() const  { return landing_pad_addr ; }
+	uint64_t getLandingPadAddressPosition() const { return landing_pad_addr_position; }
+	uint64_t getLandingPadAddressEndPosition() const { return landing_pad_addr_end_position; }
 
 	bool parse_lcs(	
 		const uint64_t action_table_start_addr, 	
@@ -294,9 +310,11 @@ class lsda_t : public LSDA_t, private eh_frame_util_t<ptrsize>
 	uint8_t type_table_encoding;
 	uint64_t type_table_offset;
 	uint64_t type_table_addr;
+	uint64_t type_table_addr_location;
 	uint8_t cs_table_encoding;
 	uint64_t cs_table_start_offset;
 	uint64_t cs_table_start_addr;
+	uint64_t cs_table_start_addr_location;
 	uint64_t cs_table_length;
 	uint64_t cs_table_end_addr;
 	uint64_t action_table_start_addr;
@@ -324,9 +342,17 @@ class lsda_t : public LSDA_t, private eh_frame_util_t<ptrsize>
 	                const uint64_t fde_region_start
 	                );
 	void print() const;
-        const CallSiteVector_t* getCallSites() const ;
-        const call_site_table_t<ptrsize> getCallSitesInternal() const { return call_site_table;}
-        const TypeTableVector_t* getTypeTable() const ;
+	uint64_t getLandingPadBaseAddress() const {  return landing_pad_base_addr; }
+	const CallSiteVector_t* getCallSites() const ;
+	uint64_t getCallSiteTableAddress() const { return cs_table_start_addr; }
+	uint64_t getCallSiteTableAddressLocation() const { return cs_table_start_addr_location; }
+	uint64_t getCallSiteTableLength() const { return cs_table_length; }
+	uint8_t getCallSiteTableEncoding() const { return cs_table_encoding; }
+	const call_site_table_t<ptrsize> getCallSitesInternal() const { return call_site_table;}
+	const TypeTableVector_t* getTypeTable() const ;
+	uint64_t getTypeTableAddress() const { return type_table_addr; }
+	uint64_t getTypeTableAddressLocation() const { return type_table_addr_location; }
+	uint8_t getTypeTableEncoding() const { return type_table_encoding; }
 
 };
 
@@ -343,7 +369,11 @@ class fde_contents_t : public FDEContents_t, eh_frame_util_t<ptrsize>
 	uint64_t fde_end_addr;
 	uint64_t fde_range_len;
 	uint64_t lsda_addr;
-
+    uint64_t fde_start_addr_position;
+    uint64_t fde_end_addr_position;
+    uint64_t fde_end_addr_size;
+    uint64_t fde_lsda_addr_position;
+    uint64_t fde_lsda_addr_size;
 
 	lsda_t<ptrsize> lsda;
 	eh_program_t<ptrsize> eh_pgm;
@@ -356,8 +386,8 @@ class fde_contents_t : public FDEContents_t, eh_frame_util_t<ptrsize>
 		fde_start_addr(start_addr),
 		fde_end_addr(end_addr)
 	{} 
-
-
+	uint64_t getPosition() const { return fde_position; }
+	uint64_t getLength() const { return length; }
 	uint64_t getStartAddress() const { return fde_start_addr; } 
 	uint64_t getEndAddress() const {return fde_end_addr; }
 
@@ -373,7 +403,12 @@ class fde_contents_t : public FDEContents_t, eh_frame_util_t<ptrsize>
 	const LSDA_t* getLSDA() const { return &lsda; } // shared_ptr<LSDA_t>(new lsda_t<ptrsize>(lsda)) ;  }
 	const lsda_t<ptrsize>& getLSDAInternal() const { return lsda; }
 
-        uint64_t getLSDAAddress() const { return lsda_addr; }  
+    uint64_t getLSDAAddress() const { return lsda_addr; }
+    uint64_t getStartAddressPosition() const { return fde_start_addr_position; }
+    uint64_t getEndAddressPosition() const { return fde_end_addr_position; }
+    uint64_t getEndAddressSize() const { return fde_end_addr_size; }
+	uint64_t getLSDAAddressPosition() const { return fde_lsda_addr_position; }
+	uint64_t getLSDAAddressSize() const { return fde_lsda_addr_size; }
 
 	bool parse_fde(
 		const uint32_t &fde_position,