diff --git a/.gitattributes b/.gitattributes
index 41c9bce0ebf3b57820de3c62dfaa2c12a3207b96..9b24f332804e0a9594a4988bf87c790ad1cf8c22 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -4,6 +4,7 @@
/README.txt -text
/SConscript -text
/SConscript.ida -text
+/SConscript.ida7 -text
/SConscript.irdb_lib -text
/SConstruct -text
/SMP-analyze.sh -text
diff --git a/SConscript b/SConscript
index ad02ba33336e6f3c03b649ddfebf970f4f1d40fa..ae670f495e91ceac72f5b23219da5e9089c0d2dd 100644
--- a/SConscript
+++ b/SConscript
@@ -9,6 +9,7 @@ argenv.Replace(debugmem=ARGUMENTS.get("debugmem",0))
argenv.Replace(do_64bit_analysis=ARGUMENTS.get("do_64bit_analysis",1))
argenv.Replace(do_64bit_build=ARGUMENTS.get("do_64bit_build",2))
argenv.Replace(build_ida=ARGUMENTS.get("build_ida",1))
+argenv.Replace(build_ida7=ARGUMENTS.get("build_ida7",0))
argenv.Replace(build_irdb=ARGUMENTS.get("build_irdb",1))
argenv.Replace(build_irdb_driver=ARGUMENTS.get("build_irdb_driver",0))
argenv.Replace(install=ARGUMENTS.get("install",1))
@@ -78,6 +79,24 @@ if int(argenv['build_ida']) == 1:
argenv.Default(ab)
+if int(argenv['build_ida7']) == 1:
+ if argenv['IDASDK'] is None:
+ print 'Cannot proceed without IDASDK set.'
+ exit(1)
+
+ if argenv['IDAROOT'] is None:
+ print 'Cannot proceed without IDAROOT set.'
+ exit(1)
+
+ print "Build IDA 7.0+ Plugin"
+ lib=SConscript('SConscript.ida7', variant_dir='build_ida')
+ print "Done build IDA Plugin"
+ test=argenv.Command(target="./test.log", source=lib, action="IDAROOT=$IDAROOT SMPSA_HOME=$SMPSA_HOME $SMPSA_HOME/tests/scripts/make_baseline.sh 2>&1 |tee ./test.log")
+ argenv.Depends(test,lib)
+ ab=argenv.AlwaysBuild(test)
+ argenv.Default(ab)
+
+
if int(argenv['build_irdb']) == 1 or int(argenv['build_irdb_driver']) == 1:
if argenv['SECURITY_TRANSFORMS_HOME'] is None:
print 'Cannot build libstars.a without SECURITY_TRANSFORMS_HOME set. Did you forget the env. var.? Or try setting build_irdb=0. '
diff --git a/SConscript.ida7 b/SConscript.ida7
new file mode 100644
index 0000000000000000000000000000000000000000..fc12b100530ea70330b59fddba5a0662bb24d806
--- /dev/null
+++ b/SConscript.ida7
@@ -0,0 +1,83 @@
+import os
+
+Import('argenv', 'STARS_CCFLAGS')
+
+idaenv=argenv.Clone()
+
+dirs='''
+ src/base
+ src/interfaces
+ src/interfaces/abstract
+ src/interfaces/idapro
+ src/drivers/idapro
+ '''
+dirs=Split(dirs)
+
+
+cpppath=''' \
+ $SMPSA_HOME/include \
+ $SMPSA_HOME/include/base \
+ $SMPSA_HOME/include/interfaces \
+ $SMPSA_HOME/include/interfaces/abstract \
+ $IDASDK/include \
+ $SMPSA_HOME/include/interfaces/idapro \
+ '''
+
+IDA_CCFLAGS=''' -std=c++0x \
+ -D__LINUX__ -Wall -Wno-unused-variable -Wno-attributes \
+ -Wno-unused-local-typedefs -Wno-parentheses \
+ -Wno-strict-aliasing -Wno-sign-compare \
+ -Wno-unused-but-set-variable --short-enums -m64 \
+ -DSTARS_IDA_INTERFACE -Wmaybe-uninitialized -Winit-self \
+ -D__PLUGIN__ -D__X64__ \
+ -D__IDP__ \
+ '''+STARS_CCFLAGS
+
+
+if int(idaenv['do_64bit_analysis']) == 1:
+ IDA_LDFLAGS="-m64 --shared -L$IDAROOT -lida64 \
+ -Wl,--version-script=$SMPSA_HOME/scripts/plugin.script"
+else:
+ IDA_LDFLAGS="-m64 --shared -L$IDAROOT -lida \
+ -Wl,--version-script=$SMPSA_HOME/scripts/plugin.script"
+
+
+# find files
+#print 'dirs: ',dirs
+files=[]
+for dir in dirs:
+ files=files+Glob(os.path.join(dir,"*.cpp"))
+
+# set suffix properly
+if int(idaenv['do_64bit_analysis']) == 1:
+ SHLIBSUF="64.so"
+else:
+ SHLIBSUF=".so"
+
+idaenv=idaenv.Clone(CCFLAGS=IDA_CCFLAGS, SHLINKFLAGS=IDA_LDFLAGS, SHLIBSUFFIX=SHLIBSUF, SHLIBPREFIX="", CPPPATH=Split(cpppath));
+
+if int(idaenv['do_64bit_analysis']) == 1:
+ lib=idaenv.SharedLibrary('SMPStaticAnalyzer', files, LIBPATH="$IDAROOT", libs="ida64")
+else:
+ lib=idaenv.SharedLibrary('SMPStaticAnalyzer', files, LIBPATH="$IDAROOT", libs="ida")
+
+
+install=idaenv.Install("$IDAROOT/idc/", "$SMPSA_HOME/scripts/SMP.idc")
+Default(install)
+
+install=idaenv.Install("$SMPSA_HOME/install/", "$SMPSA_HOME/scripts/SMP.idc")
+Default(install)
+
+install=idaenv.Install("$SMPSA_HOME/install/", lib)
+Default(install)
+
+install=idaenv.Install("$IDAROOT/plugins/", lib)
+Default(install)
+Return('install')
+
+
+
+
+
+
+
diff --git a/include/base/SMPDataFlowAnalysis.h b/include/base/SMPDataFlowAnalysis.h
index 2397053b0987b66a71928333ea7b1c48ee5118d4..85da141f549b404fa5df73d3af0692b26093c546 100644
--- a/include/base/SMPDataFlowAnalysis.h
+++ b/include/base/SMPDataFlowAnalysis.h
@@ -65,8 +65,12 @@ class STARSBitSet;
// IDA_SDK_VERSION is defined in pro.h starting in version 5.2 or 5.7 of the SDK.
#ifndef IDA_SDK_VERSION
+#ifdef __X64__
+#define IDA_SDK_VERSION 700 // To make Visual Studio display code properly
+#else
#define IDA_SDK_VERSION 695 // To make Visual Studio display code properly
#endif
+#endif
// Insert a floating no-op instruction at top of each function to hold SSA DEFs
// of LiveIn names?
diff --git a/include/interfaces/SMPDBInterface.h b/include/interfaces/SMPDBInterface.h
index 815d25d87d33331844500bdcc3e1c051d5a6b860..de3bd49c62e1179eb22770c06fb2798cd670ba68 100644
--- a/include/interfaces/SMPDBInterface.h
+++ b/include/interfaces/SMPDBInterface.h
@@ -222,7 +222,7 @@ extern const char *CallTypeNames[4];
#define SMP_get_spd(ptr_to_func, ea) (ptr_to_func->get_spd(ea))
#define SMP_generate_disasm_line(InstAddr, CharArray, CharArrayLimit) global_stars_interface->STARS_generate_disasm_line(InstAddr, CharArray, CharArrayLimit)
-#define SMP_tag_remove(InBuf, OutBuf, OutBufSize) global_stars_interface->STARS_tag_remove(InBuf, OutBuf, OutBufSize)
+#define SMP_tag_remove(OutBuf, InBuf, OutBufSize) global_stars_interface->STARS_tag_remove(OutBuf, InBuf, OutBufSize)
#define SMP_AuditTailChunkOwnership() (global_stars_interface->AuditTailChunkOwnership())
#define SMP_AuditCodeTargets() (global_stars_interface->AuditCodeTargets())
diff --git a/include/interfaces/STARSIDATypes.h b/include/interfaces/STARSIDATypes.h
index 9a1e822b0a21ce60978a64a5c7b0548c3d214d97..94ba7aacf1e8ee3da05bc21843f5d56f590025d3 100644
--- a/include/interfaces/STARSIDATypes.h
+++ b/include/interfaces/STARSIDATypes.h
@@ -57,10 +57,48 @@
// Globals, typedefs and macros for STARS_IDA_INTERFACE only
+#if (IDA_SDK_VERSION < 700)
+typedef area_t STARS_area_t;
+#define GetChunkStart(chunk) chunk.startEA;
+#define GetChunkEnd(chunk) chunk.endEA;
+#else
+typedef range_t STARS_area_t;
+#define GetChunkStart(chunk) chunk.start_ea;
+#define GetChunkEnd(chunk) chunk.end_ea;
+#endif
+
+#if (IDA_SDK_VERSION < 700)
#define SMP_isHead(flags) isHead(flags)
+#define SMP_isTail(flags) isTail(flags)
#define SMP_isCode(flags) isCode(flags)
+#define SMP_isData(flags) isData(flags)
+#define SMP_isUnknown(flags) isUnknown(flags)
+#define SMP_get_flags_novalue(ea) ::get_flags_novalue(ea)
+#define SMP_hasRef hasRef
+#define SMP_del_items(addr, len, flags) ::do_unknown_range(addr, len, DOUNK_SIMPLE)
+#define SMP_create_data do_data_ex
+#define SMP_byteflag byteflag
+#define SMP_auto_empty_finally ph.auto_empty_finally
+#else
+#define SMP_isHead(flags) is_head(flags)
+#define SMP_isTail(flags) is_tail(flags)
+#define SMP_isCode(flags) is_code(flags)
+#define SMP_isData(flags) is_data(flags)
+#define SMP_isUnknown(flags) is_unknown(flags)
+#define SMP_get_flags_novalue(ea) ::get_full_flags(ea)
+#define SMP_hasRef has_xref
+#define SMP_del_items(addr, len, flags) ::del_items(addr, DELIT_SIMPLE, len)
+#define SMP_create_data create_data
+#define SMP_byteflag byte_flag
+#define SMP_auto_empty_finally ((idb_event::event_code_t) auto_empty_finally)
+#endif
+
#define SMP_get_item_end(addr) get_item_end(addr)
+#if (IDA_SDK_VERSION < 700)
#define SMP_getFlags(addr) getFlags(addr)
+#else
+#define SMP_getFlags(addr) get_full_flags(addr)
+#endif
// #if 1
#define SMP_get_frame(ptr_to_func_t) get_frame(ptr_to_func_t)
// #else
@@ -69,7 +107,6 @@
// #define SMP_get_member_name(mid, buf, bufsize) get_member_name(mid, buf, bufsize)
// #define SMP_get_true_name(from, ea, buf, bufsize) get_true_name(from, ea, buf, bufsize)
#define SMP_next_head(ea, maxea) next_head(ea, maxea)
-#define SMP_get_flags_novalue(ea) get_flags_novalue(ea)
#define SMP_add_cref(from, to, type) add_cref(from, to, type)
diff --git a/include/interfaces/abstract/STARSInterface.h b/include/interfaces/abstract/STARSInterface.h
index 749fc63e51b054f011cab847f58cf1c57653cf3a..b8e0c001f8c667fee1faee614f5a31d6561df0a8 100644
--- a/include/interfaces/abstract/STARSInterface.h
+++ b/include/interfaces/abstract/STARSInterface.h
@@ -68,7 +68,7 @@ class STARS_Interface_t
virtual int STARS_snprintf(char *buffer, std::size_t n, const char *format, ...) = 0;
// Disasm methods.
- virtual STARS_ssize_t STARS_tag_remove(const char *instr, char *buf, std::size_t bufsize) = 0;
+ virtual STARS_ssize_t STARS_tag_remove(char *instr, char *buf, std::size_t bufsize) = 0;
virtual bool STARS_generate_disasm_line(STARS_ea_t addr, char *buf, std::size_t bufsize, int flags = 0) = 0;
// Misc. methods
diff --git a/include/interfaces/abstract/STARSProgram.h b/include/interfaces/abstract/STARSProgram.h
index 01bc2785e692aaafa17180e954851d1b53b6fbe8..c1ec7758d9f82bbc2fc6cad7f61c1062caebdcc5 100644
--- a/include/interfaces/abstract/STARSProgram.h
+++ b/include/interfaces/abstract/STARSProgram.h
@@ -113,6 +113,7 @@ class STARS_Program_t
// Analysis methods
virtual bool IsImmedCodeAddress(STARS_ea_t ImmedValue) { return false; }; // Is ImmedValue a code address?
+ virtual bool IsImmedDataAddress(STARS_ea_t ImmedValue) { return false; }; // Is ImmedValue a data address?
virtual void ReportTotalCodeSize(unsigned long long TotalCodeSize) = 0; // Set flags, take actions based on code size.
virtual void InitStaticDataTable(SMPProgram *CurrProg) = 0; // Process global static data sections
virtual void GetBlockSuccessorTargets(bool CallFlag, STARS_InstructionID_t LastBlockInst, std::size_t InstSize, std::list<STARS_InstructionID_t> &SuccList) = 0; // Get successors for LastBlockInst, omitting call targets
diff --git a/include/interfaces/idapro/STARSFunction.h b/include/interfaces/idapro/STARSFunction.h
index 89ad00c8e0ed7f5a3dda5f165f4f5a0b424c422e..c3e3cbb9d0af10e0dd688d7eccff109f08572103 100644
--- a/include/interfaces/idapro/STARSFunction.h
+++ b/include/interfaces/idapro/STARSFunction.h
@@ -23,12 +23,21 @@ public:
// Accessor methods
+#if (IDA_SDK_VERSION < 700)
virtual STARS_ea_t get_startEA() { return the_func->startEA; }
virtual STARS_ea_t get_endEA() { return the_func->endEA; }
+#else
+ virtual STARS_ea_t get_startEA() { return the_func->start_ea; }
+ virtual STARS_ea_t get_endEA() { return the_func->end_ea; }
+#endif
virtual std::size_t GetFuncSize() { return (std::size_t) (get_endEA() - get_startEA()); }
virtual char* GetFunctionName(char* name, const int len) const {
qstring TempName;
+#if (IDA_SDK_VERSION < 700)
STARS_ssize_t NameLen = ::get_func_name2(&TempName, the_func->startEA);
+#else
+ STARS_ssize_t NameLen = ::get_func_name(&TempName, the_func->start_ea);
+#endif
if (NameLen >= len) {
NameLen = len - 1;
}
@@ -47,7 +56,11 @@ public:
// Query methods
virtual bool FunctionUsesFP() { return (0 != (the_func->flags & (FUNC_FRAME | FUNC_BOTTOMBP))); }
virtual bool HasSharedChunks() const { return SharedChunks; }
+#if (IDA_SDK_VERSION < 700)
virtual bool IsStaticFunction() { return (0 != (the_func->flags & FUNC_STATIC)); }
+#else
+ virtual bool IsStaticFunction() { return (0 != (the_func->flags & FUNC_STATICDEF)); }
+#endif
virtual bool IsLibraryFunction() { return (0 != (the_func->flags & FUNC_LIB)); }
virtual bool IsStackPointerAnalyzed() { return the_func->analyzed_sp(); }
virtual bool HasReturnPoints() { return the_func->does_return(); }
diff --git a/include/interfaces/idapro/STARSInterface.h b/include/interfaces/idapro/STARSInterface.h
index 0d46b52c7051202945e6fa468a2c91802abf6733..982da0d7883afb1a8528a4650995bfca65b7a911 100644
--- a/include/interfaces/idapro/STARSInterface.h
+++ b/include/interfaces/idapro/STARSInterface.h
@@ -17,13 +17,13 @@
#include "interfaces/idapro/STARSFunction.h"
#include "interfaces/idapro/STARSInstruction.h"
-class STARS_IDA_Interface_t: public STARS_Interface_t
+class STARS_IDA_Interface_t : public STARS_Interface_t
{
public:
// Constructors
STARS_IDA_Interface_t() : CGCBinary(false) {};
-
+
// Segment accessors
virtual STARS_Segment_t *getseg(const STARS_ea_t &addr) {
@@ -93,10 +93,36 @@ public:
virtual int STARS_snprintf(char *buffer, std::size_t n, const char *format, ...);
// Disasm methods.
- virtual STARS_ssize_t STARS_tag_remove(const char *instr, char *buf, std::size_t bufsize) { return tag_remove(instr, buf, bufsize); };
+#if (IDA_SDK_VERSION < 700)
+ virtual STARS_ssize_t STARS_tag_remove(char *instr, char *buf, std::size_t bufsize) { return tag_remove(instr, buf, bufsize); };
+#else
+ virtual STARS_ssize_t STARS_tag_remove(char *instr, char *buf, std::size_t bufsize) {
+ qstring *temp = new qstring();
+ temp->resize(bufsize);
+ STARS_ssize_t ReturnLen = tag_remove(temp, buf);
+ if (0 <= ReturnLen) {
+ qstrncpy(instr, temp->c_str(), bufsize);
+ }
+ delete temp;
+ return ReturnLen;
+ };
+#endif
+#if (IDA_SDK_VERSION < 700)
virtual bool STARS_generate_disasm_line(STARS_ea_t addr, char *buf, std::size_t bufsize, int flags = 0) {
- return generate_disasm_line(addr, buf, bufsize, flags);
+ return ::generate_disasm_line(addr, buf, bufsize, flags);
}
+#else
+ virtual bool STARS_generate_disasm_line(STARS_ea_t addr, char *buf, std::size_t bufsize, int flags = 0) {
+ qstring *temp = new qstring();
+ temp->resize(bufsize);
+ bool success = ::generate_disasm_line(temp, addr, flags);
+ if (success) {
+ qstrncpy(buf, temp->c_str(), bufsize);
+ }
+ delete temp;
+ return success;
+ }
+#endif
// Miscellaneous methods.
virtual void SetCGCBinary(void) { CGCBinary = true; };
diff --git a/include/interfaces/idapro/STARSOp.h b/include/interfaces/idapro/STARSOp.h
index e2aa8b515eb248d5c54d879463fddbda14759515..0d287c3b16f38a86e164ae1313ca53953267f00c 100644
--- a/include/interfaces/idapro/STARSOp.h
+++ b/include/interfaces/idapro/STARSOp.h
@@ -35,7 +35,13 @@ class STARS_IDA_op_t : public STARS_op_t
int GetSIBScaleFactor(void) const { return ((m_Opnd.sib >> 6) & 3); }; // Extract scale factor from SIB byte
char GetSpecFlag4(void) const { return m_Opnd.specflag4; }; // Get specflag4 byte, used to hold a copy of the auxpref byte in x86-64 programs.
STARS_uval_t GetImmedValue(void) const { return m_Opnd.value; }; // Get value field for immediate operands; uint32 for x86-32, uint64 for x86-64
- char GetOpDtyp(void) const { return m_Opnd.dtyp; }; // Get field that determines byte width
+ char GetOpDtyp(void) const { // Get field that determines byte width
+#if (IDA_SDK_VERSION < 700)
+ return m_Opnd.dtyp;
+#else
+ return m_Opnd.dtype;
+#endif
+ };
uint16_t GetByteWidth(void) const;
// Set methods
diff --git a/include/interfaces/idapro/STARSProgram.h b/include/interfaces/idapro/STARSProgram.h
index e4c19082bbbd497ead0ae85216ca04c4539fd9ba..632b5c1cd7804ad8ebabe65034421e158da69545 100644
--- a/include/interfaces/idapro/STARSProgram.h
+++ b/include/interfaces/idapro/STARSProgram.h
@@ -41,8 +41,23 @@ public:
// NOTE: Change this when we do targets with data (other than switch tables) in code.
// Call IsDataAddress() first to weed out data items in the code range.
bool IsImmedCodeAddress(STARS_ea_t ImmedValue) {
- return ((ImmedValue >= LowestCodeAddress) && (ImmedValue <= HighestCodeAddress));
+ STARS_Segment_t *seg = global_stars_interface->getseg(ImmedValue);
+ bool FoundCodeAddress = false;
+ if (nullptr != seg) {
+ FoundCodeAddress = seg->IsCodeSegment();
+ }
+ return FoundCodeAddress;
}
+
+ bool IsImmedDataAddress(STARS_ea_t ImmedValue) {
+ STARS_Segment_t *seg = global_stars_interface->getseg(ImmedValue);
+ bool FoundDataAddress = false;
+ if (nullptr != seg) {
+ FoundDataAddress = seg->IsDataSegment();
+ }
+ return FoundDataAddress;
+ }
+
void ReportTotalCodeSize(unsigned long long TotalCodeSize);
void InitStaticDataTable(SMPProgram *CurrProg);
void GetBlockSuccessorTargets(bool CallFlag, STARS_InstructionID_t LastBlockInst, std::size_t InstSize, std::list<STARS_InstructionID_t> &SuccList); // Get successors for LastBlockInst, omitting call targets
diff --git a/include/interfaces/idapro/STARSSegment.h b/include/interfaces/idapro/STARSSegment.h
index 12db2726451fba272b4ccce70defed5e1e72d0b5..c97ea2c20e854ba7ceed62d5e8ba3f66406b2a79 100644
--- a/include/interfaces/idapro/STARSSegment.h
+++ b/include/interfaces/idapro/STARSSegment.h
@@ -12,8 +12,13 @@ class STARS_IDA_Segment_t : public STARS_Segment_t
public:
STARS_IDA_Segment_t(segment_t* seg) : the_seg(seg) {}
- virtual STARS_ea_t get_startEA() { return the_seg->startEA; }
+#if (IDA_SDK_VERSION < 700)
+ virtual STARS_ea_t get_startEA() { return the_seg->startEA; }
virtual STARS_ea_t get_endEA() { return the_seg->endEA; }
+#else
+ virtual STARS_ea_t get_startEA() { return the_seg->start_ea; }
+ virtual STARS_ea_t get_endEA() { return the_seg->end_ea; }
+#endif
virtual std::size_t get_seg_size() { return (std::size_t)(get_endEA() - get_startEA()); }
virtual bool IsCodeSegment() const { return the_seg->type == SEG_CODE; }
virtual bool IsXternSegment() const { return the_seg->type == SEG_XTRN; }
@@ -22,7 +27,18 @@ class STARS_IDA_Segment_t : public STARS_Segment_t
virtual bool IsBSSSegment() const { return the_seg->type == SEG_BSS; }
virtual bool IsReadableSegment() const { return the_seg->perm & SEGPERM_READ; }
virtual bool IsWriteableSegment() const { return the_seg->perm & SEGPERM_WRITE; }
- virtual STARS_ssize_t GetSegmentName(char* name, int len) { return ::get_segm_name(the_seg,name,len); }
+#if (IDA_SDK_VERSION < 700)
+ virtual STARS_ssize_t GetSegmentName(char* name, int len) { return ::get_segm_name(the_seg, name, len); }
+#else
+ virtual STARS_ssize_t GetSegmentName(char* name, int len) {
+ qstring *temp = new qstring();
+ temp->resize(len);
+ STARS_ssize_t SegSize = ::get_visible_segm_name(temp, the_seg);
+ qstrncpy(name, temp->c_str(), len);
+ delete temp;
+ return SegSize;
+ }
+#endif
// Fetch read-only data values, if any.
virtual bool GetReadOnlyMem64BitValue(STARS_ea_t MemAddr, uint64_t &Value) const {
@@ -32,7 +48,11 @@ class STARS_IDA_Segment_t : public STARS_Segment_t
}
virtual bool GetReadOnlyMem32BitValue(STARS_ea_t MemAddr, uint32_t &Value) const {
assert(!IsWriteableSegment());
+#if (IDA_SDK_VERSION < 700)
Value = (uint32_t) ::get_long(MemAddr);
+#else
+ Value = (uint32_t) ::get_dword(MemAddr);
+#endif
return true;
}
virtual bool GetReadOnlyMem16BitValue(STARS_ea_t MemAddr, uint16_t &Value) const {
diff --git a/include/interfaces/irdb/STARSInterface.h b/include/interfaces/irdb/STARSInterface.h
index d9471a205afb97dcacb19032a43ddcbaa34efe57..8153e00bc7edd8e988ce1b619a3ea1aa36b9a3f6 100644
--- a/include/interfaces/irdb/STARSInterface.h
+++ b/include/interfaces/irdb/STARSInterface.h
@@ -154,7 +154,7 @@ public:
{ va_list ap; va_start(ap,format); return vsnprintf(buffer,n, format, ap); }
// Disasm methods.
- virtual STARS_ssize_t STARS_tag_remove(const char *instr, char *buf, std::size_t bufsize)
+ virtual STARS_ssize_t STARS_tag_remove(char *instr, char *buf, std::size_t bufsize)
{
/* remove comments, etc. from disassembly.*/
// do strcpy from instr to buf
diff --git a/src/base/SMPInstr.cpp b/src/base/SMPInstr.cpp
index 35d938575422887101bee5ad90b2a58d0e24385f..0ea71004d2fdd40e782833fe2fabbf75e18437e4 100644
--- a/src/base/SMPInstr.cpp
+++ b/src/base/SMPInstr.cpp
@@ -10836,9 +10836,9 @@ void SMPInstr::SetImmedTypes(bool UseFP) {
#endif
CurrUse = this->SetUseType(UseOp, GLOBALPTR);
}
-#if 0
- else if (IsDataAddress((STARS_ea_t) ImmVal)) {
- // NOTE: We must call IsDataAddress() before we call IsImmedCodeAddress()
+#if 1
+ else if (global_STARS_program->IsImmedDataAddress((STARS_ea_t) ImmVal)) {
+ // NOTE: We must ahve a deeper analysis before we call IsImmedCodeAddress()
// to catch the data addresses within the code address range.
#if SMP_VERBOSE_DEBUG_BUILD_RTL
if (DebugFlag) SMP_msg("Setting to POINTER\n");
diff --git a/src/base/SMPProgram.cpp b/src/base/SMPProgram.cpp
index d840c5ce4233c1e522cc012527a543cd6cef0f68..192ce676ec2576cee15fc6ea8956498a9ca2a6be 100644
--- a/src/base/SMPProgram.cpp
+++ b/src/base/SMPProgram.cpp
@@ -298,8 +298,8 @@ void SMPProgram::Analyze(ProfilerInformation *pi, FILE *AnnotFile, FILE *InfoAnn
unsigned long long STARS_TotalCodeSize = 0;
for (STARS_Segment_t *seg = SMP_get_first_seg(); NULL != seg; seg = SMP_get_next_seg(RecentAddr)) {
char SegName[STARS_MAXSTR];
+ STARS_ssize_t SegNameSize = SMP_get_segm_name(seg, SegName, STARS_MAXSTR - 1);
RecentAddr = seg->get_startEA();
- STARS_ssize_t SegNameSize = SMP_get_segm_name(seg, SegName, sizeof(SegName) - 1);
if (seg->IsCodeSegment()) {
STARS_TotalCodeSize += (seg->get_seg_size());
#if SMP_DEBUG
diff --git a/src/drivers/idapro/SMPStaticAnalyzer.cpp b/src/drivers/idapro/SMPStaticAnalyzer.cpp
index 09955dde592c620f1be34d4a23f4536fc5e146b9..cb3d6006b321f006a99dd930f8056d72e200e7ec 100644
--- a/src/drivers/idapro/SMPStaticAnalyzer.cpp
+++ b/src/drivers/idapro/SMPStaticAnalyzer.cpp
@@ -169,7 +169,11 @@ set<string> ZST_NetworkLocBlacklist;
// Set of system call names whose returned values should be trusted to have only benign numeric errors.
set<string> ZST_SystemCallNumericWhitelist;
+#if (IDA_SDK_VERSION < 700)
void IDAP_run(int);
+#else
+bool IDAP_run(size_t);
+#endif
// Functions for diagnosing and/or fixing problems in the IDA database.
void FixupIDB(void); // Driver for all other fixing functions.
@@ -212,6 +216,7 @@ bool STARS_custom_ana(STARS_ea_t CurrentAddr) {
pair<set<STARS_ea_t>::iterator, bool> InsertResult;
InsertResult = LockPreficesRemoved.insert(CurrentAddr);
assert(InsertResult.second);
+#if (IDA_SDK_VERSION < 700)
cmd.itype = NN_nop; // make it a no-op
cmd.size = 1; // one-byte no-op
#if 0
@@ -219,12 +224,18 @@ bool STARS_custom_ana(STARS_ea_t CurrentAddr) {
cmd.segpref = 0;
cmd.insnpref = 0;
cmd.flags = 0;
+#endif
#endif
return true;
}
} // end of STARS_custom_ana()
+#if (IDA_SDK_VERSION < 700)
static int idaapi idp_callback(void *, int event_id, va_list va) {
+#else
+static ssize_t idaapi idp_callback(void *, int event_id, va_list va) {
+#endif
+
#if STARS_REMOVE_LOCK_PREFIX
if (event_id == processor_t::custom_ana) {
STARS_ea_t CurrentAddr = cmd.ea;
@@ -247,8 +258,12 @@ static int idaapi idp_callback(void *, int event_id, va_list va) {
#endif
}
#endif // STARS_REMOVE_LOCK_PREFIX
-
- if (event_id == ph.auto_empty_finally) { // IDA analysis is done
+#if (IDA_SDK_VERSION < 700)
+ int CheckCode = ph.auto_empty_finally;
+#else
+ idb_event::event_code_t CheckCode = idb_event::auto_empty_finally;
+#endif
+ if (event_id == (int) CheckCode) { // IDA analysis is done
// Ensure correct working environment.
// Handle Cyber Grand Challenge project variant of ELF.
#define STARS_CGC_FILETYPE 16705
@@ -261,7 +276,11 @@ static int idaapi idp_callback(void *, int event_id, va_list va) {
else if (CGCFile) {
global_stars_interface->SetCGCBinary();
}
+#if (IDA_SDK_VERSION < 700)
IDAP_run(0);
+#else
+ bool success = IDAP_run(0);
+#endif
#if STARS_REMOVE_LOCK_PREFIX
SMP_msg("INFO: Calls to STARS_custom_ana: %lu \n", CustomAnaCallCount);
SMP_msg("INFO: Number of LOCK prefices eliminated: %zu \n", LockPreficesRemoved.size());
@@ -294,7 +313,11 @@ int IDAP_init(void) {
return PLUGIN_SKIP;
}
- hook_to_notification_point(HT_IDP, idp_callback, NULL);
+#if (IDA_SDK_VERSION < 700)
+ bool hooked = hook_to_notification_point(HT_IDP, idp_callback, NULL);
+#else
+ bool hooked = hook_to_notification_point(HT_IDB, idp_callback, NULL);
+#endif
#ifdef STARS_IRDB_INTERFACE
SMPLogFile = NULL;
#endif
@@ -302,11 +325,19 @@ int IDAP_init(void) {
} // end of IDAP_init
void IDAP_term(void) {
+#if (IDA_SDK_VERSION < 700)
unhook_from_notification_point(HT_IDP, idp_callback, NULL);
+#else
+ unhook_from_notification_point(HT_IDB, idp_callback, NULL);
+#endif
return;
}
+#if (IDA_SDK_VERSION < 700)
void IDAP_run(int arg) {
+#else
+bool IDAP_run(size_t arg) {
+#endif
FILE *AnnotFile = NULL;
FILE *InfoAnnotFile = NULL;
FILE *AsmFile;
@@ -400,7 +431,11 @@ void IDAP_run(int arg) {
error("FATAL ERROR: At least one file could not be opened.\n");
delete global_STARS_program;
delete global_stars_interface;
+#if (IDA_SDK_VERSION < 700)
return;
+#else
+ return false;
+#endif
}
string AsmFileName(global_STARS_program->GetRootFileName());
@@ -449,7 +484,11 @@ void IDAP_run(int arg) {
delete CurrProg;
delete global_STARS_program;
delete global_stars_interface;
+#if (IDA_SDK_VERSION < 700)
return;
+#else
+ return true;
+#endif
#endif
// Pre-audit the IDA database by seeing if the distinction
@@ -544,7 +583,11 @@ void IDAP_run(int arg) {
SMP_msg("INFO: Deleted CurrProg. Returning to IDA Pro.\n");
delete global_STARS_program;
delete global_stars_interface;
+#if (IDA_SDK_VERSION < 700)
return;
+#else
+ return true;
+#endif
}
catch (std::bad_alloc) {
SMP_msg("FATAL ERROR: Memory exhausted.\n");
@@ -559,7 +602,11 @@ void IDAP_run(int arg) {
delete prof_info;
delete global_STARS_program;
delete global_stars_interface;
+#if (IDA_SDK_VERSION < 700)
return;
+#else
+ return true;
+#endif
}
} // end IDAP_run()
@@ -631,7 +678,7 @@ void FindCodeAddresses(void) {
continue;
for (STARS_ea_t addr = seg->get_startEA(); addr < seg->get_endEA(); addr = SMP_get_item_end(addr)) {
- flags_t InstrFlags = getFlags(addr);
+ flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isHead(InstrFlags) && SMP_isCode(InstrFlags)) {
IDAProLocs.push_back(addr);
#if 0
@@ -643,7 +690,7 @@ void FindCodeAddresses(void) {
else if ((0x806cda4 <= addr) && (0x806cf99 >= addr)) {
if (!SMP_isHead(InstrFlags))
SMP_msg("Weirdness: not isHead at %x\n", addr);
- if (isUnknown(InstrFlags)) {
+ if (SMP_isUnknown(InstrFlags)) {
SMP_msg("Weirdness: isUnknown at %x\n", addr);
}
}
@@ -748,7 +795,7 @@ void FixupIDB(void) {
// of a data region, with the code addresses not agreeing with the
// external disassembler's code addresses. We will convert these
// misaligned instructions to data as we detect them. We will also
-// convert unexplored bytes (isUnknown(flags) == true) into data if
+// convert unexplored bytes (SMP_isUnknown(flags) == true) into data if
// they are in the midst of a data sequence.
#define MIN_DATARUN_LEN 24 // #bytes on either side of "isolated" code
void FindDataInCode(void) {
@@ -774,9 +821,9 @@ void FindDataInCode(void) {
SegName, seg->startEA, seg->endEA);
#endif
for (STARS_ea_t addr = seg->get_startEA(); addr < seg->get_endEA(); addr = SMP_get_item_end(addr)) {
- flags_t AddrFlags = getFlags(addr);
+ flags_t AddrFlags = SMP_getFlags(addr);
if (SMP_isHead(AddrFlags)) {
- if (isData(AddrFlags)) {
+ if (SMP_isData(AddrFlags)) {
DataRunLen += get_item_size(addr);
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Data: %x\n", addr);
@@ -784,9 +831,9 @@ void FindDataInCode(void) {
if (MIN_DATARUN_LEN <= DataRunLen) {
if (IsolatedCodeTrigger) {
// Saw data, then one isolated code, then data
- do_unknown_range(IsolatedCodeAddr, IsolatedCodeLen, DOUNK_SIMPLE);
+ SMP_del_items(IsolatedCodeAddr, IsolatedCodeLen, 0);
RemoveIDACodeAddr(IsolatedCodeAddr);
- if (do_data_ex(IsolatedCodeAddr, byteflag(),
+ if (SMP_create_data(IsolatedCodeAddr, SMP_byteflag(),
IsolatedCodeLen, BADNODE)) {
SMP_msg("Converted isolated code to data: %lx\n",
(unsigned long) IsolatedCodeAddr);
@@ -798,8 +845,8 @@ void FindDataInCode(void) {
IsolatedCodeTrigger = false;
} // end if (IsolatedCodeTrigger)
} // end if (MIN_DATARUN_LEN <= DataRunLen)
- } // end if (isData(AddrFlags)
- else if (isUnknown(AddrFlags)) {
+ } // end if (SMP_isData(AddrFlags)
+ else if (SMP_isUnknown(AddrFlags)) {
// Just in case; unknown usually means not head or tail
// If in a data run, convert to data.
InstrLen = get_item_size(addr);
@@ -807,7 +854,7 @@ void FindDataInCode(void) {
SMP_msg("Unknown: %x len: %x\n", addr, InstrLen);
#endif
if (0 < DataRunLen) {
- if (do_data_ex(addr, byteflag(), InstrLen, BADNODE)) {
+ if (SMP_create_data(addr, SMP_byteflag(), InstrLen, BADNODE)) {
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Converted unknown to data at %x len: %x\n", addr, InstrLen);
#endif
@@ -841,9 +888,9 @@ void FindDataInCode(void) {
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Code was misaligned.\n");
#endif
- ::do_unknown_range(addr, InstrLen, DOUNK_SIMPLE);
+ SMP_del_items(addr, InstrLen, 0);
RemoveIDACodeAddr(addr);
- if (do_data_ex(addr, byteflag(), InstrLen, BADNODE)) {
+ if (SMP_create_data(addr, SMP_byteflag(), InstrLen, BADNODE)) {
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Converted misaligned code to data at %x : len: %x\n",
addr, InstrLen);
@@ -860,7 +907,7 @@ void FindDataInCode(void) {
IsolatedCodeTrigger = false;
}
} // end if (IsCodeMisaligned() ...)
- else if (!hasRef(AddrFlags)) {
+ else if (!SMP_hasRef(AddrFlags)) {
// No references at all --> isolated code.
IsolatedCodeTrigger = true;
IsolatedCodeAddr = addr;
@@ -882,16 +929,16 @@ void FindDataInCode(void) {
IsolatedCodeTrigger = false;
}
DataRunLen = 0;
- } // end if (isData) ... else if (isUnknown) ... else SMP_isCode
+ } // end if (SMP_isData) ... else if (isUnknown) ... else SMP_isCode
} // end if (SMP_isHead)
- else if (isUnknown(AddrFlags)) {
+ else if (SMP_isUnknown(AddrFlags)) {
// If in a data run, convert to data.
InstrLen = get_item_size(addr);
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Unknown: %x len: %x\n", addr, InstrLen);
#endif
if (0 < DataRunLen) {
- if (do_data_ex(addr, byteflag(), InstrLen, BADNODE)) {
+ if (SMP_create_data(addr, SMP_byteflag(), InstrLen, BADNODE)) {
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Converted unknown to data at %x len: %x\n", addr, InstrLen);
#endif
@@ -965,7 +1012,7 @@ bool FindDataToConvert(size_t IDAProIndex, size_t DisasmIndex, int &AreaSize) {
if (DebugAddress) SMP_msg(" PrevIDAAddr: %lx NextIDAAddr: %lx\n", (unsigned long) PrevIDAAddr, (unsigned long) NextIDAAddr);
// See if previous IDA address was a return.
- flags_t PrevFlags = getFlags(PrevIDAAddr);
+ flags_t PrevFlags = SMP_getFlags(PrevIDAAddr);
if (!SMP_isCode(PrevFlags) || !SMP_isHead(PrevFlags)) {
SMP_msg("PrevIDAAddr %lx not isCode or not isHead.\n", (unsigned long) PrevIDAAddr);
return true;
@@ -983,12 +1030,12 @@ bool FindDataToConvert(size_t IDAProIndex, size_t DisasmIndex, int &AreaSize) {
// Now, see if the area from DisasmAddr to NextIDAAddr is all data
// according to IDA.
while (DisasmAddr < NextIDAAddr) {
- flags_t DataFlags = getFlags(DisasmAddr);
- if (isTail(DataFlags)) {
+ flags_t DataFlags = SMP_getFlags(DisasmAddr);
+ if (SMP_isTail(DataFlags)) {
if (DebugAddress) SMP_msg(" tail byte: %lx\n", (unsigned long) DisasmAddr);
DisasmAddr = SMP_get_item_end(DisasmAddr);
}
- else if (isData(DataFlags)) {
+ else if (SMP_isData(DataFlags)) {
if (DebugAddress) SMP_msg(" data byte: %lx\n", (unsigned long) DisasmAddr);
DisasmAddr = SMP_get_item_end(DisasmAddr);
}
@@ -1041,8 +1088,8 @@ bool IsFunctionPrologue(STARS_ea_t StartAddr, STARS_ea_t EndAddr) {
// code, and permits IDA to reanalyze the function later.
// Returns true if program bytes were patched.
bool MDPatchUnconvertedBytes(STARS_ea_t CurrDisasmAddr) {
- flags_t AddrFlags = getFlags(CurrDisasmAddr);
- if (isData(AddrFlags) || isTail(AddrFlags)) {
+ flags_t AddrFlags = SMP_getFlags(CurrDisasmAddr);
+ if (SMP_isData(AddrFlags) || SMP_isTail(AddrFlags)) {
// Bytes should have been converted to unknown already.
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Cannot patch data bytes or tail bytes at %x\n", CurrDisasmAddr);
@@ -1176,7 +1223,7 @@ void FixCodeIdentification(void) {
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Found data to convert: %x to %x\n", AreaStart, AreaEnd);
#endif
- do_unknown_range(AreaStart, AreaSize, DOUNK_SIMPLE);
+ SMP_del_items(AreaStart, AreaSize, 0);
SMP_bounds_t ConvertRegion;
ConvertRegion.startEA = AreaStart;
ConvertRegion.endEA = AreaEnd;
@@ -1185,8 +1232,8 @@ void FixCodeIdentification(void) {
bool AllConverted = true;
bool AllNops = true;
do {
- flags_t InstrFlags = getFlags(CurrDisasmAddr);
- if (!isUnknown(InstrFlags)) {
+ flags_t InstrFlags = SMP_getFlags(CurrDisasmAddr);
+ if (!SMP_isUnknown(InstrFlags)) {
SMP_msg("Sync problem in FixCodeID: %lx\n", (unsigned long) CurrDisasmAddr);
}
else {
@@ -1241,8 +1288,8 @@ void FixCodeIdentification(void) {
SMP_msg("FixCodeID nops region from %x to %x\n", CurrRegion.GetStart(),
CurrRegion.GetEnd());
#endif
- do_unknown_range(CurrRegion.GetStart(),
- CurrRegion.GetEnd() - CurrRegion.GetStart(), DOUNK_SIMPLE);
+ SMP_del_items(CurrRegion.GetStart(),
+ CurrRegion.GetEnd() - CurrRegion.GetStart(), 0);
CodeReanalyzeList.pop_back();
}
} // end if (SkipArea) ... else ...
@@ -1254,7 +1301,7 @@ void FixCodeIdentification(void) {
// If there are still Disasm addrs to process, try to turn them
// into code in the IDB.
while (DisasmIndex <= DisasmLocs.size()) {
- flags_t InstrFlags = getFlags(CurrDisasmAddr);
+ flags_t InstrFlags = SMP_getFlags(CurrDisasmAddr);
if (SMP_isCode(InstrFlags)) {
SMP_msg("Sync problem in FixCodeID: %x\n", CurrDisasmAddr);
}
@@ -1262,7 +1309,7 @@ void FixCodeIdentification(void) {
// Clear bytes to unexplored.
segment_t *seg = SMP_getseg(CurrDisasmAddr);
if (SEG_CODE == seg->type) {
- do_unknown_range(CurrDisasmAddr, seg->endEA - CurrDisasmAddr, DOUNK_SIMPLE);
+ SMP_del_items(CurrDisasmAddr, seg->endEA - CurrDisasmAddr, 0);
}
else {
// Might be safest to just discontinue processing
@@ -1343,8 +1390,8 @@ int FixupNewCodeChunks(void) {
SMP_msg("FixupNewCodeChunks re-converting nops region from %x to %x\n",
CurrRegion->GetStart(), CurrRegion->GetEnd());
#endif
- do_unknown_range(CurrRegion->GetStart(),
- CurrRegion->GetEnd() - CurrRegion->GetStart(), DOUNK_SIMPLE);
+ SMP_del_items(CurrRegion->GetStart(),
+ CurrRegion->GetEnd() - CurrRegion->GetStart(), 0);
CurrRegion->SetStart(STARS_BADADDR); // mark for removal
}
else {
@@ -1430,13 +1477,14 @@ int FixupNewCodeChunks(void) {
// emit on a per-instruction basis.
void FindOrphanedCode(STARS_Segment_t *CurrSeg, FILE *AnnotFile, FILE *InfoAnnotFile) {
char disasm[MAXSTR];
+ qstring *Qdisasm;
bool PrefetchInstSeenLast = false; // inst before current inst was a prefetch
bool UndefinedOpcodeSeenLast = false; // inst before current inst was an undefined opcode
for (STARS_ea_t addr = CurrSeg->get_startEA(); addr < CurrSeg->get_endEA();
addr = SMP_get_item_end(addr)) {
- flags_t InstrFlags = getFlags(addr);
- if (isTail(InstrFlags))
+ flags_t InstrFlags = SMP_getFlags(addr);
+ if (SMP_isTail(InstrFlags))
continue;
if (SMP_isHead(InstrFlags) && SMP_isCode(InstrFlags)) {
STARS_ea_t FirstFuncAddr;
@@ -1498,7 +1546,7 @@ void FindOrphanedCode(STARS_Segment_t *CurrSeg, FILE *AnnotFile, FILE *InfoAnnot
}
}
}
- else if (isUnknown(InstrFlags)) {
+ else if (SMP_isUnknown(InstrFlags)) {
#if SMP_DEBUG_FIXUP_IDB
SMP_msg("Unanalyzed byte at %x\n", addr);
#endif
@@ -1539,7 +1587,7 @@ void FindOrphanedCode(STARS_Segment_t *CurrSeg, FILE *AnnotFile, FILE *InfoAnnot
void FindLinksFromOrphanedCode(STARS_Segment_t *CurrSeg) {
char disasm[MAXSTR];
for (STARS_ea_t addr = CurrSeg->get_startEA(); addr < CurrSeg->get_endEA(); addr = SMP_get_item_end(addr)) {
- flags_t InstrFlags = getFlags(addr);
+ flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isHead(InstrFlags) && SMP_isCode(InstrFlags)) {
// Does IDA Pro think addr is inside a function?
func_t* CurrIDAFunc = ::get_func(addr);
@@ -1558,7 +1606,11 @@ void FindLinksFromOrphanedCode(STARS_Segment_t *CurrSeg) {
// See if TargetAddr is inside a function.
func_t* TargetFunc = ::get_func(TargetAddr);
if (NULL != TargetFunc) {
+#if (IDA_SDK_VERSION < 700)
STARS_ea_t FirstAddrInFunc = TargetFunc->startEA;
+#else
+ STARS_ea_t FirstAddrInFunc = TargetFunc->start_ea;
+#endif
if (FirstAddrInFunc != TargetAddr) {
SMP_msg("WARNING: Orphaned code at %llx calls %llx which is inside func starting at %llx\n",
(unsigned long long) addr, (unsigned long long) TargetAddr, (unsigned long long) FirstAddrInFunc);
@@ -1583,7 +1635,7 @@ void Debug_FindOrphanedCode(STARS_Segment_t *CurrSeg, bool FirstRun) {
for (STARS_ea_t addr = CurrSeg->get_startEA(); addr < CurrSeg->get_endEA();
addr = SMP_get_item_end(addr)) {
- flags_t InstrFlags = getFlags(addr);
+ flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isHead(InstrFlags) && SMP_isCode(InstrFlags)) {
STARS_Function_t *CurrFunc = SMP_get_func(addr);
if (NULL == CurrFunc) { // Code not in a func; orphaned
@@ -1620,7 +1672,7 @@ void SpecialDebugOutput(void) {
for (size_t index = 0; index < ProblemAddrs.size(); ++index) {
STARS_ea_t addr = ProblemAddrs[index];
- flags_t InstrFlags = getFlags(addr);
+ flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isCode(InstrFlags) && SMP_isHead(InstrFlags)) {
SMPInstr TempInst(addr);
IDAsuccess = TempInst.FillCmd(); // Emits ERROR messages if there are failures
diff --git a/src/interfaces/idapro/STARSFunction.cpp b/src/interfaces/idapro/STARSFunction.cpp
index 66c5a2910fe07e3a370f74ff3e5d725f6065d20f..30826349c008d8e5119d1be4d47ec3112a0faf29 100644
--- a/src/interfaces/idapro/STARSFunction.cpp
+++ b/src/interfaces/idapro/STARSFunction.cpp
@@ -13,7 +13,11 @@
#include "base/SMPProgram.h"
#include <pro.h>
+#if (IDA_SDK_VERSION < 700)
#include <area.hpp>
+#else
+#include <range.hpp>
+#endif
#include <funcs.hpp>
#include <struct.hpp>
#include <xref.hpp>
@@ -70,21 +74,30 @@ void STARS_IDA_Function_t::MarkSharedChunks(void) {
// func_tail_iterator_t FuncTail((func_t*)*dynamic_cast<STARS_IDA_Function_t*>(this->GetFuncInfo()));
func_tail_iterator_t FuncTail(this->the_func); // (func_t*)*(dynamic_cast<STARS_IDA_Function_t*>(this->GetFuncInfo())));
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
- const area_t &CurrChunk = FuncTail.chunk();
+ const STARS_area_t &CurrChunk = FuncTail.chunk();
++ChunkCounter;
if (1 == ChunkCounter) { // head chunk
+#if (IDA_SDK_VERSION < 700)
FuncHeadLastAddr = CurrChunk.endEA;
+#else
+ FuncHeadLastAddr = CurrChunk.end_ea;
+#endif
}
else { // a tail chunk
- if (this->IsChunkUnshared(CurrChunk.startEA, FirstEA, FuncHeadLastAddr)) {
+#if (IDA_SDK_VERSION < 700)
+ STARS_ea_t CurrChunkStartAddr = CurrChunk.startEA;
+#else
+ STARS_ea_t CurrChunkStartAddr = CurrChunk.start_ea;
+#endif
+ if (this->IsChunkUnshared(CurrChunkStartAddr, FirstEA, FuncHeadLastAddr)) {
this->UnsharedChunks = true;
// SMP_msg("INFO: Interface Found unshared tail chunk for %s at %lx\n",
-// name, (unsigned long) CurrChunk.startEA);
+// name, (unsigned long) CurrChunkStartAddr);
}
else {
this->SharedChunks = true;
// SMP_msg("INFO: Interface Found tail chunk for %s at %lx\n",
-// name, (unsigned long) CurrChunk.startEA);
+// name, (unsigned long) CurrChunkStartAddr);
}
}
}
@@ -100,17 +113,26 @@ void STARS_IDA_Function_t::MarkSharedChunks(void) {
bool ExpansionDebugFlag = (FirstEA == 0x49cf0);
if (ExpansionDebugFlag) {
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
- const area_t &CurrChunk = FuncTail.chunk();
- SMP_msg("DEBUG: Chunk from %llx to %llx\n", (unsigned long long) CurrChunk.startEA, (unsigned long long) CurrChunk.endEA);
+ const STARS_area_t &CurrChunk = FuncTail.chunk();
+#if (IDA_SDK_VERSION < 700)
+ STARS_ea_t CurrChunkStartAddr = CurrChunk.startEA;
+ STARS_ea_t CurrChunkEndAddr = CurrChunk.endEA;
+#else
+ STARS_ea_t CurrChunkStartAddr = CurrChunk.start_ea;
+ STARS_ea_t CurrChunkEndAddr = CurrChunk.end_ea;
+#endif
+ SMP_msg("DEBUG: Chunk from %llx to %llx\n", (uint64_t) CurrChunkStartAddr, (uint64_t) CurrChunkEndAddr);
}
}
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
- const area_t &CurrChunk = FuncTail.chunk();
+ const STARS_area_t &CurrChunk = FuncTail.chunk();
// Go through addresses after this chunk and find the extent of instructions
// that are orphans (not part of any function) and expand the current chunk to
// include the orphans.
STARS_ea_t UpperLimit = 0;
- for (STARS_ea_t addr = CurrChunk.endEA; addr < SegAddrLimit; addr = SMP_get_item_end(addr)) {
+ STARS_ea_t ChunkStartAddr = GetChunkStart(CurrChunk);
+ STARS_ea_t ChunkEndAddr = GetChunkEnd(CurrChunk);
+ for (STARS_ea_t addr = ChunkEndAddr; addr < SegAddrLimit; addr = SMP_get_item_end(addr)) {
flags_t InstrFlags = SMP_getFlags(addr);
if (!SMP_isHead(InstrFlags)) {
continue;
@@ -122,13 +144,17 @@ void STARS_IDA_Function_t::MarkSharedChunks(void) {
}
else {
if (ExpansionDebugFlag) {
+#if (IDA_SDK_VERSION < 700)
if (NextFunc->startEA == FirstEA) {
+#else
+ if (NextFunc->start_ea == FirstEA) {
+#endif
SMP_msg("DEBUG: Chunk expansion terminated at %llx by code from same function.\n",
- (unsigned long long) addr);
+ (uint64_t) addr);
}
else {
SMP_msg("DEBUG: Chunk expansion terminated at %llx by code from different function.\n",
- (unsigned long long) addr);
+ (uint64_t) addr);
}
}
break;
@@ -136,18 +162,22 @@ void STARS_IDA_Function_t::MarkSharedChunks(void) {
}
} // for all addrs after CurrChunk
if (UpperLimit > 0) { // need to expand earlier chunk
- pair<STARS_ea_t, STARS_ea_t> WorkListItem(CurrChunk.startEA, UpperLimit);
+ pair<STARS_ea_t, STARS_ea_t> WorkListItem(ChunkStartAddr, UpperLimit);
ExpansionWorkList.push_back(WorkListItem);
}
else if (ExpansionDebugFlag) {
- SMP_msg("DEBUG: Chunk from %llx to %llx not Expanded\n", (unsigned long long) CurrChunk.startEA,
- (unsigned long long) CurrChunk.endEA);
+ SMP_msg("DEBUG: Chunk from %llx to %llx not Expanded\n", (uint64_t) ChunkStartAddr,
+ (uint64_t) ChunkEndAddr);
}
} // end for all chunks
for (list<pair<STARS_ea_t, STARS_ea_t> >::iterator WorkIter = ExpansionWorkList.begin(); WorkIter != ExpansionWorkList.end(); ++WorkIter) {
STARS_ea_t StartAddr = (*WorkIter).first;
STARS_ea_t LimitAddr = (*WorkIter).second;
+#if (IDA_SDK_VERSION < 700)
bool success = ::func_setend(StartAddr, LimitAddr);
+#else
+ bool success = ::set_func_end(StartAddr, LimitAddr);
+#endif
if (success) {
SMP_msg("INFO: Expanded chunk limit at %llx to new limit at %llx to include orphan code.\n",
(unsigned long long) StartAddr, (unsigned long long) LimitAddr);
@@ -172,9 +202,10 @@ bool STARS_IDA_Function_t::IsMultiEntry(bool HasIndirectJumps) {
bool HasChunks = (this->HasSharedChunks() || this->UnsharedChunks);
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
- const area_t &CurrChunk = FuncTail.chunk();
+ const STARS_area_t &CurrChunk = FuncTail.chunk();
+
// Start with just the beginning addrs of chunks, as IDA will break into chunks when calls target an inst. (???)
- STARS_ea_t addr = CurrChunk.startEA;
+ STARS_ea_t addr = GetChunkStart(CurrChunk);
if (addr != FirstEA) {
// Determine whether the instruction is a call target by looking
@@ -235,17 +266,23 @@ void STARS_IDA_Function_t::UpdateXrefs()
enum cref_t FarJump = (cref_t)(fl_JF | XREF_USER);
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
+#if (IDA_SDK_VERSION < 700)
const area_t &CurrChunk = FuncTail.chunk();
+#else
+ const range_t &CurrChunk = FuncTail.chunk();
+#endif
// Find the instructions for each chunk, audit the xrefs.
- for (STARS_ea_t addr = CurrChunk.startEA; addr < CurrChunk.endEA; addr = SMP_get_item_end(addr)) {
+ STARS_ea_t ChunkStartAddr = GetChunkStart(CurrChunk);
+ STARS_ea_t ChunkEndAddr = GetChunkEnd(CurrChunk);
+ for (STARS_ea_t addr = ChunkStartAddr; addr < ChunkEndAddr; addr = SMP_get_item_end(addr)) {
flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isHead(InstrFlags) && SMP_isCode(InstrFlags)) {
// Fill cmd structure with disassembly of instr
SMPInstr TempInst(addr);
if (!TempInst.FillCmd()) {
- SMP_msg("ERROR: SMPGetCmd failed from MDAuditJumpXrefs at %lx\n",
- (unsigned long) addr);
+ SMP_msg("ERROR: SMPGetCmd failed from MDAuditJumpXrefs at %llx\n",
+ (uint64_t) addr);
}
else {
// Determine whether the instruction is a jump target by looking
@@ -332,11 +369,17 @@ void STARS_IDA_Function_t::BuildFuncIR(SMPFunction *func)
bool GoodRTL;
func->BuiltRTLs = true;
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
+#if (IDA_SDK_VERSION < 700)
const area_t &CurrChunk = FuncTail.chunk();
+#else
+ const range_t &CurrChunk = FuncTail.chunk();
+#endif
++ChunkCounter;
+ STARS_ea_t ChunkStartAddr = GetChunkStart(CurrChunk);
+ STARS_ea_t ChunkEndAddr = GetChunkEnd(CurrChunk);
#if 0
- if (CurrChunk.startEA < func->GetFirstFuncAddr()) {
- func->FirstEA = CurrChunk.startEA;
+ if (ChunkStartAddr < func->GetFirstFuncAddr()) {
+ func->FirstEA = ChunkStartAddr;
}
#endif
#if STARS_DEBUG_MEMORY_CORRUPTION
@@ -344,7 +387,7 @@ void STARS_IDA_Function_t::BuildFuncIR(SMPFunction *func)
#endif
// Build the instruction and block lists for the function.
bool PreviousInstWasCall = false;
- for (STARS_ea_t addr = CurrChunk.startEA; addr < CurrChunk.endEA; addr = SMP_get_item_end(addr)) {
+ for (STARS_ea_t addr = ChunkStartAddr; addr < ChunkEndAddr; addr = SMP_get_item_end(addr)) {
flags_t InstrFlags = SMP_getFlags(addr);
if (!SMP_isHead(InstrFlags)) {
continue;
@@ -699,10 +742,16 @@ bool STARS_IDA_Function_t::FindDistantCodeFragment(SMPFunction* func, STARS_ea_t
bool HasReturnInstruction = false;
bool AllocatesStackFrame = false;
for (bool ChunkOK = FuncTail.main(); ChunkOK; ChunkOK = FuncTail.next()) {
+#if (IDA_SDK_VERSION < 700)
const area_t &CurrChunk = FuncTail.chunk();
+#else
+ const range_t &CurrChunk = FuncTail.chunk();
+#endif
++ChunkCounter;
+ STARS_ea_t ChunkStartAddr = GetChunkStart(CurrChunk);
+ STARS_ea_t ChunkEndAddr = GetChunkEnd(CurrChunk);
// Analyze the instructions in the chunk.
- for (STARS_ea_t addr = CurrChunk.startEA; addr < CurrChunk.endEA; addr = SMP_get_item_end(addr)) {
+ for (STARS_ea_t addr = ChunkStartAddr; addr < ChunkEndAddr; addr = SMP_get_item_end(addr)) {
flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isHead(InstrFlags) && SMP_isCode(InstrFlags)) {
SMPInstr *CurrInst = new SMPInstr(addr);
@@ -765,7 +814,11 @@ void STARS_IDA_Function_t::FillInLocalVarTable(SMPFunction *CurrFunc) {
break;
}
qstring TempName;
+#if (IDA_SDK_VERSION < 700)
STARS_ssize_t NameLen = ::get_member_name2(&TempName, Member->id);
+#else
+ STARS_ssize_t NameLen = ::get_member_name(&TempName, Member->id);
+#endif
::qstrncpy(MemberName, TempName.c_str(), sizeof(MemberName));
if (MemberName[0] == '\0') {
#if SMP_DEBUG_STACK_GRANULARITY
diff --git a/src/interfaces/idapro/STARSIDAInstruction.cpp b/src/interfaces/idapro/STARSIDAInstruction.cpp
index 84b6e823f033a691a1b9d423ea91294c235b2851..0ec4dfb69a5669d36b6d191ce48cd71fffa0b1e7 100644
--- a/src/interfaces/idapro/STARSIDAInstruction.cpp
+++ b/src/interfaces/idapro/STARSIDAInstruction.cpp
@@ -58,7 +58,11 @@ void STARS_IDA_Instruction_t::InitOperand(op_t &InitOp) const {
InitOp.specflag4 = 0;
#else
(void) memset(&InitOp, 0, sizeof(op_t));
+#if (IDA_SDK_VERSION < 700)
InitOp.dtyp = global_STARS_program->GetSTARS_ISA_dtyp();
+#else
+ InitOp.dtype = global_STARS_program->GetSTARS_ISA_dtyp();
+#endif
#if IDA_SDK_VERSION < 680
InitOp.set_showed();
#else
@@ -80,8 +84,8 @@ bool STARS_IDA_Instruction_t::STARS_GetCmd(void) {
this->VoidOpndsPtr = dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
// Fill cmd structure with disassembly of instr
+#if (IDA_SDK_VERSION < 700)
InstrLen = decode_insn(m_id.GetIDWithinFile());
-
// Copy cmd fields to member STARScmd.
this->STARScmd.itype = cmd.itype;
this->STARScmd.size = cmd.size;
@@ -89,6 +93,22 @@ bool STARS_IDA_Instruction_t::STARS_GetCmd(void) {
this->STARScmd.segpref = cmd.segpref;
this->STARScmd.insnpref = cmd.insnpref;
this->STARScmd.flags = cmd.flags;
+ // Get the canonical features into member STARSfeatures.
+ this->STARSfeatures = cmd.get_canon_feature();
+#else
+ insn_t NewInsn;
+ InstrLen = decode_insn(&NewInsn, m_id.GetIDWithinFile());
+ // Copy cmd fields to member STARScmd.
+ this->STARScmd.itype = NewInsn.itype;
+ this->STARScmd.size = NewInsn.size;
+ this->STARScmd.auxpref = NewInsn.auxpref;
+ this->STARScmd.segpref = NewInsn.segpref;
+ this->STARScmd.insnpref = NewInsn.insnpref;
+ this->STARScmd.flags = NewInsn.flags;
+ // Get the canonical features into member STARSfeatures.
+ this->STARSfeatures = NewInsn.get_canon_feature();
+#endif
+
if (0 >= InstrLen) {
SMP_msg("ERROR: decode_insn failed at %ullx in file %u\n", (unsigned long long) m_id.GetIDWithinFile(), m_id.GetFileNum());
@@ -101,11 +121,12 @@ bool STARS_IDA_Instruction_t::STARS_GetCmd(void) {
return success;
}
- // Get the canonical features into member STARSfeatures.
- this->STARSfeatures = cmd.get_canon_feature();
-
for (int i = 0; i < STARS_UA_MAXOP; ++i) {
+#if (IDA_SDK_VERSION < 700)
this->STARScmd.Operands.push_back(std::make_shared<STARS_IDA_op_t>(cmd.Operands[i]));
+#else
+ this->STARScmd.Operands.push_back(std::make_shared<STARS_IDA_op_t>(NewInsn.ops[i]));
+#endif
assert(dynamic_pointer_cast<STARS_IDA_op_t>(this->STARScmd.Operands[i]) != nullptr);
dynamic_pointer_cast<STARS_IDA_op_t>(this->STARScmd.Operands[i])->SetSpecFlag4(0);
#ifdef __EA64__
@@ -123,7 +144,11 @@ bool STARS_IDA_Instruction_t::STARS_GetCmd(void) {
#endif
// See comments on STARS_VEXPR and STARS_VSIB in SMPDataFlowAnalysis.h.
// These bits do not (as of IDA Pro 6.4) conflict with cmd.rex bits.
+#if (IDA_SDK_VERSION < 700)
if ((cmd.auxpref & aux_vexpr) != 0) {
+#else
+ if ((NewInsn.auxpref & aux_vexpr) != 0) {
+#endif
dynamic_pointer_cast<STARS_IDA_op_t>(this->STARScmd.Operands[i])->SetBitInSpecFlag4(STARS_VEXPR);
}
@@ -222,7 +247,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeRegOpnd(STARS_regnum_t RegNum, boo
op_t TempOp;
this->InitOperand(TempOp);
TempOp.type = o_reg;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(RegNum, (DefaultToMachineWidth && (global_STARS_program->GetSTARS_ISA_Bitwidth() == 64)));
+#else
+ TempOp.dtype = GetRegDtyp(RegNum, (DefaultToMachineWidth && (global_STARS_program->GetSTARS_ISA_Bitwidth() == 64)));
+#endif
TempOp.reg = RegNum;
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeRegOpnd()
@@ -237,7 +266,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeFloatingPointRegOpnd(STARS_regnum_
RegNum = (STARS_regnum_t) (((int) STARS_x86_R_st0) + ((int) RegNum));
}
TempOp.reg = RegNum;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(RegNum, false);
+#else
+ TempOp.dtype = GetRegDtyp(RegNum, false);
+#endif
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeFloatingPointRegOpnd()
@@ -246,7 +279,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeMMXRegOpnd(STARS_regnum_t RegNum)
this->InitOperand(TempOp);
TempOp.type = o_mmxreg;
TempOp.reg = RegNum;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(RegNum, false);
+#else
+ TempOp.dtype = GetRegDtyp(RegNum, false);
+#endif
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeMMXRegOpnd()
@@ -255,7 +292,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeXMMRegOpnd(STARS_regnum_t RegNum)
this->InitOperand(TempOp);
TempOp.type = o_xmmreg;
TempOp.reg = RegNum;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(RegNum, false);
+#else
+ TempOp.dtype = GetRegDtyp(RegNum, false);
+#endif
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeXMMRegOpnd()
@@ -264,7 +305,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeYMMRegOpnd(STARS_regnum_t RegNum)
this->InitOperand(TempOp);
TempOp.type = o_ymmreg;
TempOp.reg = RegNum;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(RegNum, false);
+#else
+ TempOp.dtype = GetRegDtyp(RegNum, false);
+#endif
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeYMMRegOpnd()
@@ -282,7 +327,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeMemPhraseOpnd(STARS_regnum_t BaseR
this->InitOperand(TempOp);
TempOp.type = o_phrase;
TempOp.reg = BaseRegNum;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(BaseRegNum, this->Has64BitOperands());
+#else
+ TempOp.dtype = GetRegDtyp(BaseRegNum, this->Has64BitOperands());
+#endif
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeMemPhraseOpnd()
@@ -293,7 +342,11 @@ STARSOpndTypePtr STARS_IDA_Instruction_t::MakeMemDisplacementOpnd(STARS_regnum_t
TempOp.type = o_displ;
TempOp.reg = BaseRegNum;
TempOp.addr = (ea_t) offset;
+#if (IDA_SDK_VERSION < 700)
TempOp.dtyp = GetRegDtyp(BaseRegNum, this->Has64BitOperands());
+#else
+ TempOp.dtype = GetRegDtyp(BaseRegNum, this->Has64BitOperands());
+#endif
return dynamic_pointer_cast<STARS_op_t>(std::make_shared<STARS_IDA_op_t>(TempOp));
} // end of STARS_IDA_Instruction_t::MakeMemDisplacementOpnd()
@@ -310,7 +363,11 @@ bool STARS_IDA_Instruction_t::IsBranchToFarChunk(SMPInstr *CurrInst, STARS_ea_t
if ((0 != TargetAddr) && (STARS_BADADDR != TargetAddr)) {
func_t *TargetChunk = get_fchunk(TargetAddr);
// Is target address within the same chunk as the branch?
+#if (IDA_SDK_VERSION < 700)
FarBranch = (NULL == TargetChunk) || (CurrChunk->startEA != TargetChunk->startEA);
+#else
+ FarBranch = (NULL == TargetChunk) || (CurrChunk->start_ea != TargetChunk->start_ea);
+#endif
}
}
}
@@ -355,11 +412,20 @@ bool STARS_IDA_Instruction_t::AnalyzeSwitchStatement(SMPInstr *IndirJumpInst, st
assert(NULL != IndirJumpInst);
assert(INDIR_JUMP == IndirJumpInst->GetDataFlowType());
STARS_ea_t IndirJumpAddr = IndirJumpInst->GetAddr();
+#if (IDA_SDK_VERSION < 700)
switch_info_ex_t SwitchInfo;
if (get_switch_info_ex(IndirJumpAddr, &SwitchInfo, sizeof(SwitchInfo)) > 0) {
+#else
+ switch_info_t SwitchInfo;
+ if (get_switch_info(&SwitchInfo, IndirJumpAddr) > 0) {
+#endif
casevec_t CaseVector;
eavec_t TargetAddrsVector;
+#if (IDA_SDK_VERSION < 700)
success = ::calc_switch_cases(IndirJumpAddr, &SwitchInfo, &CaseVector, &TargetAddrsVector);
+#else
+ success = ::calc_switch_cases(&CaseVector, &TargetAddrsVector, IndirJumpAddr, SwitchInfo);
+#endif
if (success) {
success = (CaseVector.size() == TargetAddrsVector.size()); // sanity check
}
diff --git a/src/interfaces/idapro/STARSIDAOp.cpp b/src/interfaces/idapro/STARSIDAOp.cpp
index 42f55187f4b6ad1a610af30e29ef7f245db8078c..cd3728d136177b2e851c3335c8950b99a5460540 100644
--- a/src/interfaces/idapro/STARSIDAOp.cpp
+++ b/src/interfaces/idapro/STARSIDAOp.cpp
@@ -12,9 +12,15 @@ using namespace std;
// Constructors
STARS_IDA_op_t::STARS_IDA_op_t(op_t IDAOp) : m_Opnd(IDAOp) {
+#if (IDA_SDK_VERSION < 700)
if ((this->m_Opnd.dtyp == ((char)-1)) && (this->m_Opnd.type != o_imm)) {
this->m_Opnd.dtyp = global_STARS_program->GetSTARS_ISA_dtyp();
}
+#else
+ if ((this->m_Opnd.dtype == ((char)-1)) && (this->m_Opnd.type != o_imm)) {
+ this->m_Opnd.dtype = global_STARS_program->GetSTARS_ISA_dtyp();
+ }
+#endif
};
// Clone method (deep copy).
@@ -153,9 +159,11 @@ uint16_t STARS_IDA_op_t::GetByteWidth(void) const {
case dt_fword:
DataSize = 6;
break;
+#if (IDA_SDK_VERSION < 700)
case dt_3byte:
DataSize = 3;
break;
+#endif
case dt_byte32:
DataSize = 32;
break;
@@ -172,6 +180,7 @@ uint16_t STARS_IDA_op_t::GetByteWidth(void) const {
// Change default byte width of opnd
void STARS_IDA_op_t::SetByteWidth(uint16_t ByteWidth) {
+#if (IDA_SDK_VERSION < 700)
if (1 == ByteWidth) {
this->m_Opnd.dtyp = dt_byte;
}
@@ -184,6 +193,20 @@ void STARS_IDA_op_t::SetByteWidth(uint16_t ByteWidth) {
else if (8 == ByteWidth) {
this->m_Opnd.dtyp = dt_qword;
}
+#else
+ if (1 == ByteWidth) {
+ this->m_Opnd.dtype = dt_byte;
+ }
+ else if (2 == ByteWidth) {
+ this->m_Opnd.dtype = dt_word;
+ }
+ else if (4 == ByteWidth) {
+ this->m_Opnd.dtype = dt_dword;
+ }
+ else if (8 == ByteWidth) {
+ this->m_Opnd.dtype = dt_qword;
+ }
+#endif
else {
SMP_msg("ERROR: ByteWidth of %d specified for operandr\n", ByteWidth);
}
@@ -191,6 +214,7 @@ void STARS_IDA_op_t::SetByteWidth(uint16_t ByteWidth) {
}; // end of STARS_IDA_op_t::SetByteWidth()
void STARS_IDA_op_t::DoubleRegWidth(void) {
+#if (IDA_SDK_VERSION < 700)
if (this->m_Opnd.dtyp == dt_byte) { // current width 1, e.g. register AL
this->SetByteWidth(2); // double the byte width
// Transform byte reg into word reg; the dtyp field will determine the interpretation
@@ -203,6 +227,20 @@ void STARS_IDA_op_t::DoubleRegWidth(void) {
else if (this->m_Opnd.dtyp == dt_dword) { // current width 4, e.g. register EAX
this->SetByteWidth(8); // double the byte width; makes R_ax be interpreted as RAX, for example
}
+#else
+ if (this->m_Opnd.dtype == dt_byte) { // current width 1, e.g. register AL
+ this->SetByteWidth(2); // double the byte width
+ // Transform byte reg into word reg; the dtype field will determine the interpretation
+ // of the word reg as AX, EAX, or RAX, so only the AL case needs a register number change.
+ this->m_Opnd.reg = (uint16_t)MDCanonicalizeSubReg((STARS_regnum_t) this->m_Opnd.reg);
+ }
+ else if (this->m_Opnd.dtype == dt_word) { // current width 2, e.g. register AX
+ this->SetByteWidth(4); // double the byte width; makes R_ax be interpreted as EAX, for example
+ }
+ else if (this->m_Opnd.dtype == dt_dword) { // current width 4, e.g. register EAX
+ this->SetByteWidth(8); // double the byte width; makes R_ax be interpreted as RAX, for example
+ }
+#endif
return;
} // end of STARS_IDA_op_t::DoubleRegWidth()
diff --git a/src/interfaces/idapro/STARSIDAProgram.cpp b/src/interfaces/idapro/STARSIDAProgram.cpp
index 84254fce3e3c4dde445c98e0bc9c080a3f307dd3..dca1f9810217072860058388cb4b33db3ec7e27e 100644
--- a/src/interfaces/idapro/STARSIDAProgram.cpp
+++ b/src/interfaces/idapro/STARSIDAProgram.cpp
@@ -201,9 +201,9 @@ void STARS_IDA_Program_t::InitStaticDataTable(SMPProgram *CurrProg) {
STARS_ea_t RecentAddr = STARS_BADADDR;
for (STARS_Segment_t *seg = SMP_get_first_seg(); NULL != seg; seg = SMP_get_next_seg(RecentAddr)) {
char SegName[STARS_MAXSTR];
- RecentAddr = seg->get_startEA();
- STARS_ssize_t SegNameSize = SMP_get_segm_name(seg, SegName, sizeof(SegName) - 1);
+ STARS_ssize_t SegNameSize = SMP_get_segm_name(seg, SegName, STARS_MAXSTR - 1);
+ RecentAddr = seg->get_startEA();
// We are only interested in the data segments of type
// SEG_DATA, SEG_BSS and SEG_COMM.
#if SMP_DEBUG
@@ -229,7 +229,7 @@ void STARS_IDA_Program_t::InitStaticDataTable(SMPProgram *CurrProg) {
while (ea < seg->get_endEA()) {
ObjFlags = SMP_get_flags_novalue(ea);
// Only process head bytes of data objects, i.e. isData().
- if (isData(ObjFlags)) {
+ if (SMP_isData(ObjFlags)) {
// Compute the size of the data object.
STARS_ea_t NextEA = SMP_next_head(ea, seg->get_endEA());
if (NextEA == BADADDR) {
@@ -242,7 +242,11 @@ void STARS_IDA_Program_t::InitStaticDataTable(SMPProgram *CurrProg) {
TempHighestGlobalVarAddress = NextEA - 1;
// Get the data object name using its address.
qstring TempName;
+#if (IDA_SDK_VERSION < 700)
STARS_ssize_t TempNameLen = ::get_true_name(&TempName, ea);
+#else
+ STARS_ssize_t TempNameLen = ::get_name(&TempName, ea);
+#endif
char *TrueName = NULL;
if (TempNameLen > 0) {
TrueName = ::qstrncpy(buf, TempName.c_str(), sizeof(buf)-1);
@@ -309,7 +313,11 @@ void STARS_IDA_Program_t::InitStaticDataTable(SMPProgram *CurrProg) {
if (4 < global_STARS_program->GetSTARS_ISA_Bytewidth())
DataValue = (STARS_ea_t) ::get_qword(TempAddr);
else
+#if (IDA_SDK_VERSION < 700)
DataValue = (STARS_ea_t) ::get_long(TempAddr);
+#else
+ DataValue = (STARS_ea_t) ::get_dword(TempAddr);
+#endif
if (DataValue != 0) {
// Is this a code address?
@@ -328,7 +336,11 @@ void STARS_IDA_Program_t::InitStaticDataTable(SMPProgram *CurrProg) {
ea = NextEA;
}
else {
+#if (IDA_SDK_VERSION < 700)
ea = nextaddr(ea);
+#else
+ ea = next_addr(ea);
+#endif
}
} // end while (ea < seg->endEA)
} // end if (seg->type == SEG_DATA ...)
diff --git a/src/interfaces/idapro/STARSInterface.cpp b/src/interfaces/idapro/STARSInterface.cpp
index 55af721b351e1a7150b30357489917eab963e3a6..3f2e3f9ed9b9d30ba71f7d4bbd050f84944b7dcc 100644
--- a/src/interfaces/idapro/STARSInterface.cpp
+++ b/src/interfaces/idapro/STARSInterface.cpp
@@ -75,21 +75,27 @@ void STARS_IDA_Interface_t::AuditTailChunkOwnership(void)
std::size_t NumChunks = get_fchunk_qty();
for (std::size_t ChunkIndex = 0; ChunkIndex < NumChunks; ++ChunkIndex) {
func_t *ChunkInfo = getn_fchunk((int) ChunkIndex);
+#if (IDA_SDK_VERSION < 700)
+ STARS_ea_t ChunkStartAddr = ChunkInfo->startEA;
+#else
+ STARS_ea_t ChunkStartAddr = ChunkInfo->start_ea;
+#endif
if (is_func_tail(ChunkInfo)) {
// For each TAIL chunk, find all the parent chunks. Find the last
// parent chunk with an address less than the TAIL chunk address.
STARS_ea_t BestCandidate = 0;
func_parent_iterator_t FuncParent(ChunkInfo);
#if SMP_DEBUG_CHUNKS
- SMP_msg("Tail chunk: %x ", ChunkInfo->startEA);
+ SMP_msg("Tail chunk: %x ", ChunkStartAddr);
#endif
for (bool ok = FuncParent.first(); ok; ok = FuncParent.next()) {
STARS_ea_t parent = FuncParent.parent();
#if SMP_DEBUG_CHUNKS
SMP_msg(" parent: %x ", parent);
#endif
- if ((parent > BestCandidate) && (parent < ChunkInfo->startEA))
+ if ((parent > BestCandidate) && (parent < ChunkStartAddr)) {
BestCandidate = parent;
+ }
}
#if SMP_DEBUG_CHUNKS
SMP_msg("\n");
@@ -100,23 +106,23 @@ void STARS_IDA_Interface_t::AuditTailChunkOwnership(void)
if (0 < BestCandidate) {
if (set_tail_owner(ChunkInfo, BestCandidate)) {
func_t *FuncInfo = ::get_func(BestCandidate);
- SMP_msg("Set %lx as new owner of tail %lx\n",
- (unsigned long) BestCandidate, (unsigned long) ChunkInfo->startEA);
+ SMP_msg("Set %llx as new owner of tail %llx\n",
+ (uint64_t) BestCandidate, (uint64_t) ChunkStartAddr);
// Reanalyze the parent function (and all its
// tail chunks) now that the structure has changed.
reanalyze_function(FuncInfo);
}
else {
- SMP_msg("set_tail_owner failed for tail %lx and parent %lx\n",
- (unsigned long) ChunkInfo->startEA, (unsigned long) BestCandidate);
+ SMP_msg("set_tail_owner failed for tail %llx and parent %llx\n",
+ (uint64_t) ChunkStartAddr, (uint64_t) BestCandidate);
}
}
else {
func_t *FuncInfo = ::get_func(ChunkInfo->owner);
#if SMP_DEBUG_CHUNKS
::get_func_name(FuncInfo->startEA, FuncName, sizeof(FuncName) - 1);
- SMP_msg("No good parent candidate before tail at %x\n",
- ChunkInfo->startEA);
+ SMP_msg("No good parent candidate before tail at %llx\n",
+ (uint64_t) ChunkStartAddr);
SMP_msg("Current parent is %x: %s\n", FuncInfo->startEA, FuncName);
#endif
// Find out if a function entry chunk that comes before the
@@ -129,18 +135,19 @@ void STARS_IDA_Interface_t::AuditTailChunkOwnership(void)
SMP_bounds_t CurrFunc;
for (std::size_t FuncIndex = 0; FuncIndex < global_STARS_program->GetFuncBoundsSize(); ++FuncIndex) {
CurrFunc = global_STARS_program->GetFuncBounds(FuncIndex);
- if ((CurrFunc.startEA < ChunkInfo->startEA)
- && (CurrFunc.startEA > BestCandidate)) {
- BestCandidate = CurrFunc.startEA;
+ STARS_ea_t FuncStartAddr = CurrFunc.startEA;
+ if ((FuncStartAddr < ChunkStartAddr)
+ && (FuncStartAddr > BestCandidate)) {
+ BestCandidate = FuncStartAddr;
#if SMP_DEBUG_CHUNKS
- SMP_msg(" candidate: %x tail: %x", BestCandidate,
- ChunkInfo->startEA);
+ SMP_msg(" candidate: %llx tail: %llx", (uint64_t) BestCandidate,
+ (uint64_t) ChunkStartAddr);
#endif
}
else {
#if SMP_DEBUG_CHUNKS
- SMP_msg(" not a candidate: %x tail: %x best: %x\n",
- CurrFunc.startEA, ChunkInfo->startEA, BestCandidate);
+ SMP_msg(" not a candidate: %llx tail: %llx best: %llx\n",
+ (uint64_t) FuncStartAddr, (uint64_t) ChunkStartAddr, (uint64_t) BestCandidate);
#endif
break;
}
@@ -151,9 +158,9 @@ void STARS_IDA_Interface_t::AuditTailChunkOwnership(void)
else {
FuncInfo = ::get_func(BestCandidate);
#if SMP_DEBUG_CHUNKS
- ::get_func_name(FuncInfo->startEA, FuncName, sizeof(FuncName) - 1);
- SMP_msg("Best func entry parent candidate: %s at %x",
- FuncName, BestCandidate);
+ ::get_func_name(FuncStartAddr, FuncName, sizeof(FuncName) - 1);
+ SMP_msg("Best func entry parent candidate: %s at %llx",
+ FuncName, (uint64_t) BestCandidate);
if (FuncInfo->endEA == ChunkInfo->startEA)
SMP_msg(" Function endEA == tail chunk startEA");
SMP_msg("\n");
@@ -187,7 +194,7 @@ static STARS_ea_t FindNewFuncLimit(STARS_ea_t StartAddr)
STARS_ea_t SegLimit = seg->get_endEA();
for (STARS_ea_t addr = SMP_get_item_end(StartAddr); addr < SegLimit; addr = SMP_get_item_end(addr)) {
- flags_t InstrFlags = getFlags(addr);
+ flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isCode(InstrFlags) && SMP_isHead(InstrFlags)) {
LimitAddr = addr;
func_t *FuncInfo = get_func(addr);
@@ -268,23 +275,30 @@ void STARS_IDA_Interface_t::AuditCodeTargets(void)
for (std::size_t ChunkIndex = 0; ChunkIndex < NumChunks; ++ChunkIndex) {
func_t *ChunkInfo = getn_fchunk((int) ChunkIndex);
char FuncName[MAXSTR];
- get_func_name(ChunkInfo->startEA, FuncName, sizeof(FuncName) - 1);
+#if (IDA_SDK_VERSION < 700)
+ STARS_ea_t ChunkStartAddr = ChunkInfo->startEA;
+ STARS_ea_t ChunkEndAddr = ChunkInfo->endEA;
+#else
+ STARS_ea_t ChunkStartAddr = ChunkInfo->start_ea;
+ STARS_ea_t ChunkEndAddr = ChunkInfo->end_ea;
+#endif
+ get_func_name(ChunkStartAddr, FuncName, sizeof(FuncName) - 1);
// First, see if any calls to this function (if this chunk is
// an entry point) are not coming from within functions.
if (is_func_entry(ChunkInfo)) {
SMP_xref_t xb;
- STARS_ea_t addr = ChunkInfo->startEA;
+ STARS_ea_t addr = ChunkStartAddr;
for (bool ok = xb.SMP_first_to(addr, XREF_ALL); ok; ok = xb.SMP_next_to()) {
uchar XrefType = xb.GetType() & XREF_MASK;
if (xb.GetIscode()) {
if ((XrefType == fl_U) || (XrefType == fl_USobsolete)) {
- SMP_msg("AUDIT: Bad xref type: %lx %s\n", (unsigned long) addr, FuncName);
+ SMP_msg("AUDIT: Bad xref type: %llx %s\n", (uint64_t) addr, FuncName);
}
#if SMP_DEBUG_FIXUP_IDB
else if ((XrefType == fl_JF) || (XrefType == fl_JN)) {
- SMP_msg("Jump to func: %x %s from: %x\n",
- addr, FuncName, xb.GetFrom());
+ SMP_msg("Jump to func: %llx %s from: %llx\n",
+ (uint64_t) addr, FuncName, (uint64_t) xb.GetFrom());
}
#endif
else if (XrefType == fl_F) {
@@ -325,7 +339,7 @@ void STARS_IDA_Interface_t::AuditCodeTargets(void)
// address and ask IDA to analyze it and store it in the
// IDA database. If it is a branch target, not a call target,
// create a new TAIL chunk for the current parent functions.
- for (STARS_ea_t addr = ChunkInfo->startEA; addr < ChunkInfo->endEA;
+ for (STARS_ea_t addr = ChunkStartAddr; addr < ChunkEndAddr;
addr = SMP_get_item_end(addr)) {
flags_t InstrFlags = SMP_getFlags(addr);
if (SMP_isCode(InstrFlags) && SMP_isHead(InstrFlags)) {