Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found

Target

Select target project
  • opensrc/libehp
1 result
Show changes
Commits on Source (17)
Hide whitespace changes
Inline Side-by-side
.gitignore
View file @ 26232ebf
......@@ -6,4 +6,6 @@ src/libehp.a
src/.*.swp
src/*.o
include/.*.swp
*.os
*.so
CMakeLists.txt 0 → 100644
View file @ 26232ebf
#
# 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=1)
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/third-party/elfio-code/)
else()
add_definitions(-DUSE_ELFIO=0)
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)
README.md
View file @ 26232ebf
......@@ -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
SConscript
View file @ 26232ebf
......@@ -17,21 +17,24 @@
import os
Import('env')
myenv=env.Clone();
env.Replace(debug=ARGUMENTS.get("debug",0))
if int(env['debug']) == 1:
myenv.Replace(debug=ARGUMENTS.get("debug",0))
myenv.Append(CFLAGS=" -DUSE_ELFIO=1 ")
myenv.Append(CXXFLAGS=" -DUSE_ELFIO=1 ")
if int(myenv['debug']) == 1:
print "Setting debug mode"
env.Append(CFLAGS=" -g ")
env.Append(CXXFLAGS=" -g ")
env.Append(LINKFLAGS=" -g ")
myenv.Append(CFLAGS=" -g ")
myenv.Append(CXXFLAGS=" -g ")
myenv.Append(LINKFLAGS=" -g ")
else:
print "Setting release mode"
env.Append(CFLAGS=" -O3 ")
env.Append(CXXFLAGS=" -O3 ")
env.Append(LINKFLAGS=" -O3 ")
myenv.Append(CFLAGS=" -O3 ")
myenv.Append(CXXFLAGS=" -O3 ")
myenv.Append(LINKFLAGS=" -O3 ")
lib=SConscript("src/SConscript")
lib=myenv.SConscript("src/SConscript")
Return('lib')
include/ehp.hpp
View file @ 26232ebf
......@@ -25,6 +25,10 @@
#include <vector>
#ifndef USE_ELFIO
#define USE_ELFIO 1
#endif
namespace EHP
{
......@@ -39,6 +43,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 +74,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 +124,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 +145,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 +166,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 +200,9 @@ class EHFrameParser_t
virtual const CIEVector_t* getCIEs() const =0;
virtual const FDEContents_t* findFDE(uint64_t addr) const =0;
#if 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 0 → 100644
View file @ 26232ebf
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
View file @ 26232ebf
......@@ -26,7 +26,6 @@ cpppath='''
'''
cpppath=cpppath+Dir('.').srcnode().abspath+'/../third-party/elfio-code'
LIBPATH="$SECURITY_TRANSFORMS_HOME/lib"
LIBS=Split("")
......
src/ehp.cpp
View file @ 26232ebf
......@@ -29,12 +29,21 @@
#include "ehp_priv.hpp"
#include "scoop_replacement.hpp"
#ifndef USE_ELFIO
#define USE_ELFIO 1
#endif
#if USE_ELFIO
#include <elfio/elfio.hpp>
#endif
#include <elf.h>
using namespace std;
using namespace EHP;
#if USE_ELFIO
using namespace ELFIO;
#endif
#define ALLOF(s) begin(s), end(s)
......@@ -285,7 +294,7 @@ template <int ptrsize>
void eh_program_insn_t<ptrsize>::print(uint64_t &pc, int64_t caf) 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");
static_assert(is_same<unsigned char, uint8_t>::value, "uint8_t is not unsigned char");
auto &data=program_bytes;
auto opcode=program_bytes[0];
......@@ -496,6 +505,170 @@ void eh_program_insn_t<ptrsize>::print(uint64_t &pc, int64_t caf) const
}
template <int ptrsize>
tuple<string, int64_t, int64_t> eh_program_insn_t<ptrsize>::decode() const
{
// make sure uint8_t is an unsigned char.
static_assert(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 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 make_tuple("unexpected_error", 0, 0);
// case DW_CFA_offset:
return make_tuple("offset", +opcode_lower6, uleb);
case 3:
// case DW_CFA_restore (register #):
return make_tuple("restore", +opcode_lower6, 0);
case 0:
switch(opcode_lower6)
{
case DW_CFA_nop:
return make_tuple("nop", 0, 0);
case DW_CFA_remember_state:
return make_tuple("remember_state", 0, 0);
case DW_CFA_restore_state:
return 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 make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("set_loc", arg, 0);
}
case DW_CFA_advance_loc1:
{
auto loc = *(uint8_t*)(&data.data()[pos]);
return make_tuple("advance_loc", loc, 0);
}
case DW_CFA_advance_loc2:
{
auto loc = *(uint16_t*)(&data.data()[pos]);
return make_tuple("advance_loc", loc, 0);
}
case DW_CFA_advance_loc4:
{
auto loc = *(uint32_t*)(&data.data()[pos]);
return 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 make_tuple("unexpected_error", 0, 0);
if(eh_frame_util_t<ptrsize>::read_uleb128(
uleb2, pos, (const uint8_t* const)data.data(), max))
return make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
if(eh_frame_util_t<ptrsize>::read_uleb128(
uleb2, pos, (const uint8_t* const)data.data(), max))
return make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
if(eh_frame_util_t<ptrsize>::read_uleb128(
uleb2, pos, (const uint8_t* const)data.data(), max))
return make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
if(eh_frame_util_t<ptrsize>::read_sleb128(
sleb, pos, (const uint8_t* const)data.data(), max))
return make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unexpected_error", 0, 0);
if(eh_frame_util_t<ptrsize>::read_sleb128(
sleb, pos, (const uint8_t* const)data.data(), max))
return make_tuple("unexpected_error", 0, 0);
return 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 make_tuple("unhandled_instruction", 0, 0);
}
default:
return 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); }
......@@ -750,7 +923,7 @@ template <int ptrsize>
bool eh_program_insn_t<ptrsize>::advance(uint64_t &cur_addr, uint64_t CAF) 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");
static_assert(is_same<unsigned char, uint8_t>::value, "uint8_t is not unsigned char");
auto &data=program_bytes;
auto opcode=program_bytes[0];
......@@ -986,10 +1159,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 +1173,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 +1192,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 +1203,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;
......@@ -1131,6 +1311,10 @@ bool lsda_type_table_entry_t<ptrsize>::parse(
case DW_EH_PE_sdata4:
tt_encoding_size=4;
break;
case DW_EH_PE_udata8:
case DW_EH_PE_sdata8:
tt_encoding_size=8;
break;
case DW_EH_PE_absptr:
tt_encoding_size=ptrsize;
break;
......@@ -1203,15 +1387,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 +1520,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 +1696,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 +1714,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 +1729,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 +1737,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 +1957,7 @@ const FDEContents_t* split_eh_frame_impl_t<ptrsize>::findFDE(uint64_t addr) cons
return raw_ret_ptr;
}
#if USE_ELFIO
unique_ptr<const EHFrameParser_t> EHFrameParser_t::factory(const string filename)
{
auto elfiop=unique_ptr<elfio>(new elfio);
......@@ -1789,6 +1994,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,
......@@ -1806,7 +2012,7 @@ unique_ptr<const EHFrameParser_t> EHFrameParser_t::factory(
else if(ptrsize==8)
ret_val=new split_eh_frame_impl_t<8>(eh_frame_sr,eh_frame_hdr_sr,gcc_except_table_sr);
else
throw std::out_of_range("ptrsize must be 4 or 8");
throw out_of_range("ptrsize must be 4 or 8");
ret_val->parse();
......
src/ehp_priv.hpp
View file @ 26232ebf
......@@ -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;
tuple<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,
......