1 //===-- ArchitectureMips.cpp ----------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "Plugins/Architecture/Mips/ArchitectureMips.h"
10 #include "lldb/Core/Address.h"
11 #include "lldb/Core/Disassembler.h"
12 #include "lldb/Core/Module.h"
13 #include "lldb/Core/PluginManager.h"
14 #include "lldb/Symbol/Function.h"
15 #include "lldb/Symbol/SymbolContext.h"
16 #include "lldb/Target/SectionLoadList.h"
17 #include "lldb/Target/Target.h"
18 #include "lldb/Utility/ArchSpec.h"
19 #include "lldb/Utility/Log.h"
20 
21 using namespace lldb_private;
22 using namespace lldb;
23 
24 LLDB_PLUGIN_DEFINE(ArchitectureMips)
25 
26 ConstString ArchitectureMips::GetPluginNameStatic() {
27   return ConstString("mips");
28 }
29 
30 void ArchitectureMips::Initialize() {
31   PluginManager::RegisterPlugin(GetPluginNameStatic(),
32                                 "Mips-specific algorithms",
33                                 &ArchitectureMips::Create);
34 }
35 
36 void ArchitectureMips::Terminate() {
37   PluginManager::UnregisterPlugin(&ArchitectureMips::Create);
38 }
39 
40 std::unique_ptr<Architecture> ArchitectureMips::Create(const ArchSpec &arch) {
41   return arch.IsMIPS() ?
42       std::unique_ptr<Architecture>(new ArchitectureMips(arch)) : nullptr;
43 }
44 
45 ConstString ArchitectureMips::GetPluginName() { return GetPluginNameStatic(); }
46 
47 addr_t ArchitectureMips::GetCallableLoadAddress(addr_t code_addr,
48                                                 AddressClass addr_class) const {
49   bool is_alternate_isa = false;
50 
51   switch (addr_class) {
52   case AddressClass::eData:
53   case AddressClass::eDebug:
54     return LLDB_INVALID_ADDRESS;
55   case AddressClass::eCodeAlternateISA:
56     is_alternate_isa = true;
57     break;
58   default: break;
59   }
60 
61   if ((code_addr & 2ull) || is_alternate_isa)
62     return code_addr | 1u;
63   return code_addr;
64 }
65 
66 addr_t ArchitectureMips::GetOpcodeLoadAddress(addr_t opcode_addr,
67                                               AddressClass addr_class) const {
68   switch (addr_class) {
69   case AddressClass::eData:
70   case AddressClass::eDebug:
71     return LLDB_INVALID_ADDRESS;
72   default: break;
73   }
74   return opcode_addr & ~(1ull);
75 }
76 
77 lldb::addr_t ArchitectureMips::GetBreakableLoadAddress(lldb::addr_t addr,
78                                                        Target &target) const {
79 
80   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
81 
82   Address resolved_addr;
83 
84   SectionLoadList &section_load_list = target.GetSectionLoadList();
85   if (section_load_list.IsEmpty())
86     // No sections are loaded, so we must assume we are not running yet and
87     // need to operate only on file address.
88     target.ResolveFileAddress(addr, resolved_addr);
89   else
90     target.ResolveLoadAddress(addr, resolved_addr);
91 
92   addr_t current_offset = 0;
93 
94   // Get the function boundaries to make sure we don't scan back before the
95   // beginning of the current function.
96   ModuleSP temp_addr_module_sp(resolved_addr.GetModule());
97   if (temp_addr_module_sp) {
98     SymbolContext sc;
99     SymbolContextItem resolve_scope =
100         eSymbolContextFunction | eSymbolContextSymbol;
101     temp_addr_module_sp->ResolveSymbolContextForAddress(resolved_addr,
102       resolve_scope, sc);
103     Address sym_addr;
104     if (sc.function)
105       sym_addr = sc.function->GetAddressRange().GetBaseAddress();
106     else if (sc.symbol)
107       sym_addr = sc.symbol->GetAddress();
108 
109     addr_t function_start = sym_addr.GetLoadAddress(&target);
110     if (function_start == LLDB_INVALID_ADDRESS)
111       function_start = sym_addr.GetFileAddress();
112 
113     if (function_start)
114       current_offset = addr - function_start;
115   }
116 
117   // If breakpoint address is start of function then we dont have to do
118   // anything.
119   if (current_offset == 0)
120     return addr;
121 
122   auto insn = GetInstructionAtAddress(target, current_offset, addr);
123 
124   if (nullptr == insn || !insn->HasDelaySlot())
125     return addr;
126 
127   // Adjust the breakable address
128   uint64_t breakable_addr = addr - insn->GetOpcode().GetByteSize();
129   LLDB_LOGF(log,
130             "Target::%s Breakpoint at 0x%8.8" PRIx64
131             " is adjusted to 0x%8.8" PRIx64 " due to delay slot\n",
132             __FUNCTION__, addr, breakable_addr);
133 
134   return breakable_addr;
135 }
136 
137 Instruction *ArchitectureMips::GetInstructionAtAddress(
138     Target &target, const Address &resolved_addr, addr_t symbol_offset) const {
139 
140   auto loop_count = symbol_offset / 2;
141 
142   uint32_t arch_flags = m_arch.GetFlags();
143   bool IsMips16 = arch_flags & ArchSpec::eMIPSAse_mips16;
144   bool IsMicromips = arch_flags & ArchSpec::eMIPSAse_micromips;
145 
146   if (loop_count > 3) {
147     // Scan previous 6 bytes
148     if (IsMips16 | IsMicromips)
149       loop_count = 3;
150     // For mips-only, instructions are always 4 bytes, so scan previous 4
151     // bytes only.
152     else
153       loop_count = 2;
154   }
155 
156   // Create Disassembler Instance
157   lldb::DisassemblerSP disasm_sp(
158     Disassembler::FindPlugin(m_arch, nullptr, nullptr));
159 
160   InstructionList instruction_list;
161   InstructionSP prev_insn;
162   uint32_t inst_to_choose = 0;
163 
164   Address addr = resolved_addr;
165 
166   for (uint32_t i = 1; i <= loop_count; i++) {
167     // Adjust the address to read from.
168     addr.Slide(-2);
169     uint32_t insn_size = 0;
170 
171     disasm_sp->ParseInstructions(target, addr,
172                                  {Disassembler::Limit::Bytes, i * 2}, nullptr);
173 
174     uint32_t num_insns = disasm_sp->GetInstructionList().GetSize();
175     if (num_insns) {
176       prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0);
177       insn_size = prev_insn->GetOpcode().GetByteSize();
178       if (i == 1 && insn_size == 2) {
179         // This looks like a valid 2-byte instruction (but it could be a part
180         // of upper 4 byte instruction).
181         instruction_list.Append(prev_insn);
182         inst_to_choose = 1;
183       }
184       else if (i == 2) {
185         // Here we may get one 4-byte instruction or two 2-byte instructions.
186         if (num_insns == 2) {
187           // Looks like there are two 2-byte instructions above our
188           // breakpoint target address. Now the upper 2-byte instruction is
189           // either a valid 2-byte instruction or could be a part of it's
190           // upper 4-byte instruction. In both cases we don't care because in
191           // this case lower 2-byte instruction is definitely a valid
192           // instruction and whatever i=1 iteration has found out is true.
193           inst_to_choose = 1;
194           break;
195         }
196         else if (insn_size == 4) {
197           // This instruction claims its a valid 4-byte instruction. But it
198           // could be a part of it's upper 4-byte instruction. Lets try
199           // scanning upper 2 bytes to verify this.
200           instruction_list.Append(prev_insn);
201           inst_to_choose = 2;
202         }
203       }
204       else if (i == 3) {
205         if (insn_size == 4)
206           // FIXME: We reached here that means instruction at [target - 4] has
207           // already claimed to be a 4-byte instruction, and now instruction
208           // at [target - 6] is also claiming that it's a 4-byte instruction.
209           // This can not be true. In this case we can not decide the valid
210           // previous instruction so we let lldb set the breakpoint at the
211           // address given by user.
212           inst_to_choose = 0;
213         else
214           // This is straight-forward
215           inst_to_choose = 2;
216         break;
217       }
218     }
219     else {
220       // Decode failed, bytes do not form a valid instruction. So whatever
221       // previous iteration has found out is true.
222       if (i > 1) {
223         inst_to_choose = i - 1;
224         break;
225       }
226     }
227   }
228 
229   // Check if we are able to find any valid instruction.
230   if (inst_to_choose) {
231     if (inst_to_choose > instruction_list.GetSize())
232       inst_to_choose--;
233     return instruction_list.GetInstructionAtIndex(inst_to_choose - 1).get();
234   }
235 
236   return nullptr;
237 }
238