diff --git a/SConscript b/SConscript
index a2fc2e5252f99d7d382066d930582f5cb76d08d9..324fbb1d41e23764f7ed83c9cb8b22fc9cf6a053 100644
--- a/SConscript
+++ b/SConscript
@@ -96,6 +96,9 @@ dump_map=SConscript("dump_map/SConscript", variant_dir='scons_build/dump_map')
dump_insns=SConscript("dump_insns/SConscript", variant_dir='scons_build/dump_insns')
ir_builders=SConscript("ir_builders/SConscript", variant_dir='scons_build/ir_builders')
+if int(env['build_deep']) == 1:
+ libIRDBdeep=env.SConscript("libIRDB-deep/src/SConscript", variant_dir='scons_build/libIRDB-deep')
+
tools=None
if 'build_tools' not in env or env['build_tools'] is None or int(env['build_tools']) == 1:
@@ -103,11 +106,32 @@ if 'build_tools' not in env or env['build_tools'] is None or int(env['build_tool
if "PEDI_HOME" in os.environ:
Depends(pedi,tools)
+libs=( libIRDBcore,
+ libIRDBcfg,
+ libIRDButil,
+ libIRDBcore,
+ libehp,
+ libtransform,
+ libEXEIO,
+ libMEDSannotation,
+ libStructDiv,
+ libElfDep,
+ libcapstone,
+ thanos,
+ rida,
+ meds2pdb,
+ dump_map,
+ dump_insns,
+ ir_builders)
+
+if int(env['build_deep'] == 1):
+ libs=libs+libIRDBdeep
+
if "PEDI_HOME" in os.environ:
- Depends(pedi, (libIRDBcore, libIRDBcfg, libIRDButil, libIRDBcore, libehp,libtransform,libEXEIO,libMEDSannotation,libStructDiv,libElfDep, libcapstone, thanos, rida, meds2pdb, dump_map, dump_insns, ir_builders))
+ Depends(pedi, libs)
Default( pedi )
else:
- Default(libIRDBcore, libIRDBcfg, libIRDButil, libIRDBcore, libehp,libtransform,libEXEIO,libMEDSannotation,libStructDiv,libElfDep, libcapstone, thanos, rida, meds2pdb, dump_map, dump_insns, ir_builders)
+ Default(libIRDBcore, libIRDBcfg, libIRDButil, libIRDBdeep, libIRDBcore, libehp,libtransform,libEXEIO,libMEDSannotation,libStructDiv,libElfDep, libcapstone, thanos, rida, meds2pdb, dump_map, dump_insns, ir_builders)
if 'build_tools' not in env or env['build_tools'] is None or int(env['build_tools']) == 1:
Default(tools)
diff --git a/SConstruct b/SConstruct
index 1fe720b55f5bd58cbaba194eed003ab966294b4f..1232a0c1dbbe170548c352eda055cb70b393718b 100644
--- a/SConstruct
+++ b/SConstruct
@@ -13,16 +13,17 @@ env.Replace(CFLAGS="-fPIC -fmax-errors=2 -Wall -Werror -fmax-errors=2")
env.Replace(CXXFLAGS="-fPIC -fmax-errors=2 -Wall -Werror -fmax-errors=2 ")
env.Replace(LINKFLAGS="-fPIC -fmax-errors=2 -Wall -Werror -fmax-errors=2 ")
-# parse arguments
+# parse arguments into env and set default values.
env.Replace(SECURITY_TRANSFORMS_HOME=os.environ['SECURITY_TRANSFORMS_HOME'])
env.Replace(IRDB_SDK=os.environ['IRDB_SDK'])
-#env.Replace(SMPSA_HOME=os.environ['SMPSA_HOME'])
+env.Replace(SMPSA_HOME=os.environ['SMPSA_HOME'])
env.Replace(do_64bit_build=ARGUMENTS.get("do_64bit_build",None))
env.Replace(debug=ARGUMENTS.get("debug",0))
-env.Replace(build_appfw=ARGUMENTS.get("build_appfw", 0))
+env.Replace(build_deep=ARGUMENTS.get("build_deep", 0))
env.Replace(build_tools=ARGUMENTS.get("build_tools", 1))
env.Replace(build_stars=ARGUMENTS.get("build_stars", 1))
env.Replace(build_cgc=ARGUMENTS.get("build_cgc", 0))
+
if 'PEDI_HOME' in os.environ:
env.Replace(PEDI_HOME=os.environ['PEDI_HOME'])
diff --git a/libIRDB-deep/src/SConscript b/libIRDB-deep/src/SConscript
new file mode 100644
index 0000000000000000000000000000000000000000..5b4788ef9245b5a89fd94091d88f01cf588225f3
--- /dev/null
+++ b/libIRDB-deep/src/SConscript
@@ -0,0 +1,27 @@
+import os
+
+Import('env')
+myenv=env
+
+
+libname="irdb-deep"
+files= '''
+ deep.cpp
+ '''
+cpppath='''
+ $IRDB_SDK/include/
+ $SECURITY_TRANSFORMS_HOME/include/
+ $SECURITY_TRANSFORMS_HOME/libMEDSannotation/include
+ $SMPSA_HOME/include/
+ '''
+
+#myenv.Append(CCFLAGS=" -Wall -W -Wextra -Wconversion ")
+
+myenv=myenv.Clone(CPPPATH=Split(cpppath))
+myenv.Append(CXXFLAGS = " -std=c++11 ")
+lib=myenv.SharedLibrary(libname, Split(files), LIBS=Split("irdb-core irdb-util irdb-transform stars MEDSannotation"), LIBPATH=Split("$SECURITY_TRANSFORMS_HOME/lib"))
+
+install=env.Install("$SECURITY_TRANSFORMS_HOME/lib/", lib)
+Default(install)
+
+Return('install')
diff --git a/libIRDB-deep/src/deep.cpp b/libIRDB-deep/src/deep.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7ce18abae9e9f5405ebf9d9f2bbbe2f2933bb5b7
--- /dev/null
+++ b/libIRDB-deep/src/deep.cpp
@@ -0,0 +1,128 @@
+
+#include <map>
+#include <set>
+#include <memory>
+#include "deep.hpp"
+#include <MEDS_DeadRegAnnotation.hpp>
+#include <MEDS_MemoryRangeAnnotation.hpp>
+
+
+using namespace libIRDB;
+using namespace std;
+using namespace MEDS_Annotation;
+
+
+StarsDeepAnalysis_t::StarsDeepAnalysis_t(IRDB_SDK::FileIR_t* firp, const vector<string>& options)
+ : Transform(firp)
+{
+ stars_analysis_engine.do_STARS(getFileIR());
+}
+
+unique_ptr<IRDB_SDK::DeadRegisterMap_t> StarsDeepAnalysis_t::getDeadRegisters() const
+{
+ auto ret=unique_ptr<IRDB_SDK::DeadRegisterMap_t>(new IRDB_SDK::DeadRegisterMap_t);
+ auto &ret_map=*ret;
+ auto meds_ap=stars_analysis_engine.getAnnotations();
+ for(auto insn : getFileIR()->getInstructions())
+ {
+ auto the_range = meds_ap.getAnnotations().equal_range(insn->getBaseID());
+ /* for each annotation for this instruction */
+ for (auto it = the_range.first; it != the_range.second; ++it)
+ {
+ auto p_annotation=dynamic_cast<MEDS_DeadRegAnnotation*>(it->second);
+ if(p_annotation==nullptr)
+ continue;
+
+ /* bad annotation? */
+ if(!p_annotation->isValid())
+ continue;
+
+ /* record dead reg set */
+ ret_map[insn] = p_annotation->getRegisterSet();
+ }
+ }
+
+ return ret;
+}
+
+unique_ptr<IRDB_SDK::StaticGlobalStartMap_t> StarsDeepAnalysis_t::getStaticGlobalRanges() const
+{
+ auto ret=unique_ptr<IRDB_SDK::StaticGlobalStartMap_t>(new IRDB_SDK::StaticGlobalStartMap_t());
+ auto &ret_map=*ret;
+ auto meds_ap=stars_analysis_engine.getAnnotations();
+ for(auto insn : getFileIR()->getInstructions())
+ {
+ auto the_range = meds_ap.getAnnotations().equal_range(insn->getBaseID());
+ /* for each annotation for this instruction */
+ for (auto it = the_range.first; it != the_range.second; ++it)
+ {
+ auto p_annotation=dynamic_cast<MEDS_MemoryRangeAnnotation*>(it->second);
+ if(p_annotation==nullptr)
+ continue;
+
+ /* bad annotation? */
+ if(!p_annotation->isValid())
+ continue;
+
+ if(!p_annotation->isStaticGlobalRange())
+ continue;
+
+ // record the range minimum.
+ ret_map[insn] = p_annotation->getRangeMin();
+ }
+ }
+
+ return ret;
+}
+
+unique_ptr<IRDB_SDK::RangeSentinelSet_t> StarsDeepAnalysis_t::getRangeSentinels() const
+{
+ auto ret=unique_ptr<IRDB_SDK::RangeSentinelSet_t>(new IRDB_SDK::RangeSentinelSet_t);
+ auto meds_ap=stars_analysis_engine.getAnnotations();
+ for(auto insn : getFileIR()->getInstructions())
+ {
+ auto the_range = meds_ap.getAnnotations().equal_range(insn->getBaseID());
+ /* for each annotation for this instruction */
+ for (auto it = the_range.first; it != the_range.second; ++it)
+ {
+ auto p_annotation=dynamic_cast<MEDS_MemoryRangeAnnotation*>(it->second);
+ if(p_annotation==nullptr)
+ continue;
+
+ /* bad annotation? */
+ if(!p_annotation->isValid())
+ continue;
+
+ if(!p_annotation->isSentinel())
+ continue;
+
+ /* record sentinal marker. */
+ ret->insert(insn);
+ }
+ }
+ return ret;
+}
+
+
+unique_ptr<IRDB_SDK::DeepAnalysis_t> IRDB_SDK::DeepAnalysis_t::factory(FileIR_t* firp, const AnalysisEngine_t& ae, const vector<string>& options)
+{
+
+ auto ret=unique_ptr<IRDB_SDK::DeepAnalysis_t>();
+
+ switch(ae)
+ {
+ case IRDB_SDK::aeSTARS:
+ {
+ ret.reset(new libIRDB::StarsDeepAnalysis_t(firp,options));
+ break;
+ }
+ default:
+ {
+ throw std::invalid_argument("AnalysisEngine_t value not supported");
+ }
+
+ }
+ return ret;
+}
+
+
diff --git a/libIRDB-deep/src/deep.hpp b/libIRDB-deep/src/deep.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..fa552fd1b1360c081723dc8c2ae003fe01b8abca
--- /dev/null
+++ b/libIRDB-deep/src/deep.hpp
@@ -0,0 +1,33 @@
+
+#include <irdb-core>
+#include <irdb-transform>
+#include <irdb-deep>
+#include <memory>
+#include <vector>
+
+#include <stars.h>
+
+
+namespace libIRDB
+{
+ using namespace std;
+
+ class StarsDeepAnalysis_t : public IRDB_SDK::DeepAnalysis_t, protected IRDB_SDK::Transform
+ {
+ private:
+ StarsDeepAnalysis_t() = delete;
+ StarsDeepAnalysis_t(const StarsDeepAnalysis_t& copy) = delete;
+
+ public:
+
+ StarsDeepAnalysis_t(IRDB_SDK::FileIR_t* firp, const vector<string>& options={});
+
+ unique_ptr<IRDB_SDK::DeadRegisterMap_t > getDeadRegisters() const ;
+ unique_ptr<IRDB_SDK::StaticGlobalStartMap_t > getStaticGlobalRanges() const ;
+ unique_ptr<IRDB_SDK::RangeSentinelSet_t > getRangeSentinels() const ;
+
+ private:
+ STARS::IRDB_Interface_t stars_analysis_engine;
+
+ };
+}
diff --git a/libIRDB-transform/src/transform.cpp b/libIRDB-transform/src/transform.cpp
index 52e4e2469ec28bb77b63fad57991b076d2d8f59b..fb70acbcdd23e41ad6abf9b94c90eb4997d289fa 100644
--- a/libIRDB-transform/src/transform.cpp
+++ b/libIRDB-transform/src/transform.cpp
@@ -34,6 +34,11 @@ FileIR_t* Transform::getFileIR()
return m_fileIR;
}
+const FileIR_t* Transform::getFileIR() const
+{
+ return m_fileIR;
+}
+
Instruction_t* Transform::insertAssemblyBefore(Instruction_t* before, const string &the_asm, Instruction_t* target)
{
return IRDB_SDK::insertAssemblyBefore(getFileIR(), before, the_asm, target);
diff --git a/libIRDB-util/src/SConscript b/libIRDB-util/src/SConscript
index b57c532c186b2f609e50620c4dd156e9d720a6bc..fee25b597ad027296a0ee24b950916fb0105c8e0 100644
--- a/libIRDB-util/src/SConscript
+++ b/libIRDB-util/src/SConscript
@@ -10,6 +10,7 @@ files= '''
insn_preds.cpp
IBT_Provenance.cpp
params.cpp
+ registers.cpp
'''
cpppath='''
$IRDB_SDK/include/
diff --git a/libIRDB-util/src/registers.cpp b/libIRDB-util/src/registers.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b9ee000e008a2e4cb46da90bd747d80a348769cc
--- /dev/null
+++ b/libIRDB-util/src/registers.cpp
@@ -0,0 +1,423 @@
+
+
+#include <string>
+#include <irdb-util>
+
+using namespace std;
+using namespace IRDB_SDK;
+
+RegisterID_t IRDB_SDK::strToRegister(const char *p_reg)
+{
+ return strToRegister(string(p_reg));
+}
+
+bool IRDB_SDK::isValidRegister(const RegisterID_t p_reg)
+{
+ return p_reg != rn_UNKNOWN;
+}
+
+RegisterID_t IRDB_SDK::strToRegister(const string& p_reg)
+{
+ if (strcasecmp(p_reg.c_str(), "EFLAGS") ==0)
+ return rn_EFLAGS;
+ else if (strcasecmp(p_reg.c_str(), "RAX") == 0)
+ return rn_RAX;
+ else if (strcasecmp(p_reg.c_str(), "RBX") == 0)
+ return rn_RBX;
+ else if (strcasecmp(p_reg.c_str(), "RCX") == 0)
+ return rn_RCX;
+ else if (strcasecmp(p_reg.c_str(), "RDX") == 0)
+ return rn_RDX;
+ else if (strcasecmp(p_reg.c_str(), "RSI") == 0)
+ return rn_RSI;
+ else if (strcasecmp(p_reg.c_str(), "RDI") == 0)
+ return rn_RDI;
+ else if (strcasecmp(p_reg.c_str(), "RBP") == 0)
+ return rn_RBP;
+ else if (strcasecmp(p_reg.c_str(), "RSP") == 0)
+ return rn_RSP;
+ else if (strcasecmp(p_reg.c_str(), "R8") == 0)
+ return rn_R8;
+ else if (strcasecmp(p_reg.c_str(), "R9") == 0)
+ return rn_R9;
+ else if (strcasecmp(p_reg.c_str(), "R10") == 0)
+ return rn_R10;
+ else if (strcasecmp(p_reg.c_str(), "R11") == 0)
+ return rn_R11;
+ else if (strcasecmp(p_reg.c_str(), "R12") == 0)
+ return rn_R12;
+ else if (strcasecmp(p_reg.c_str(), "R13") == 0)
+ return rn_R13;
+ else if (strcasecmp(p_reg.c_str(), "R14") == 0)
+ return rn_R14;
+ else if (strcasecmp(p_reg.c_str(), "R15") == 0)
+ return rn_R15;
+ else if (strcasecmp(p_reg.c_str(), "RIP") == 0)
+ return rn_RIP;
+
+ else if (strcasecmp(p_reg.c_str(), "EAX") == 0)
+ return rn_EAX;
+ else if (strcasecmp(p_reg.c_str(), "EBX") == 0)
+ return rn_EBX;
+ else if (strcasecmp(p_reg.c_str(), "ECX") == 0)
+ return rn_ECX;
+ else if (strcasecmp(p_reg.c_str(), "EDX") == 0)
+ return rn_EDX;
+ else if (strcasecmp(p_reg.c_str(), "ESI") == 0)
+ return rn_ESI;
+ else if (strcasecmp(p_reg.c_str(), "EDI") == 0)
+ return rn_EDI;
+ else if (strcasecmp(p_reg.c_str(), "EBP") == 0)
+ return rn_EBP;
+ else if (strcasecmp(p_reg.c_str(), "ESP") == 0)
+ return rn_ESP;
+ else if (strcasecmp(p_reg.c_str(), "R8D") == 0)
+ return rn_R8D;
+ else if (strcasecmp(p_reg.c_str(), "R9D") == 0)
+ return rn_R9D;
+ else if (strcasecmp(p_reg.c_str(), "R10D") == 0)
+ return rn_R10D;
+ else if (strcasecmp(p_reg.c_str(), "R11D") == 0)
+ return rn_R11D;
+ else if (strcasecmp(p_reg.c_str(), "R12D") == 0)
+ return rn_R12D;
+ else if (strcasecmp(p_reg.c_str(), "R13D") == 0)
+ return rn_R13D;
+ else if (strcasecmp(p_reg.c_str(), "R14D") == 0)
+ return rn_R14D;
+ else if (strcasecmp(p_reg.c_str(), "R15D") == 0)
+ return rn_R15D;
+
+ else if (strcasecmp(p_reg.c_str(), "AX") == 0)
+ return rn_AX;
+ else if (strcasecmp(p_reg.c_str(), "BX") == 0)
+ return rn_BX;
+ else if (strcasecmp(p_reg.c_str(), "CX") == 0)
+ return rn_CX;
+ else if (strcasecmp(p_reg.c_str(), "DX") == 0)
+ return rn_DX;
+ else if (strcasecmp(p_reg.c_str(), "BP") == 0)
+ return rn_BP;
+ else if (strcasecmp(p_reg.c_str(), "SP") == 0)
+ return rn_SP;
+ else if (strcasecmp(p_reg.c_str(), "SI") == 0)
+ return rn_SI;
+ else if (strcasecmp(p_reg.c_str(), "DI") == 0)
+ return rn_DI;
+ else if (strcasecmp(p_reg.c_str(), "R8W") == 0)
+ return rn_R8W;
+ else if (strcasecmp(p_reg.c_str(), "R9W") == 0)
+ return rn_R9W;
+ else if (strcasecmp(p_reg.c_str(), "R10W") == 0)
+ return rn_R10W;
+ else if (strcasecmp(p_reg.c_str(), "R11W") == 0)
+ return rn_R11W;
+ else if (strcasecmp(p_reg.c_str(), "R12W") == 0)
+ return rn_R12W;
+ else if (strcasecmp(p_reg.c_str(), "R13W") == 0)
+ return rn_R13W;
+ else if (strcasecmp(p_reg.c_str(), "R14W") == 0)
+ return rn_R14W;
+ else if (strcasecmp(p_reg.c_str(), "R15W") == 0)
+ return rn_R15W;
+
+ else if (strcasecmp(p_reg.c_str(), "AH") == 0)
+ return rn_AL;
+ else if (strcasecmp(p_reg.c_str(), "BH") == 0)
+ return rn_BL;
+ else if (strcasecmp(p_reg.c_str(), "CH") == 0)
+ return rn_CL;
+ else if (strcasecmp(p_reg.c_str(), "DH") == 0)
+ return rn_DL;
+ else if (strcasecmp(p_reg.c_str(), "AL") == 0)
+ return rn_AL;
+ else if (strcasecmp(p_reg.c_str(), "BL") == 0)
+ return rn_BL;
+ else if (strcasecmp(p_reg.c_str(), "CL") == 0)
+ return rn_CL;
+ else if (strcasecmp(p_reg.c_str(), "DL") == 0)
+ return rn_DL;
+ else if (strcasecmp(p_reg.c_str(), "SIL") == 0)
+ return rn_SIL;
+ else if (strcasecmp(p_reg.c_str(), "DIL") == 0)
+ return rn_DIL;
+ else if (strcasecmp(p_reg.c_str(), "BPL") == 0)
+ return rn_BPL;
+ else if (strcasecmp(p_reg.c_str(), "SPL") == 0)
+ return rn_SPL;
+ else if (strcasecmp(p_reg.c_str(), "R8B") == 0)
+ return rn_R8B;
+ else if (strcasecmp(p_reg.c_str(), "R9B") == 0)
+ return rn_R9B;
+ else if (strcasecmp(p_reg.c_str(), "R10B") == 0)
+ return rn_R10B;
+ else if (strcasecmp(p_reg.c_str(), "R11B") == 0)
+ return rn_R11B;
+ else if (strcasecmp(p_reg.c_str(), "R12B") == 0)
+ return rn_R12B;
+ else if (strcasecmp(p_reg.c_str(), "R13B") == 0)
+ return rn_R13B;
+ else if (strcasecmp(p_reg.c_str(), "R14B") == 0)
+ return rn_R14B;
+ else if (strcasecmp(p_reg.c_str(), "R15B") == 0)
+ return rn_R15B;
+ else
+ return rn_UNKNOWN;
+}
+
+bool IRDB_SDK::is8bitRegister(const RegisterID_t p_reg)
+{
+ return p_reg == rn_AL || p_reg == rn_BL || p_reg == rn_CL || p_reg == rn_DL ||
+ p_reg == rn_AH || p_reg == rn_BH || p_reg == rn_CH || p_reg == rn_DH ||
+ p_reg == rn_SIL || p_reg == rn_DIL || p_reg == rn_BPL || p_reg == rn_SPL ||
+ p_reg == rn_R8B || p_reg == rn_R9B || p_reg == rn_R10B || p_reg == rn_R11B ||
+ p_reg == rn_R12B || p_reg == rn_R13B || p_reg == rn_R14B || p_reg == rn_R15B;
+}
+
+bool IRDB_SDK::is16bitRegister(const RegisterID_t p_reg)
+{
+ return p_reg == rn_AX || p_reg == rn_BX || p_reg == rn_CX || p_reg == rn_DX ||
+ p_reg == rn_BP || p_reg == rn_SP || p_reg == rn_SI || p_reg == rn_DI ||
+ p_reg == rn_R8W || p_reg == rn_R9W || p_reg == rn_R10W || p_reg == rn_R11W ||
+ p_reg == rn_R12W || p_reg == rn_R13W || p_reg == rn_R14W || p_reg == rn_R15W;
+}
+
+bool IRDB_SDK::is32bitRegister(const RegisterID_t p_reg)
+{
+ return p_reg == rn_EAX || p_reg == rn_EBX || p_reg == rn_ECX || p_reg == rn_EDX ||
+ p_reg == rn_ESI || p_reg == rn_EDI || p_reg == rn_ESP || p_reg == rn_EBP ||
+ p_reg == rn_R8D || p_reg == rn_R9D || p_reg == rn_R10D || p_reg == rn_R11D ||
+ p_reg == rn_R12D || p_reg == rn_R13D || p_reg == rn_R14D || p_reg == rn_R15D;
+}
+
+bool IRDB_SDK::is64bitRegister(const RegisterID_t p_reg)
+{
+ return p_reg == rn_RAX || p_reg == rn_RBX || p_reg == rn_RCX || p_reg == rn_RDX ||
+ p_reg == rn_RSI || p_reg == rn_RDI || p_reg == rn_RBP || p_reg == rn_RSP ||
+ p_reg == rn_R8 || p_reg == rn_R9 || p_reg == rn_R10 || p_reg == rn_R11 ||
+ p_reg == rn_R12 || p_reg == rn_R13 || p_reg == rn_R14 || p_reg == rn_R15 || p_reg == rn_RIP;
+}
+
+string IRDB_SDK::registerToString(const RegisterID_t p_reg)
+{
+ if (p_reg == rn_UNKNOWN) return string("UNKNOWN");
+
+ else if (p_reg == rn_EFLAGS) return string("EFLAGS");
+
+ else if (p_reg == rn_RAX) return string("RAX");
+ else if (p_reg == rn_RBX) return string("RBX");
+ else if (p_reg == rn_RCX) return string("RCX");
+ else if (p_reg == rn_RDX) return string("RDX");
+ else if (p_reg == rn_RSI) return string("RSI");
+ else if (p_reg == rn_RDI) return string("RDI");
+ else if (p_reg == rn_RBP) return string("RBP");
+ else if (p_reg == rn_RSP) return string("RSP");
+ else if (p_reg == rn_R8) return string("R8");
+ else if (p_reg == rn_R9) return string("R9");
+ else if (p_reg == rn_R10) return string("R10");
+ else if (p_reg == rn_R11) return string("R11");
+ else if (p_reg == rn_R12) return string("R12");
+ else if (p_reg == rn_R13) return string("R13");
+ else if (p_reg == rn_R14) return string("R14");
+ else if (p_reg == rn_R15) return string("R15");
+ else if (p_reg == rn_RIP) return string("RIP");
+
+ else if (p_reg == rn_EAX) return string("EAX");
+ else if (p_reg == rn_EBX) return string("EBX");
+ else if (p_reg == rn_ECX) return string("ECX");
+ else if (p_reg == rn_EDX) return string("EDX");
+ else if (p_reg == rn_EDI) return string("EDI");
+ else if (p_reg == rn_ESI) return string("ESI");
+ else if (p_reg == rn_EBP) return string("EBP");
+ else if (p_reg == rn_ESP) return string("ESP");
+ else if (p_reg == rn_R8D) return string("R8D");
+ else if (p_reg == rn_R9D) return string("R9D");
+ else if (p_reg == rn_R10D) return string("R10D");
+ else if (p_reg == rn_R11D) return string("R11D");
+ else if (p_reg == rn_R12D) return string("R12D");
+ else if (p_reg == rn_R13D) return string("R13D");
+ else if (p_reg == rn_R14D) return string("R14D");
+ else if (p_reg == rn_R15D) return string("R15D");
+
+ else if (p_reg == rn_AX) return string("AX");
+ else if (p_reg == rn_BX) return string("BX");
+ else if (p_reg == rn_CX) return string("CX");
+ else if (p_reg == rn_DX) return string("DX");
+ else if (p_reg == rn_BP) return string("BP");
+ else if (p_reg == rn_SP) return string("SP");
+ else if (p_reg == rn_SI) return string("SI");
+ else if (p_reg == rn_DI) return string("DI");
+ else if (p_reg == rn_R8W) return string("R8W");
+ else if (p_reg == rn_R9W) return string("R9W");
+ else if (p_reg == rn_R10W) return string("R10W");
+ else if (p_reg == rn_R11W) return string("R11W");
+ else if (p_reg == rn_R12W) return string("R12W");
+ else if (p_reg == rn_R13W) return string("R13W");
+ else if (p_reg == rn_R14W) return string("R14W");
+ else if (p_reg == rn_R15W) return string("R15W");
+
+ else if (p_reg == rn_AH) return string("AH");
+ else if (p_reg == rn_BH) return string("BH");
+ else if (p_reg == rn_CH) return string("CH");
+ else if (p_reg == rn_DH) return string("DH");
+ else if (p_reg == rn_AL) return string("AL");
+ else if (p_reg == rn_BL) return string("BL");
+ else if (p_reg == rn_CL) return string("CL");
+ else if (p_reg == rn_DL) return string("DL");
+ else if (p_reg == rn_SIL) return string("SIL");
+ else if (p_reg == rn_DIL) return string("DIL");
+ else if (p_reg == rn_BPL) return string("BPL");
+ else if (p_reg == rn_SPL) return string("SPL");
+ else if (p_reg == rn_R8B) return string("R8B");
+ else if (p_reg == rn_R9B) return string("R9B");
+ else if (p_reg == rn_R10B) return string("R10B");
+ else if (p_reg == rn_R11B) return string("R11B");
+ else if (p_reg == rn_R12B) return string("R12B");
+ else if (p_reg == rn_R13B) return string("R13B");
+ else if (p_reg == rn_R14B) return string("R14B");
+ else if (p_reg == rn_R15B) return string("R15B");
+
+ else return string("UNEXPECTED REGISTER VALUE");
+}
+
+
+RegisterID_t IRDB_SDK::convertRegisterTo64bit(const RegisterID_t p_reg)
+{
+ if (is64bitRegister(p_reg))
+ return p_reg;
+
+ switch (p_reg)
+ {
+ case rn_AL:
+ case rn_AH:
+ case rn_AX:
+ case rn_EAX:
+ return rn_RAX;
+ case rn_BL:
+ case rn_BH:
+ case rn_BX:
+ case rn_EBX:
+ return rn_RBX;
+ case rn_CL:
+ case rn_CH:
+ case rn_CX:
+ case rn_ECX:
+ return rn_RCX;
+ case rn_DL:
+ case rn_DH:
+ case rn_DX:
+ case rn_EDX:
+ return rn_RDX;
+ case rn_DIL:
+ case rn_DI:
+ case rn_EDI:
+ return rn_RDI;
+ case rn_SIL:
+ case rn_SI:
+ case rn_ESI:
+ return rn_RSI;
+ case rn_BPL:
+ case rn_BP:
+ case rn_EBP:
+ return rn_RBP;
+ case rn_SPL:
+ case rn_SP:
+ case rn_ESP:
+ return rn_RSP;
+ case rn_R8B:
+ case rn_R8W:
+ case rn_R8D:
+ return rn_R8;
+ case rn_R9B:
+ case rn_R9W:
+ case rn_R9D:
+ return rn_R9;
+ case rn_R10B:
+ case rn_R10W:
+ case rn_R10D:
+ return rn_R10;
+ case rn_R11B:
+ case rn_R11W:
+ case rn_R11D:
+ return rn_R11;
+ case rn_R12B:
+ case rn_R12W:
+ case rn_R12D:
+ return rn_R12;
+ case rn_R13B:
+ case rn_R13W:
+ case rn_R13D:
+ return rn_R13;
+ case rn_R14B:
+ case rn_R14W:
+ case rn_R14D:
+ return rn_R14;
+ case rn_R15B:
+ case rn_R15W:
+ case rn_R15D:
+ return rn_R15;
+
+ default:
+ return rn_UNKNOWN;
+ break;
+ }
+}
+
+RegisterID_t IRDB_SDK::convertRegisterTo32bit(const RegisterID_t p_reg)
+{
+ if (is32bitRegister(p_reg))
+ return p_reg;
+
+ switch (p_reg)
+ {
+ case rn_RAX: return rn_EAX;
+ case rn_RBX: return rn_EBX;
+ case rn_RCX: return rn_ECX;
+ case rn_RDX: return rn_EDX;
+ case rn_RBP: return rn_EBP;
+ case rn_RSP: return rn_ESP;
+ case rn_RSI: return rn_ESI;
+ case rn_RDI: return rn_EDI;
+ case rn_R8: return rn_R8D;
+ case rn_R9: return rn_R9D;
+ case rn_R10: return rn_R10D;
+ case rn_R11: return rn_R11D;
+ case rn_R12: return rn_R12D;
+ case rn_R13: return rn_R13D;
+ case rn_R14: return rn_R14D;
+ case rn_R15: return rn_R15D;
+ default:
+ return rn_UNKNOWN;
+ break;
+ }
+}
+
+RegisterID_t IRDB_SDK::convertRegisterTo16bit(const RegisterID_t p_reg)
+{
+ if (is16bitRegister(p_reg))
+ return p_reg;
+
+ switch (p_reg)
+ {
+ case rn_RAX: case rn_EAX: return rn_AX;
+ case rn_RBX: case rn_EBX: return rn_BX;
+ case rn_RCX: case rn_ECX: return rn_CX;
+ case rn_RDX: case rn_EDX: return rn_DX;
+ case rn_RBP: case rn_EBP: return rn_BP;
+ case rn_RSP: case rn_ESP: return rn_SP;
+ case rn_RSI: case rn_ESI: return rn_SI;
+ case rn_RDI: case rn_EDI: return rn_DI;
+ case rn_R8: case rn_R8D: return rn_R8W;
+ case rn_R9: case rn_R9D: return rn_R9W;
+ case rn_R10: case rn_R10D: return rn_R10W;
+ case rn_R11: case rn_R11D: return rn_R11W;
+ case rn_R12: case rn_R12D: return rn_R12W;
+ case rn_R13: case rn_R13D: return rn_R13W;
+ case rn_R14: case rn_R14D: return rn_R14W;
+ case rn_R15: case rn_R15D: return rn_R15W;
+ default:
+ return rn_UNKNOWN;
+ break;
+ }
+}
+
diff --git a/libMEDSannotation/include/MEDS_Register.hpp b/libMEDSannotation/include/MEDS_Register.hpp
index ae0ad88d9df4b52d839f33ba6436144b591bf77e..c1207a0608112e35dfa5a5bab123aed9f4f08ea6 100644
--- a/libMEDSannotation/include/MEDS_Register.hpp
+++ b/libMEDSannotation/include/MEDS_Register.hpp
@@ -24,6 +24,7 @@
#include <string>
#include <set>
#include <irdb-util>
+#include <irdb-deep>
namespace MEDS_Annotation
{
@@ -46,7 +47,7 @@ typedef std::set<RegisterName> RegisterSet_t;
#endif
using RegisterName = IRDB_SDK::RegisterID;
using RegisterName_t = IRDB_SDK::RegisterID_t;
-using RegisterSet_t = std::set<RegisterName_t>;
+using RegisterSet_t = IRDB_SDK::RegisterIDSet_t;