Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/include/llvm-c/Disassembler.h
Line
Count
Source
1
/*===-- llvm-c/Disassembler.h - Disassembler Public C Interface ---*- C -*-===*\
2
|*                                                                            *|
3
|*                     The LLVM Compiler Infrastructure                       *|
4
|*                                                                            *|
5
|* This file is distributed under the University of Illinois Open Source      *|
6
|* License. See LICENSE.TXT for details.                                      *|
7
|*                                                                            *|
8
|*===----------------------------------------------------------------------===*|
9
|*                                                                            *|
10
|* This header provides a public interface to a disassembler library.         *|
11
|* LLVM provides an implementation of this interface.                         *|
12
|*                                                                            *|
13
\*===----------------------------------------------------------------------===*/
14
15
#ifndef LLVM_C_DISASSEMBLER_H
16
#define LLVM_C_DISASSEMBLER_H
17
18
#include "llvm/Support/DataTypes.h"
19
#ifdef __cplusplus
20
#include <cstddef>
21
#else
22
#include <stddef.h>
23
#endif
24
25
/**
26
 * @defgroup LLVMCDisassembler Disassembler
27
 * @ingroup LLVMC
28
 *
29
 * @{
30
 */
31
32
/**
33
 * An opaque reference to a disassembler context.
34
 */
35
typedef void *LLVMDisasmContextRef;
36
37
/**
38
 * The type for the operand information call back function.  This is called to
39
 * get the symbolic information for an operand of an instruction.  Typically
40
 * this is from the relocation information, symbol table, etc.  That block of
41
 * information is saved when the disassembler context is created and passed to
42
 * the call back in the DisInfo parameter.  The instruction containing operand
43
 * is at the PC parameter.  For some instruction sets, there can be more than
44
 * one operand with symbolic information.  To determine the symbolic operand
45
 * information for each operand, the bytes for the specific operand in the
46
 * instruction are specified by the Offset parameter and its byte widith is the
47
 * size parameter.  For instructions sets with fixed widths and one symbolic
48
 * operand per instruction, the Offset parameter will be zero and Size parameter
49
 * will be the instruction width.  The information is returned in TagBuf and is
50
 * Triple specific with its specific information defined by the value of
51
 * TagType for that Triple.  If symbolic information is returned the function
52
 * returns 1, otherwise it returns 0.
53
 */
54
typedef int (*LLVMOpInfoCallback)(void *DisInfo, uint64_t PC,
55
                                  uint64_t Offset, uint64_t Size,
56
                                  int TagType, void *TagBuf);
57
58
/**
59
 * The initial support in LLVM MC for the most general form of a relocatable
60
 * expression is "AddSymbol - SubtractSymbol + Offset".  For some Darwin targets
61
 * this full form is encoded in the relocation information so that AddSymbol and
62
 * SubtractSymbol can be link edited independent of each other.  Many other
63
 * platforms only allow a relocatable expression of the form AddSymbol + Offset
64
 * to be encoded.
65
 *
66
 * The LLVMOpInfoCallback() for the TagType value of 1 uses the struct
67
 * LLVMOpInfo1.  The value of the relocatable expression for the operand,
68
 * including any PC adjustment, is passed in to the call back in the Value
69
 * field.  The symbolic information about the operand is returned using all
70
 * the fields of the structure with the Offset of the relocatable expression
71
 * returned in the Value field.  It is possible that some symbols in the
72
 * relocatable expression were assembly temporary symbols, for example
73
 * "Ldata - LpicBase + constant", and only the Values of the symbols without
74
 * symbol names are present in the relocation information.  The VariantKind
75
 * type is one of the Target specific #defines below and is used to print
76
 * operands like "_foo@GOT", ":lower16:_foo", etc.
77
 */
78
struct LLVMOpInfoSymbol1 {
79
  uint64_t Present;  /* 1 if this symbol is present */
80
  const char *Name;  /* symbol name if not NULL */
81
  uint64_t Value;    /* symbol value if name is NULL */
82
};
83
84
struct LLVMOpInfo1 {
85
  struct LLVMOpInfoSymbol1 AddSymbol;
86
  struct LLVMOpInfoSymbol1 SubtractSymbol;
87
  uint64_t Value;
88
  uint64_t VariantKind;
89
};
90
91
/**
92
 * The operand VariantKinds for symbolic disassembly.
93
 */
94
154
#define LLVMDisassembler_VariantKind_None 0 /* all targets */
95
96
/**
97
 * The ARM target VariantKinds.
98
 */
99
3
#define LLVMDisassembler_VariantKind_ARM_HI16 1 /* :upper16: */
100
3
#define LLVMDisassembler_VariantKind_ARM_LO16 2 /* :lower16: */
101
102
/**
103
 * The ARM64 target VariantKinds.
104
 */
105
#define LLVMDisassembler_VariantKind_ARM64_PAGE       1 /* @page */
106
#define LLVMDisassembler_VariantKind_ARM64_PAGEOFF    2 /* @pageoff */
107
#define LLVMDisassembler_VariantKind_ARM64_GOTPAGE    3 /* @gotpage */
108
#define LLVMDisassembler_VariantKind_ARM64_GOTPAGEOFF 4 /* @gotpageoff */
109
#define LLVMDisassembler_VariantKind_ARM64_TLVP       5 /* @tvlppage */
110
#define LLVMDisassembler_VariantKind_ARM64_TLVOFF     6 /* @tvlppageoff */
111
112
/**
113
 * The type for the symbol lookup function.  This may be called by the
114
 * disassembler for things like adding a comment for a PC plus a constant
115
 * offset load instruction to use a symbol name instead of a load address value.
116
 * It is passed the block information is saved when the disassembler context is
117
 * created and the ReferenceValue to look up as a symbol.  If no symbol is found
118
 * for the ReferenceValue NULL is returned.  The ReferenceType of the
119
 * instruction is passed indirectly as is the PC of the instruction in
120
 * ReferencePC.  If the output reference can be determined its type is returned
121
 * indirectly in ReferenceType along with ReferenceName if any, or that is set
122
 * to NULL.
123
 */
124
typedef const char *(*LLVMSymbolLookupCallback)(void *DisInfo,
125
                                                uint64_t ReferenceValue,
126
                                                uint64_t *ReferenceType,
127
                                                uint64_t ReferencePC,
128
                                                const char **ReferenceName);
129
/**
130
 * The reference types on input and output.
131
 */
132
/* No input reference type or no output reference type. */
133
#define LLVMDisassembler_ReferenceType_InOut_None 0
134
135
/* The input reference is from a branch instruction. */
136
#define LLVMDisassembler_ReferenceType_In_Branch 1
137
/* The input reference is from a PC relative load instruction. */
138
#define LLVMDisassembler_ReferenceType_In_PCrel_Load 2
139
140
/* The input reference is from an ARM64::ADRP instruction. */
141
#define LLVMDisassembler_ReferenceType_In_ARM64_ADRP 0x100000001
142
/* The input reference is from an ARM64::ADDXri instruction. */
143
#define LLVMDisassembler_ReferenceType_In_ARM64_ADDXri 0x100000002
144
/* The input reference is from an ARM64::LDRXui instruction. */
145
#define LLVMDisassembler_ReferenceType_In_ARM64_LDRXui 0x100000003
146
/* The input reference is from an ARM64::LDRXl instruction. */
147
#define LLVMDisassembler_ReferenceType_In_ARM64_LDRXl 0x100000004
148
/* The input reference is from an ARM64::ADR instruction. */
149
#define LLVMDisassembler_ReferenceType_In_ARM64_ADR 0x100000005
150
151
/* The output reference is to as symbol stub. */
152
#define LLVMDisassembler_ReferenceType_Out_SymbolStub 1
153
/* The output reference is to a symbol address in a literal pool. */
154
#define LLVMDisassembler_ReferenceType_Out_LitPool_SymAddr 2
155
/* The output reference is to a cstring address in a literal pool. */
156
#define LLVMDisassembler_ReferenceType_Out_LitPool_CstrAddr 3
157
158
/* The output reference is to a Objective-C CoreFoundation string. */
159
#define LLVMDisassembler_ReferenceType_Out_Objc_CFString_Ref 4
160
/* The output reference is to a Objective-C message. */
161
#define LLVMDisassembler_ReferenceType_Out_Objc_Message 5
162
/* The output reference is to a Objective-C message ref. */
163
#define LLVMDisassembler_ReferenceType_Out_Objc_Message_Ref 6
164
/* The output reference is to a Objective-C selector ref. */
165
#define LLVMDisassembler_ReferenceType_Out_Objc_Selector_Ref 7
166
/* The output reference is to a Objective-C class ref. */
167
#define LLVMDisassembler_ReferenceType_Out_Objc_Class_Ref 8
168
169
/* The output reference is to a C++ symbol name. */
170
#define LLVMDisassembler_ReferenceType_DeMangled_Name 9
171
172
#ifdef __cplusplus
173
extern "C" {
174
#endif /* !defined(__cplusplus) */
175
176
/**
177
 * Create a disassembler for the TripleName.  Symbolic disassembly is supported
178
 * by passing a block of information in the DisInfo parameter and specifying the
179
 * TagType and callback functions as described above.  These can all be passed
180
 * as NULL.  If successful, this returns a disassembler context.  If not, it
181
 * returns NULL. This function is equivalent to calling
182
 * LLVMCreateDisasmCPUFeatures() with an empty CPU name and feature set.
183
 */
184
LLVMDisasmContextRef LLVMCreateDisasm(const char *TripleName, void *DisInfo,
185
                                      int TagType, LLVMOpInfoCallback GetOpInfo,
186
                                      LLVMSymbolLookupCallback SymbolLookUp);
187
188
/**
189
 * Create a disassembler for the TripleName and a specific CPU.  Symbolic
190
 * disassembly is supported by passing a block of information in the DisInfo
191
 * parameter and specifying the TagType and callback functions as described
192
 * above.  These can all be passed * as NULL.  If successful, this returns a
193
 * disassembler context.  If not, it returns NULL. This function is equivalent
194
 * to calling LLVMCreateDisasmCPUFeatures() with an empty feature set.
195
 */
196
LLVMDisasmContextRef LLVMCreateDisasmCPU(const char *Triple, const char *CPU,
197
                                         void *DisInfo, int TagType,
198
                                         LLVMOpInfoCallback GetOpInfo,
199
                                         LLVMSymbolLookupCallback SymbolLookUp);
200
201
/**
202
 * Create a disassembler for the TripleName, a specific CPU and specific feature
203
 * string.  Symbolic disassembly is supported by passing a block of information
204
 * in the DisInfo parameter and specifying the TagType and callback functions as
205
 * described above.  These can all be passed * as NULL.  If successful, this
206
 * returns a disassembler context.  If not, it returns NULL.
207
 */
208
LLVMDisasmContextRef
209
LLVMCreateDisasmCPUFeatures(const char *Triple, const char *CPU,
210
                            const char *Features, void *DisInfo, int TagType,
211
                            LLVMOpInfoCallback GetOpInfo,
212
                            LLVMSymbolLookupCallback SymbolLookUp);
213
214
/**
215
 * Set the disassembler's options.  Returns 1 if it can set the Options and 0
216
 * otherwise.
217
 */
218
int LLVMSetDisasmOptions(LLVMDisasmContextRef DC, uint64_t Options);
219
220
/* The option to produce marked up assembly. */
221
#define LLVMDisassembler_Option_UseMarkup 1
222
/* The option to print immediates as hex. */
223
#define LLVMDisassembler_Option_PrintImmHex 2
224
/* The option use the other assembler printer variant */
225
#define LLVMDisassembler_Option_AsmPrinterVariant 4
226
/* The option to set comment on instructions */
227
#define LLVMDisassembler_Option_SetInstrComments 8
228
  /* The option to print latency information alongside instructions */
229
#define LLVMDisassembler_Option_PrintLatency 16
230
231
/**
232
 * Dispose of a disassembler context.
233
 */
234
void LLVMDisasmDispose(LLVMDisasmContextRef DC);
235
236
/**
237
 * Disassemble a single instruction using the disassembler context specified in
238
 * the parameter DC.  The bytes of the instruction are specified in the
239
 * parameter Bytes, and contains at least BytesSize number of bytes.  The
240
 * instruction is at the address specified by the PC parameter.  If a valid
241
 * instruction can be disassembled, its string is returned indirectly in
242
 * OutString whose size is specified in the parameter OutStringSize.  This
243
 * function returns the number of bytes in the instruction or zero if there was
244
 * no valid instruction.
245
 */
246
size_t LLVMDisasmInstruction(LLVMDisasmContextRef DC, uint8_t *Bytes,
247
                             uint64_t BytesSize, uint64_t PC,
248
                             char *OutString, size_t OutStringSize);
249
250
/**
251
 * @}
252
 */
253
254
#ifdef __cplusplus
255
}
256
#endif /* !defined(__cplusplus) */
257
258
#endif /* LLVM_C_DISASSEMBLER_H */