Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /*===-- llvm-c/DisassemblerTypedefs.h -----------------------------*- C -*-===*\
  2. |*                                                                            *|
  3. |* Part of the LLVM Project, under the Apache License v2.0 with LLVM          *|
  4. |* Exceptions.                                                                *|
  5. |* See https://llvm.org/LICENSE.txt for license information.                  *|
  6. |* SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception                    *|
  7. |*                                                                            *|
  8. |*===----------------------------------------------------------------------===*/
  9.  
  10. #ifndef LLVM_C_DISASSEMBLERTYPES_H
  11. #define LLVM_C_DISASSEMBLERTYPES_H
  12.  
  13. #include "llvm-c/DataTypes.h"
  14. #ifdef __cplusplus
  15. #include <cstddef>
  16. #else
  17. #include <stddef.h>
  18. #endif
  19.  
  20. /**
  21.  * @addtogroup LLVMCDisassembler
  22.  *
  23.  * @{
  24.  */
  25.  
  26. /**
  27.  * An opaque reference to a disassembler context.
  28.  */
  29. typedef void *LLVMDisasmContextRef;
  30.  
  31. /**
  32.  * The type for the operand information call back function.  This is called to
  33.  * get the symbolic information for an operand of an instruction.  Typically
  34.  * this is from the relocation information, symbol table, etc.  That block of
  35.  * information is saved when the disassembler context is created and passed to
  36.  * the call back in the DisInfo parameter.  The instruction containing operand
  37.  * is at the PC parameter.  For some instruction sets, there can be more than
  38.  * one operand with symbolic information.  To determine the symbolic operand
  39.  * information for each operand, the bytes for the specific operand in the
  40.  * instruction are specified by the Offset parameter and its byte widith is the
  41.  * OpSize parameter.  For instructions sets with fixed widths and one symbolic
  42.  * operand per instruction, the Offset parameter will be zero and InstSize
  43.  * parameter will be the instruction width.  The information is returned in
  44.  * TagBuf and is Triple specific with its specific information defined by the
  45.  * value of TagType for that Triple.  If symbolic information is returned the
  46.  * function * returns 1, otherwise it returns 0.
  47.  */
  48. typedef int (*LLVMOpInfoCallback)(void *DisInfo, uint64_t PC, uint64_t Offset,
  49.                                   uint64_t OpSize, uint64_t InstSize,
  50.                                   int TagType, void *TagBuf);
  51.  
  52. /**
  53.  * The initial support in LLVM MC for the most general form of a relocatable
  54.  * expression is "AddSymbol - SubtractSymbol + Offset".  For some Darwin targets
  55.  * this full form is encoded in the relocation information so that AddSymbol and
  56.  * SubtractSymbol can be link edited independent of each other.  Many other
  57.  * platforms only allow a relocatable expression of the form AddSymbol + Offset
  58.  * to be encoded.
  59.  *
  60.  * The LLVMOpInfoCallback() for the TagType value of 1 uses the struct
  61.  * LLVMOpInfo1.  The value of the relocatable expression for the operand,
  62.  * including any PC adjustment, is passed in to the call back in the Value
  63.  * field.  The symbolic information about the operand is returned using all
  64.  * the fields of the structure with the Offset of the relocatable expression
  65.  * returned in the Value field.  It is possible that some symbols in the
  66.  * relocatable expression were assembly temporary symbols, for example
  67.  * "Ldata - LpicBase + constant", and only the Values of the symbols without
  68.  * symbol names are present in the relocation information.  The VariantKind
  69.  * type is one of the Target specific #defines below and is used to print
  70.  * operands like "_foo@GOT", ":lower16:_foo", etc.
  71.  */
  72. struct LLVMOpInfoSymbol1 {
  73.   uint64_t Present;  /* 1 if this symbol is present */
  74.   const char *Name;  /* symbol name if not NULL */
  75.   uint64_t Value;    /* symbol value if name is NULL */
  76. };
  77.  
  78. struct LLVMOpInfo1 {
  79.   struct LLVMOpInfoSymbol1 AddSymbol;
  80.   struct LLVMOpInfoSymbol1 SubtractSymbol;
  81.   uint64_t Value;
  82.   uint64_t VariantKind;
  83. };
  84.  
  85. /**
  86.  * The operand VariantKinds for symbolic disassembly.
  87.  */
  88. #define LLVMDisassembler_VariantKind_None 0 /* all targets */
  89.  
  90. /**
  91.  * The ARM target VariantKinds.
  92.  */
  93. #define LLVMDisassembler_VariantKind_ARM_HI16 1 /* :upper16: */
  94. #define LLVMDisassembler_VariantKind_ARM_LO16 2 /* :lower16: */
  95.  
  96. /**
  97.  * The ARM64 target VariantKinds.
  98.  */
  99. #define LLVMDisassembler_VariantKind_ARM64_PAGE       1 /* @page */
  100. #define LLVMDisassembler_VariantKind_ARM64_PAGEOFF    2 /* @pageoff */
  101. #define LLVMDisassembler_VariantKind_ARM64_GOTPAGE    3 /* @gotpage */
  102. #define LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF 4 /* @gotpageoff */
  103. #define LLVMDisassembler_VariantKind_ARM64_TLVP       5 /* @tvlppage */
  104. #define LLVMDisassembler_VariantKind_ARM64_TLVOFF     6 /* @tvlppageoff */
  105.  
  106. /**
  107.  * The type for the symbol lookup function.  This may be called by the
  108.  * disassembler for things like adding a comment for a PC plus a constant
  109.  * offset load instruction to use a symbol name instead of a load address value.
  110.  * It is passed the block information is saved when the disassembler context is
  111.  * created and the ReferenceValue to look up as a symbol.  If no symbol is found
  112.  * for the ReferenceValue NULL is returned.  The ReferenceType of the
  113.  * instruction is passed indirectly as is the PC of the instruction in
  114.  * ReferencePC.  If the output reference can be determined its type is returned
  115.  * indirectly in ReferenceType along with ReferenceName if any, or that is set
  116.  * to NULL.
  117.  */
  118. typedef const char *(*LLVMSymbolLookupCallback)(void *DisInfo,
  119.                                                 uint64_t ReferenceValue,
  120.                                                 uint64_t *ReferenceType,
  121.                                                 uint64_t ReferencePC,
  122.                                                 const char **ReferenceName);
  123. /**
  124.  * The reference types on input and output.
  125.  */
  126. /* No input reference type or no output reference type. */
  127. #define LLVMDisassembler_ReferenceType_InOut_None 0
  128.  
  129. /* The input reference is from a branch instruction. */
  130. #define LLVMDisassembler_ReferenceType_In_Branch 1
  131. /* The input reference is from a PC relative load instruction. */
  132. #define LLVMDisassembler_ReferenceType_In_PCrel_Load 2
  133.  
  134. /* The input reference is from an ARM64::ADRP instruction. */
  135. #define LLVMDisassembler_ReferenceType_In_ARM64_ADRP 0x100000001
  136. /* The input reference is from an ARM64::ADDXri instruction. */
  137. #define LLVMDisassembler_ReferenceType_In_ARM64_ADDXri 0x100000002
  138. /* The input reference is from an ARM64::LDRXui instruction. */
  139. #define LLVMDisassembler_ReferenceType_In_ARM64_LDRXui 0x100000003
  140. /* The input reference is from an ARM64::LDRXl instruction. */
  141. #define LLVMDisassembler_ReferenceType_In_ARM64_LDRXl 0x100000004
  142. /* The input reference is from an ARM64::ADR instruction. */
  143. #define LLVMDisassembler_ReferenceType_In_ARM64_ADR 0x100000005
  144.  
  145. /* The output reference is to as symbol stub. */
  146. #define LLVMDisassembler_ReferenceType_Out_SymbolStub 1
  147. /* The output reference is to a symbol address in a literal pool. */
  148. #define LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr 2
  149. /* The output reference is to a cstring address in a literal pool. */
  150. #define LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr 3
  151.  
  152. /* The output reference is to a Objective-C CoreFoundation string. */
  153. #define LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref 4
  154. /* The output reference is to a Objective-C message. */
  155. #define LLVMDisassembler_ReferenceType_Out_Objc_Message 5
  156. /* The output reference is to a Objective-C message ref. */
  157. #define LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref 6
  158. /* The output reference is to a Objective-C selector ref. */
  159. #define LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref 7
  160. /* The output reference is to a Objective-C class ref. */
  161. #define LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref 8
  162.  
  163. /* The output reference is to a C++ symbol name. */
  164. #define LLVMDisassembler_ReferenceType_DeMangled_Name 9
  165.  
  166. /**
  167.  * @}
  168.  */
  169.  
  170. #endif
  171.