llvm/include/llvm-c/DisassemblerTypes.h

   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