ROSE  0.11.31.0
BinaryCallingConvention.h
1 #ifndef ROSE_BinaryAnalysis_CallingConvention_H
2 #define ROSE_BinaryAnalysis_CallingConvention_H
3 
4 #include <featureTests.h>
5 #ifdef ROSE_ENABLE_BINARY_ANALYSIS
6 
7 #include <BaseSemantics2.h>
8 #include <BinaryVariables.h>
9 #include <Partitioner2/BasicTypes.h>
10 #include <Registers.h>
11 #include <RegisterParts.h>
12 
13 #include <boost/serialization/access.hpp>
14 #include <boost/serialization/set.hpp>
15 #include <boost/serialization/string.hpp>
16 #include <boost/serialization/vector.hpp>
17 #include <Sawyer/SharedObject.h>
18 #include <Sawyer/SharedPointer.h>
19 
20 namespace Rose {
21 namespace BinaryAnalysis {
22 
23 // Forwards
24 class Disassembler;
25 
36 namespace CallingConvention {
37 
41 void initDiagnostics();
42 
47 
49 // Miscellaneous small types
51 
57 };
58 
63 };
64 
70 };
71 
72 
74 // ParameterLocation
76 
86  #undef ABSOLUTE
88 public:
90  enum Type {
95  };
96 
97 private:
98  Type type_;
99  RegisterDescriptor reg_; // The argument register, or the stack base register.
100  union {
101  int64_t offset_; // Offset from stack base register for stack-based locations.
102  rose_addr_t va_; // Absolute address
103  };
104 
105 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
106 private:
107  friend class boost::serialization::access;
108 
109  template<class S>
110  void serialize(S &s, const unsigned /*version*/) {
111  s & BOOST_SERIALIZATION_NVP(type_);
112  s & BOOST_SERIALIZATION_NVP(reg_);
113  if (STACK==type_) {
114  s & BOOST_SERIALIZATION_NVP(offset_);
115  } else {
116  s & BOOST_SERIALIZATION_NVP(va_);
117  }
118  }
119 #endif
120 
121 public:
128  : type_(NO_LOCATION), offset_(0) {}
129 
132  : type_(REGISTER), reg_(reg), offset_(0) {}
133 
136  : type_(STACK), reg_(reg), offset_(offset) {}
137 
139  explicit ParameterLocation(rose_addr_t va)
140  : type_(ABSOLUTE), va_(va) {}
141 
143  Type type() const { return type_; }
144 
148  bool isValid() const {
149  return type() != NO_LOCATION;
150  }
151 
158  return reg_;
159  }
160 
166  int64_t offset() const {
167  return STACK == type_ ? offset_ : (int64_t)0;
168  }
169 
174  rose_addr_t address() const {
175  return ABSOLUTE == type_ ? va_ : (rose_addr_t)0;
176  }
177 
181  bool operator==(const ParameterLocation &other) const {
182  return type_ == other.type_ && reg_ == other.reg_ && offset_ == other.offset_; // &va_ == &offset_
183  }
184 
188  bool operator!=(const ParameterLocation &other) const {
189  return type_ != other.type_ || reg_ != other.reg_ || offset_ != other.offset_; // &va_ == &offset_
190  }
191 
193  std::string toString(const RegisterDictionary *regdict) const {
194  std::ostringstream ss;
195  print(ss, RegisterNames(regdict));
196  return ss.str();
197  }
198 
202  void print(std::ostream &out, const RegisterDictionary *regdict) const {
203  print(out, RegisterNames(regdict));
204  }
205  void print(std::ostream &out, const RegisterNames &regnames) const {
206  switch (type_) {
207  case NO_LOCATION: out <<"nowhere"; break;
208  case REGISTER: out <<regnames(reg_); break;
209  case STACK: out <<"mem[" <<regnames(reg_) <<"+" <<offset_ <<"]"; break;
210  case ABSOLUTE: out <<"mem[" <<StringUtility::addrToString(va_) <<"]"; break;
211  }
212  }
215 };
216 
217 
219 // Definition
221 
224 
229 public:
232 
233 private:
234  std::string name_; // Official short name of the convention, like "stdcall".
235  std::string comment_; // Long name, like "Windows Borland x86-32 fastcall"
236  size_t wordWidth_; // Natural width word size in bits
237  const RegisterDictionary *regDict_; // Register dictionary used when this definition was created
238  std::vector<ParameterLocation> inputParameters_; // Input (inc. in-out) parameters; additional stack-based are implied
239  std::vector<ParameterLocation> outputParameters_; // Return values and output parameters.
240  StackParameterOrder stackParameterOrder_; // Order of arguments on the stack
241  RegisterDescriptor stackPointerRegister_; // Base pointer for implied stack parameters
242  size_t nonParameterStackSize_; // Size in bytes of non-parameter stack area
243  size_t stackAlignment_; // Stack alignment in bytes (zero means unknown)
244  StackDirection stackDirection_; // Direction that stack grows from a PUSH operation
245  StackCleanup stackCleanup_; // Who cleans up stack parameters?
246  ParameterLocation thisParameter_; // Object pointer for calling conventions that are object methods
247  std::set<RegisterDescriptor> calleeSavedRegisters_; // Register that the callee must restore before returning
248  std::set<RegisterDescriptor> scratchRegisters_; // Caller-saved registers
249 
250 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
251 private:
252  friend class boost::serialization::access;
253 
254  template<class S>
255  void serialize(S &s, const unsigned /*version*/) {
256  s & BOOST_SERIALIZATION_NVP(name_);
257  s & BOOST_SERIALIZATION_NVP(comment_);
258  s & BOOST_SERIALIZATION_NVP(wordWidth_);
259  s & BOOST_SERIALIZATION_NVP(regDict_);
260  s & BOOST_SERIALIZATION_NVP(inputParameters_);
261  s & BOOST_SERIALIZATION_NVP(outputParameters_);
262  s & BOOST_SERIALIZATION_NVP(stackParameterOrder_);
263  s & BOOST_SERIALIZATION_NVP(stackPointerRegister_);
264  s & BOOST_SERIALIZATION_NVP(nonParameterStackSize_);
265  s & BOOST_SERIALIZATION_NVP(stackAlignment_);
266  s & BOOST_SERIALIZATION_NVP(stackDirection_);
267  s & BOOST_SERIALIZATION_NVP(stackCleanup_);
268  s & BOOST_SERIALIZATION_NVP(thisParameter_);
269  s & BOOST_SERIALIZATION_NVP(calleeSavedRegisters_);
270  s & BOOST_SERIALIZATION_NVP(scratchRegisters_);
271  }
272 #endif
273 
274 protected:
279  : wordWidth_(0), regDict_(NULL), stackParameterOrder_(ORDER_UNSPECIFIED), nonParameterStackSize_(0),
280  stackAlignment_(0), stackDirection_(GROWS_DOWN), stackCleanup_(CLEANUP_UNSPECIFIED) {}
281 
287  Definition(size_t wordWidth, const std::string &name, const std::string &comment, const RegisterDictionary *regDict)
288  : name_(name), comment_(comment), wordWidth_(wordWidth), regDict_(regDict), stackParameterOrder_(ORDER_UNSPECIFIED),
289  nonParameterStackSize_(0), stackAlignment_(0), stackDirection_(GROWS_DOWN), stackCleanup_(CLEANUP_UNSPECIFIED) {
290  ASSERT_require2(0 == (wordWidth & 7) && wordWidth > 0, "word size must be a positive multiple of eight");
291  }
292 
293 public:
295  static Ptr instance(size_t wordWidth, const std::string &name, const std::string &comment, const RegisterDictionary *regs) {
296  return Ptr(new Definition(wordWidth, name, comment, regs));
297  }
298 
299 public:
303  static Ptr x86_32bit_cdecl();
304  static Ptr x86_64bit_cdecl();
305  static Ptr x86_32bit_stdcall();
306  static Ptr x86_64bit_stdcall();
307  static Ptr x86_32bit_fastcall();
308  static Ptr x86_64bit_sysv();
309  static Ptr ppc_32bit_ibm();
315  static Ptr x86_cdecl(const RegisterDictionary*);
316  static Ptr x86_stdcall(const RegisterDictionary*);
317  static Ptr x86_fastcall(const RegisterDictionary*);
318  static Ptr ppc_ibm(const RegisterDictionary*);
326  const RegisterDictionary* registerDictionary() const { return regDict_; }
327  void registerDictionary(const RegisterDictionary *d) { regDict_ = d; }
338  const std::string& name() const { return name_; }
339  void name(const std::string &s) { name_ = s; }
349  const std::string& comment() const { return comment_; }
350  void comment(const std::string &s) { comment_ = s; }
362  size_t wordWidth() const { return wordWidth_; }
363  void wordWidth(size_t nBits) {
364  ASSERT_require2(nBits > 0 && 0 == (nBits & 7), "word size must be a positive multiple of eight");
365  wordWidth_ = nBits;
366  }
375  thisParameter_ = ParameterLocation();
376  }
377 
382  const std::vector<ParameterLocation>& inputParameters() const { return inputParameters_; }
383 
386 
391  void clearInputParameters() { inputParameters_.clear(); }
392 
402  }
403  void appendInputParameter(RegisterDescriptor reg, int64_t offset) {
405  }
406  void appendInputParameter(rose_addr_t va) {
408  }
415  const std::vector<ParameterLocation>& outputParameters() const { return outputParameters_; }
416 
419 
424  void clearOutputParameters() { outputParameters_.clear(); }
425 
437  }
438  void appendOutputParameter(RegisterDescriptor reg, int64_t offset) {
440  }
441  void appendOutputParameter(rose_addr_t va) {
443  }
456  StackParameterOrder stackParameterOrder() const { return stackParameterOrder_; }
457  void stackParameterOrder(StackParameterOrder x) { stackParameterOrder_ = x; }
467  const RegisterDescriptor stackPointerRegister() const { return stackPointerRegister_; }
468  void stackPointerRegister(RegisterDescriptor r) { stackPointerRegister_ = r; }
478  size_t nonParameterStackSize() const {
479  return nonParameterStackSize_;
480  }
481  void nonParameterStackSize(size_t nBytes) {
482  nonParameterStackSize_ = nBytes;
483  }
493  StackDirection stackDirection() const { return stackDirection_; }
494  void stackDirection(StackDirection x) { stackDirection_ = x; }
504  StackCleanup stackCleanup() const { return stackCleanup_; }
505  void stackCleanup(StackCleanup x) { stackCleanup_ = x; }
514  size_t stackAlignment() const { return stackAlignment_; }
515  void stackAlignment(size_t nBytes) { stackAlignment_ = nBytes; }
532  const ParameterLocation& thisParameter() const { return thisParameter_; }
533  void thisParameter(const ParameterLocation &x) { thisParameter_ = x; }
536  }
537  void thisParameter(RegisterDescriptor reg, int64_t offset) {
538  thisParameter(ParameterLocation(reg, offset));
539  }
540  void thisParameter(rose_addr_t va) {
542  }
556  const std::set<RegisterDescriptor>& calleeSavedRegisters() const { return calleeSavedRegisters_; }
557  std::set<RegisterDescriptor>& calleeSavedRegisters() { return calleeSavedRegisters_; }
562 
570  const std::set<RegisterDescriptor>& scratchRegisters() const { return scratchRegisters_; }
571  std::set<RegisterDescriptor>& scratchRegisters() { return scratchRegisters_; }
576 
587 
592  void print(std::ostream&, const RegisterDictionary *regDict = NULL) const;
593 };
594 
595 
597 // Dictionary
599 
601 typedef std::vector<Definition::Ptr> Dictionary;
602 
604 const Dictionary& dictionaryAmd64();
605 
607 const Dictionary& dictionaryAarch32();
608 
610 const Dictionary& dictionaryAarch64();
611 
613 const Dictionary& dictionaryM68k();
614 
616 const Dictionary& dictionaryMips();
617 
619 const Dictionary& dictionaryPowerpc32();
620 
622 const Dictionary& dictionaryPowerpc64();
623 
625 const Dictionary& dictionaryX86();
626 
627 
629 // Analysis
631 
635 class Analysis {
636 private:
638  const RegisterDictionary *regDict_; // Names for the register parts
639  Definition::Ptr defaultCc_; // Default calling convention for called functions
640 
641  bool hasResults_; // Are the following data members initialized?
642  bool didConverge_; // Are the following data members valid (else only approximations)?
643  RegisterParts restoredRegisters_; // Registers accessed but restored
644  RegisterParts inputRegisters_; // Registers that serve as possible input parameters
645  RegisterParts outputRegisters_; // Registers that hold possible return values
646  Variables::StackVariables inputStackParameters_; // Stack variables serving as function inputs
647  Variables::StackVariables outputStackParameters_; // Stack variables serving as possible return values
648  Sawyer::Optional<int64_t> stackDelta_; // Change in stack across entire function
649  // Don't forget to update clearResults() and serialize() if you add more.
650 
651 #ifdef ROSE_HAVE_BOOST_SERIALIZATION_LIB
652 private:
653  friend class boost::serialization::access;
654 
655  template<class S>
656  void serialize(S &s, const unsigned /*version*/) {
657  s & BOOST_SERIALIZATION_NVP(cpu_);
658  s & BOOST_SERIALIZATION_NVP(regDict_);
659  s & BOOST_SERIALIZATION_NVP(defaultCc_);
660  s & BOOST_SERIALIZATION_NVP(hasResults_);
661  s & BOOST_SERIALIZATION_NVP(didConverge_);
662  s & BOOST_SERIALIZATION_NVP(restoredRegisters_);
663  s & BOOST_SERIALIZATION_NVP(inputRegisters_);
664  s & BOOST_SERIALIZATION_NVP(outputRegisters_);
665  s & BOOST_SERIALIZATION_NVP(inputStackParameters_);
666  s & BOOST_SERIALIZATION_NVP(outputStackParameters_);
667  s & BOOST_SERIALIZATION_NVP(stackDelta_);
668  }
669 #endif
670 
671 public:
678  : regDict_(NULL), hasResults_(false), didConverge_(false) {}
679 
683  explicit Analysis(Disassembler *d)
684  : regDict_(NULL), hasResults_(false), didConverge_(false) {
685  init(d);
686  }
687 
695  : cpu_(cpu), regDict_(NULL), hasResults_(false), didConverge_(false) {}
696 
704  Definition::Ptr defaultCallingConvention() const { return defaultCc_; }
705  void defaultCallingConvention(const Definition::Ptr &x) { defaultCc_ = x; }
714 
719  bool hasResults() const { return hasResults_; }
720 
725  bool didConverge() const { return didConverge_; }
726 
731  void clearResults();
732 
737  void clearNonResults();
738 
746  const RegisterDictionary* registerDictionary() const { return regDict_; }
747  void registerDictionary(const RegisterDictionary *d) { regDict_ = d; }
754  const RegisterParts& calleeSavedRegisters() const { return restoredRegisters_; }
755 
760  const RegisterParts& inputRegisters() const { return inputRegisters_; }
761 
766  const RegisterParts& outputRegisters() const { return outputRegisters_; }
767 
771  const Variables::StackVariables& inputStackParameters() const { return inputStackParameters_; }
772 
776  const Variables::StackVariables& outputStackParameters() const { return outputStackParameters_; }
777 
782  Sawyer::Optional<int64_t> stackDelta() const { return stackDelta_; }
783 
787  bool match(const Definition::Ptr&) const;
788 
794  Dictionary match(const Dictionary&) const;
795 
800  void print(std::ostream&, bool multiLine=false) const;
801 
802 private:
803  // Finish constructing
804  void init(Disassembler*);
805 
806  // Recompute the restoredRegisters_ data member.
807  void updateRestoredRegisters(const InstructionSemantics2::BaseSemantics::StatePtr &initialState,
809 
810  // Recompute the inputRegisters_ data member after updateRestoredRegisters is computed.
811  void updateInputRegisters(const InstructionSemantics2::BaseSemantics::StatePtr &state);
812 
813  // Recompute the outputRegisters_ data member after updateRestoredRegisters is computed.
814  void updateOutputRegisters(const InstructionSemantics2::BaseSemantics::StatePtr &state);
815 
816  // Recompute the input and output stack variables
817  void updateStackParameters(const Partitioner2::FunctionPtr &function,
820 
821  // Recomputes the stack delta
822  void updateStackDelta(const InstructionSemantics2::BaseSemantics::StatePtr &initialState,
824 };
825 
827 // Free functions
829 
830 std::ostream& operator<<(std::ostream&, const Definition&);
831 std::ostream& operator<<(std::ostream&, const Analysis&);
832 
833 } // namespace
834 } // namespace
835 } // namespace
836 
837 #endif
838 #endif
void print(std::ostream &out, const RegisterNames &regnames) const
Print location.
void thisParameter(rose_addr_t va)
Property: Object pointer parameter.
size_t wordWidth() const
Property: Word size in bits.
const Dictionary & dictionaryX86()
Common calling conventions for 32-bit x86.
const std::vector< ParameterLocation > & outputParameters() const
Property: List of output parameters.
void registerDictionary(const RegisterDictionary *d)
Property: Register dictionary.
StackParameterOrder stackParameterOrder() const
Property: Stack parameter order.
size_t stackAlignment() const
Property: Stack alignment.
const Dictionary & dictionaryM68k()
Common calling conventions for m68k.
void print(std::ostream &out, const RegisterDictionary *regdict) const
Print location.
StackDirection stackDirection() const
Property: Direction that stack grows for a push operation.
The called function pops all stack parameters.
std::string toString(const RegisterDictionary *regdict) const
String representation.
const Variables::StackVariables & outputStackParameters() const
Output stack parameters.
void wordWidth(size_t nBits)
Property: Word size in bits.
void stackDirection(StackDirection x)
Property: Direction that stack grows for a push operation.
void appendInputParameter(const ParameterLocation &)
Append input parameter.
RegisterDescriptor reg() const
Register part of location.
static Ptr x86_32bit_cdecl()
Returns a predefined, cached calling convention.
const RegisterDictionary * registerDictionary() const
Property: Register dictionary.
void appendOutputParameter(rose_addr_t va)
Append output parameter.
const Dictionary & dictionaryAarch64()
Common calling conventions for ARM AArch64.
Sawyer::SharedPointer< class Definition > DefinitionPtr
Reference counting pointer to calling convention definition.
void registerDictionary(const RegisterDictionary *d)
Property: Register dictionary.
Collection of streams.
Definition: Message.h:1606
static Ptr x86_32bit_stdcall()
Allocating constructor.
static Ptr ppc_32bit_ibm()
Allocating constructor.
void thisParameter(RegisterDescriptor reg, int64_t offset)
Property: Object pointer parameter.
ParameterLocation(RegisterDescriptor reg)
Constructs a parameter in a register location.
ParameterLocation(RegisterDescriptor reg, int64_t offset)
Constructs a parameter at a register-relative memory address.
void thisParameter(const ParameterLocation &x)
Property: Object pointer parameter.
const Dictionary & dictionaryPowerpc64()
Common calling conventions for PowerPC-64.
boost::shared_ptr< State > StatePtr
Shared-ownership pointer to a semantic state.
StackDirection
The direction in which the stack grows.
Analysis(Disassembler *d)
Construct an analyzer using a specified disassembler.
bool operator!=(const ParameterLocation &other) const
Inequality.
const Dictionary & dictionaryAmd64()
Common calling conventions for amd64 (x86-64).
void appendInputParameter(rose_addr_t va)
Append input parameter.
Definition::Ptr defaultCallingConvention() const
Property: Default calling convention.
void thisParameter(RegisterDescriptor reg)
Property: Object pointer parameter.
void stackCleanup(StackCleanup x)
Property: Who pops stack parameters.
rose_addr_t address() const
Fixed address location.
Main namespace for the ROSE library.
RegisterParts inputRegisterParts() const
Compute the set of input registers.
RegisterParts scratchRegisterParts() const
Computes the set of scratch registers.
Holds a set of registers without regard for register boundaries.
Definition: RegisterParts.h:28
StackCleanup stackCleanup() const
Property: Who pops stack parameters.
static Ptr x86_fastcall(const RegisterDictionary *)
Constructs a new pre-defined calling convention based on a register dictionary.
Sawyer::Optional< int64_t > stackDelta() const
Concrete stack delta.
bool hasResults() const
Whether a function has been analyzed.
Sawyer::SharedPointer< Definition > Ptr
Reference counting pointer to calling convention definition.
const ParameterLocation & thisParameter() const
Property: Object pointer parameter.
boost::shared_ptr< Dispatcher > DispatcherPtr
Shared-ownership pointer to a semantics instruction dispatcher.
void comment(const std::string &s)
Property: Full name of calling convention.
const RegisterParts & calleeSavedRegisters() const
Callee-saved registers.
void stackParameterOrder(StackParameterOrder x)
Property: Stack parameter order.
const RegisterParts & inputRegisters() const
Input registers.
void print(std::ostream &, bool multiLine=false) const
Print information about the analysis results.
const Dictionary & dictionaryPowerpc32()
Common calling conventions for PowerPC-32.
bool operator==(const ParameterLocation &other) const
Equality.
std::vector< Definition::Ptr > Dictionary
A ordered collection of calling convention definitions.
const Dictionary & dictionaryMips()
Common calling conventions for MIPS.
void appendOutputParameter(const ParameterLocation &)
Append output parameter.
static Ptr x86_cdecl(const RegisterDictionary *)
Constructs a new pre-defined calling convention based on a register dictionary.
static Ptr instance(size_t wordWidth, const std::string &name, const std::string &comment, const RegisterDictionary *regs)
Allocating constructor.
const Variables::StackVariables & inputStackParameters() const
Input stack parameters.
const std::set< RegisterDescriptor > & calleeSavedRegisters() const
Property: Callee-saved registers.
Describes (part of) a physical CPU register.
void appendInputParameter(RegisterDescriptor reg)
Append input parameter.
ROSE_UTIL_API std::string addrToString(uint64_t value, size_t nbits=0)
Convert a virtual address to a string.
void nonParameterStackSize(size_t nBytes)
Property: Size of non-parameter stack area.
StackParameterOrder
The order that arguments are pushed onto the stack.
bool isValid() const
Predicate to determine if location is valid.
bool didConverge() const
Whether the analysis results are valid.
std::set< RegisterDescriptor > & scratchRegisters()
Property: Scratch registers.
Sawyer::Message::Facility mlog
Facility for diagnostic output.
Prints a register name even when no dictionary is available or when the dictionary doesn't contain an...
Definition: Registers.h:381
void appendInputParameter(RegisterDescriptor reg, int64_t offset)
Append input parameter.
void analyzeFunction(const Partitioner2::Partitioner &, const Sawyer::SharedPointer< Partitioner2::Function > &)
Analyze one function.
void print(std::ostream &, const RegisterDictionary *regDict=NULL) const
Print detailed information about this calling convention.
size_t nonParameterStackSize() const
Property: Size of non-parameter stack area.
Analysis(const InstructionSemantics2::BaseSemantics::DispatcherPtr &cpu)
Construct an analysis using a specified dispatcher.
static Ptr x86_stdcall(const RegisterDictionary *)
Constructs a new pre-defined calling convention based on a register dictionary.
RegisterParts outputRegisterParts() const
Computes the set of output registers.
bool match(const Definition::Ptr &) const
Determine whether a definition matches.
const RegisterDescriptor stackPointerRegister() const
Property: Register for implied stack parameters.
RegisterParts getUsedRegisterParts() const
Returns all registers mentioned in this definition.
const RegisterParts & outputRegisters() const
Output registers.
static Ptr x86_64bit_cdecl()
Allocating constructor.
void name(const std::string &s)
Property: Short name of calling convention.
Stack parameters pushed left to right (Pascal order).
ParameterLocation(rose_addr_t va)
Constructs a parameter at a fixed memory address.
StackCleanup
Who is responsible for popping stack parameters.
const RegisterDictionary * registerDictionary() const
Property: Register dictionary.
Base class for reference counted objects.
Definition: SharedObject.h:64
void clearNonResults()
Clears everything but results.
void initDiagnostics()
Initialize diagnostics.
void clearResults()
Clear analysis results.
const std::vector< ParameterLocation > & inputParameters() const
Property: Enumerated input parameters.
Stack parameters pushed right to left (C order).
void clearInputParameters()
Erase enumerated input parameters.
void appendOutputParameter(RegisterDescriptor reg)
Append output parameter.
const std::string & name() const
Property: Short name of calling convention.
void stackAlignment(size_t nBytes)
Property: Stack alignment.
Stack parameter cleanup is unknown or unspecified.
const Dictionary & dictionaryAarch32()
Common calling conventions for ARM AArch32.
Definition(size_t wordWidth, const std::string &name, const std::string &comment, const RegisterDictionary *regDict)
Allocating constructor.
Defines registers available for a particular architecture.
Definition: Registers.h:38
Stack parameter order is unknown or unspecified.
RegisterParts calleeSavedRegisterParts() const
Compute the set of callee-saved registers.
void defaultCallingConvention(const Definition::Ptr &x)
Property: Default calling convention.
const std::string & comment() const
Property: Full name of calling convention.
const std::set< RegisterDescriptor > & scratchRegisters() const
Property: Scratch registers.
static Ptr x86_32bit_fastcall()
Allocating constructor.
Partitions instructions into basic blocks and functions.
Definition: Partitioner.h:323
static Ptr x86_64bit_sysv()
Allocating constructor.
Virtual base class for instruction disassemblers.
Definition: Disassembler.h:50
static Ptr x86_64bit_stdcall()
Allocating constructor.
std::set< RegisterDescriptor > & calleeSavedRegisters()
Property: Callee-saved registers.
static Ptr ppc_ibm(const RegisterDictionary *)
Constructs a new pre-defined calling convention based on a register dictionary.
void stackPointerRegister(RegisterDescriptor r)
Property: Register for implied stack parameters.
void appendOutputParameter(RegisterDescriptor reg, int64_t offset)
Append output parameter.