1// Copyright 2015, ARM Limited
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are met:
6//
7//   * Redistributions of source code must retain the above copyright notice,
8//     this list of conditions and the following disclaimer.
9//   * Redistributions in binary form must reproduce the above copyright notice,
10//     this list of conditions and the following disclaimer in the documentation
11//     and/or other materials provided with the distribution.
12//   * Neither the name of ARM Limited nor the names of its contributors may be
13//     used to endorse or promote products derived from this software without
14//     specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS CONTRIBUTORS "AS IS" AND
17// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
20// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
22// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
23// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26
27#ifndef VIXL_A64_DISASM_A64_H
28#define VIXL_A64_DISASM_A64_H
29
30#include "vixl/globals.h"
31#include "vixl/utils.h"
32#include "vixl/a64/instructions-a64.h"
33#include "vixl/a64/decoder-a64.h"
34#include "vixl/a64/assembler-a64.h"
35
36namespace vixl {
37
38class Disassembler: public DecoderVisitor {
39 public:
40  Disassembler();
41  Disassembler(char* text_buffer, int buffer_size);
42  virtual ~Disassembler();
43  char* GetOutput();
44
45  // Declare all Visitor functions.
46  #define DECLARE(A) virtual void Visit##A(const Instruction* instr);
47  VISITOR_LIST(DECLARE)
48  #undef DECLARE
49
50 protected:
51  virtual void ProcessOutput(const Instruction* instr);
52
53  // Default output functions.  The functions below implement a default way of
54  // printing elements in the disassembly. A sub-class can override these to
55  // customize the disassembly output.
56
57  // Prints the name of a register.
58  // TODO: This currently doesn't allow renaming of V registers.
59  virtual void AppendRegisterNameToOutput(const Instruction* instr,
60                                          const CPURegister& reg);
61
62  // Prints a PC-relative offset. This is used for example when disassembling
63  // branches to immediate offsets.
64  virtual void AppendPCRelativeOffsetToOutput(const Instruction* instr,
65                                              int64_t offset);
66
67  // Prints an address, in the general case. It can be code or data. This is
68  // used for example to print the target address of an ADR instruction.
69  virtual void AppendCodeRelativeAddressToOutput(const Instruction* instr,
70                                                 const void* addr);
71
72  // Prints the address of some code.
73  // This is used for example to print the target address of a branch to an
74  // immediate offset.
75  // A sub-class can for example override this method to lookup the address and
76  // print an appropriate name.
77  virtual void AppendCodeRelativeCodeAddressToOutput(const Instruction* instr,
78                                                     const void* addr);
79
80  // Prints the address of some data.
81  // This is used for example to print the source address of a load literal
82  // instruction.
83  virtual void AppendCodeRelativeDataAddressToOutput(const Instruction* instr,
84                                                     const void* addr);
85
86  // Same as the above, but for addresses that are not relative to the code
87  // buffer. They are currently not used by VIXL.
88  virtual void AppendAddressToOutput(const Instruction* instr,
89                                     const void* addr);
90  virtual void AppendCodeAddressToOutput(const Instruction* instr,
91                                         const void* addr);
92  virtual void AppendDataAddressToOutput(const Instruction* instr,
93                                         const void* addr);
94
95 public:
96  // Get/Set the offset that should be added to code addresses when printing
97  // code-relative addresses in the AppendCodeRelative<Type>AddressToOutput()
98  // helpers.
99  // Below is an example of how a branch immediate instruction in memory at
100  // address 0xb010200 would disassemble with different offsets.
101  // Base address | Disassembly
102  //          0x0 | 0xb010200:  b #+0xcc  (addr 0xb0102cc)
103  //      0x10000 | 0xb000200:  b #+0xcc  (addr 0xb0002cc)
104  //    0xb010200 |       0x0:  b #+0xcc  (addr 0xcc)
105  void MapCodeAddress(int64_t base_address, const Instruction* instr_address);
106  int64_t CodeRelativeAddress(const void* instr);
107
108 private:
109  void Format(
110      const Instruction* instr, const char* mnemonic, const char* format);
111  void Substitute(const Instruction* instr, const char* string);
112  int SubstituteField(const Instruction* instr, const char* format);
113  int SubstituteRegisterField(const Instruction* instr, const char* format);
114  int SubstituteImmediateField(const Instruction* instr, const char* format);
115  int SubstituteLiteralField(const Instruction* instr, const char* format);
116  int SubstituteBitfieldImmediateField(
117      const Instruction* instr, const char* format);
118  int SubstituteShiftField(const Instruction* instr, const char* format);
119  int SubstituteExtendField(const Instruction* instr, const char* format);
120  int SubstituteConditionField(const Instruction* instr, const char* format);
121  int SubstitutePCRelAddressField(const Instruction* instr, const char* format);
122  int SubstituteBranchTargetField(const Instruction* instr, const char* format);
123  int SubstituteLSRegOffsetField(const Instruction* instr, const char* format);
124  int SubstitutePrefetchField(const Instruction* instr, const char* format);
125  int SubstituteBarrierField(const Instruction* instr, const char* format);
126  int SubstituteSysOpField(const Instruction* instr, const char* format);
127  int SubstituteCrField(const Instruction* instr, const char* format);
128  bool RdIsZROrSP(const Instruction* instr) const {
129    return (instr->Rd() == kZeroRegCode);
130  }
131
132  bool RnIsZROrSP(const Instruction* instr) const {
133    return (instr->Rn() == kZeroRegCode);
134  }
135
136  bool RmIsZROrSP(const Instruction* instr) const {
137    return (instr->Rm() == kZeroRegCode);
138  }
139
140  bool RaIsZROrSP(const Instruction* instr) const {
141    return (instr->Ra() == kZeroRegCode);
142  }
143
144  bool IsMovzMovnImm(unsigned reg_size, uint64_t value);
145
146  int64_t code_address_offset() const { return code_address_offset_; }
147
148 protected:
149  void ResetOutput();
150  void AppendToOutput(const char* string, ...) PRINTF_CHECK(2, 3);
151
152  void set_code_address_offset(int64_t code_address_offset) {
153    code_address_offset_ = code_address_offset;
154  }
155
156  char* buffer_;
157  uint32_t buffer_pos_;
158  uint32_t buffer_size_;
159  bool own_buffer_;
160
161  int64_t code_address_offset_;
162};
163
164
165class PrintDisassembler: public Disassembler {
166 public:
167  explicit PrintDisassembler(FILE* stream) : stream_(stream) { }
168
169 protected:
170  virtual void ProcessOutput(const Instruction* instr);
171
172 private:
173  FILE *stream_;
174};
175}  // namespace vixl
176
177#endif  // VIXL_A64_DISASM_A64_H
178