xref: /llvm-project/lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp (revision 593be023615a456ca6ee0ef9bedc21301d73b73c) 
1 //===-- ABISysV_mips.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 "ABISysV_mips.h"
10 
11 #include "llvm/ADT/STLExtras.h"
12 #include "llvm/TargetParser/Triple.h"
13 
14 #include "lldb/Core/Module.h"
15 #include "lldb/Core/PluginManager.h"
16 #include "lldb/Core/Value.h"
17 #include "lldb/Symbol/UnwindPlan.h"
18 #include "lldb/Target/Process.h"
19 #include "lldb/Target/RegisterContext.h"
20 #include "lldb/Target/StackFrame.h"
21 #include "lldb/Target/Target.h"
22 #include "lldb/Target/Thread.h"
23 #include "lldb/Utility/ConstString.h"
24 #include "lldb/Utility/DataExtractor.h"
25 #include "lldb/Utility/LLDBLog.h"
26 #include "lldb/Utility/Log.h"
27 #include "lldb/Utility/RegisterValue.h"
28 #include "lldb/Utility/Status.h"
29 #include "lldb/ValueObject/ValueObjectConstResult.h"
30 #include "lldb/ValueObject/ValueObjectMemory.h"
31 #include "lldb/ValueObject/ValueObjectRegister.h"
32 #include <optional>
33 
34 using namespace lldb;
35 using namespace lldb_private;
36 
37 LLDB_PLUGIN_DEFINE(ABISysV_mips)
38 
39 enum dwarf_regnums {
40   dwarf_r0 = 0,
41   dwarf_r1,
42   dwarf_r2,
43   dwarf_r3,
44   dwarf_r4,
45   dwarf_r5,
46   dwarf_r6,
47   dwarf_r7,
48   dwarf_r8,
49   dwarf_r9,
50   dwarf_r10,
51   dwarf_r11,
52   dwarf_r12,
53   dwarf_r13,
54   dwarf_r14,
55   dwarf_r15,
56   dwarf_r16,
57   dwarf_r17,
58   dwarf_r18,
59   dwarf_r19,
60   dwarf_r20,
61   dwarf_r21,
62   dwarf_r22,
63   dwarf_r23,
64   dwarf_r24,
65   dwarf_r25,
66   dwarf_r26,
67   dwarf_r27,
68   dwarf_r28,
69   dwarf_r29,
70   dwarf_r30,
71   dwarf_r31,
72   dwarf_sr,
73   dwarf_lo,
74   dwarf_hi,
75   dwarf_bad,
76   dwarf_cause,
77   dwarf_pc
78 };
79 
80 static const RegisterInfo g_register_infos[] = {
81     {"r0",
82      "zero",
83      4,
84      0,
85      eEncodingUint,
86      eFormatHex,
87      {dwarf_r0, dwarf_r0, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
88       LLDB_INVALID_REGNUM},
89      nullptr,
90      nullptr,
91      nullptr,
92     },
93     {"r1",
94      "AT",
95      4,
96      0,
97      eEncodingUint,
98      eFormatHex,
99      {dwarf_r1, dwarf_r1, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
100       LLDB_INVALID_REGNUM},
101      nullptr,
102      nullptr,
103      nullptr,
104     },
105     {"r2",
106      "v0",
107      4,
108      0,
109      eEncodingUint,
110      eFormatHex,
111      {dwarf_r2, dwarf_r2, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
112       LLDB_INVALID_REGNUM},
113      nullptr,
114      nullptr,
115      nullptr,
116     },
117     {"r3",
118      "v1",
119      4,
120      0,
121      eEncodingUint,
122      eFormatHex,
123      {dwarf_r3, dwarf_r3, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
124       LLDB_INVALID_REGNUM},
125      nullptr,
126      nullptr,
127      nullptr,
128     },
129     {"r4",
130      nullptr,
131      4,
132      0,
133      eEncodingUint,
134      eFormatHex,
135      {dwarf_r4, dwarf_r4, LLDB_REGNUM_GENERIC_ARG1, LLDB_INVALID_REGNUM,
136       LLDB_INVALID_REGNUM},
137      nullptr,
138      nullptr,
139      nullptr,
140     },
141     {"r5",
142      nullptr,
143      4,
144      0,
145      eEncodingUint,
146      eFormatHex,
147      {dwarf_r5, dwarf_r5, LLDB_REGNUM_GENERIC_ARG2, LLDB_INVALID_REGNUM,
148       LLDB_INVALID_REGNUM},
149      nullptr,
150      nullptr,
151      nullptr,
152     },
153     {"r6",
154      nullptr,
155      4,
156      0,
157      eEncodingUint,
158      eFormatHex,
159      {dwarf_r6, dwarf_r6, LLDB_REGNUM_GENERIC_ARG3, LLDB_INVALID_REGNUM,
160       LLDB_INVALID_REGNUM},
161      nullptr,
162      nullptr,
163      nullptr,
164     },
165     {"r7",
166      nullptr,
167      4,
168      0,
169      eEncodingUint,
170      eFormatHex,
171      {dwarf_r7, dwarf_r7, LLDB_REGNUM_GENERIC_ARG4, LLDB_INVALID_REGNUM,
172       LLDB_INVALID_REGNUM},
173      nullptr,
174      nullptr,
175      nullptr,
176     },
177     {"r8",
178      "arg5",
179      4,
180      0,
181      eEncodingUint,
182      eFormatHex,
183      {dwarf_r8, dwarf_r8, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
184       LLDB_INVALID_REGNUM},
185      nullptr,
186      nullptr,
187      nullptr,
188     },
189     {"r9",
190      "arg6",
191      4,
192      0,
193      eEncodingUint,
194      eFormatHex,
195      {dwarf_r9, dwarf_r9, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
196       LLDB_INVALID_REGNUM},
197      nullptr,
198      nullptr,
199      nullptr,
200     },
201     {"r10",
202      "arg7",
203      4,
204      0,
205      eEncodingUint,
206      eFormatHex,
207      {dwarf_r10, dwarf_r10, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
208       LLDB_INVALID_REGNUM},
209      nullptr,
210      nullptr,
211      nullptr,
212     },
213     {"r11",
214      "arg8",
215      4,
216      0,
217      eEncodingUint,
218      eFormatHex,
219      {dwarf_r11, dwarf_r11, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
220       LLDB_INVALID_REGNUM},
221      nullptr,
222      nullptr,
223      nullptr,
224     },
225     {"r12",
226      nullptr,
227      4,
228      0,
229      eEncodingUint,
230      eFormatHex,
231      {dwarf_r12, dwarf_r12, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
232       LLDB_INVALID_REGNUM},
233      nullptr,
234      nullptr,
235      nullptr,
236     },
237     {"r13",
238      nullptr,
239      4,
240      0,
241      eEncodingUint,
242      eFormatHex,
243      {dwarf_r13, dwarf_r13, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
244       LLDB_INVALID_REGNUM},
245      nullptr,
246      nullptr,
247      nullptr,
248     },
249     {"r14",
250      nullptr,
251      4,
252      0,
253      eEncodingUint,
254      eFormatHex,
255      {dwarf_r14, dwarf_r14, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
256       LLDB_INVALID_REGNUM},
257      nullptr,
258      nullptr,
259      nullptr,
260     },
261     {"r15",
262      nullptr,
263      4,
264      0,
265      eEncodingUint,
266      eFormatHex,
267      {dwarf_r15, dwarf_r15, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
268       LLDB_INVALID_REGNUM},
269      nullptr,
270      nullptr,
271      nullptr,
272     },
273     {"r16",
274      nullptr,
275      4,
276      0,
277      eEncodingUint,
278      eFormatHex,
279      {dwarf_r16, dwarf_r16, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
280       LLDB_INVALID_REGNUM},
281      nullptr,
282      nullptr,
283      nullptr,
284     },
285     {"r17",
286      nullptr,
287      4,
288      0,
289      eEncodingUint,
290      eFormatHex,
291      {dwarf_r17, dwarf_r17, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
292       LLDB_INVALID_REGNUM},
293      nullptr,
294      nullptr,
295      nullptr,
296     },
297     {"r18",
298      nullptr,
299      4,
300      0,
301      eEncodingUint,
302      eFormatHex,
303      {dwarf_r18, dwarf_r18, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
304       LLDB_INVALID_REGNUM},
305      nullptr,
306      nullptr,
307      nullptr,
308     },
309     {"r19",
310      nullptr,
311      4,
312      0,
313      eEncodingUint,
314      eFormatHex,
315      {dwarf_r19, dwarf_r19, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
316       LLDB_INVALID_REGNUM},
317      nullptr,
318      nullptr,
319      nullptr,
320     },
321     {"r20",
322      nullptr,
323      4,
324      0,
325      eEncodingUint,
326      eFormatHex,
327      {dwarf_r20, dwarf_r20, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
328       LLDB_INVALID_REGNUM},
329      nullptr,
330      nullptr,
331      nullptr,
332     },
333     {"r21",
334      nullptr,
335      4,
336      0,
337      eEncodingUint,
338      eFormatHex,
339      {dwarf_r21, dwarf_r21, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
340       LLDB_INVALID_REGNUM},
341      nullptr,
342      nullptr,
343      nullptr,
344     },
345     {"r22",
346      nullptr,
347      4,
348      0,
349      eEncodingUint,
350      eFormatHex,
351      {dwarf_r22, dwarf_r22, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
352       LLDB_INVALID_REGNUM},
353      nullptr,
354      nullptr,
355      nullptr,
356     },
357     {"r23",
358      nullptr,
359      4,
360      0,
361      eEncodingUint,
362      eFormatHex,
363      {dwarf_r23, dwarf_r23, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
364       LLDB_INVALID_REGNUM},
365      nullptr,
366      nullptr,
367      nullptr,
368     },
369     {"r24",
370      nullptr,
371      4,
372      0,
373      eEncodingUint,
374      eFormatHex,
375      {dwarf_r24, dwarf_r24, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
376       LLDB_INVALID_REGNUM},
377      nullptr,
378      nullptr,
379      nullptr,
380     },
381     {"r25",
382      nullptr,
383      4,
384      0,
385      eEncodingUint,
386      eFormatHex,
387      {dwarf_r25, dwarf_r25, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
388       LLDB_INVALID_REGNUM},
389      nullptr,
390      nullptr,
391      nullptr,
392     },
393     {"r26",
394      nullptr,
395      4,
396      0,
397      eEncodingUint,
398      eFormatHex,
399      {dwarf_r26, dwarf_r26, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
400       LLDB_INVALID_REGNUM},
401      nullptr,
402      nullptr,
403      nullptr,
404     },
405     {"r27",
406      nullptr,
407      4,
408      0,
409      eEncodingUint,
410      eFormatHex,
411      {dwarf_r27, dwarf_r27, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
412       LLDB_INVALID_REGNUM},
413      nullptr,
414      nullptr,
415      nullptr,
416     },
417     {"r28",
418      "gp",
419      4,
420      0,
421      eEncodingUint,
422      eFormatHex,
423      {dwarf_r28, dwarf_r28, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
424       LLDB_INVALID_REGNUM},
425      nullptr,
426      nullptr,
427      nullptr,
428     },
429     {"r29",
430      nullptr,
431      4,
432      0,
433      eEncodingUint,
434      eFormatHex,
435      {dwarf_r29, dwarf_r29, LLDB_REGNUM_GENERIC_SP, LLDB_INVALID_REGNUM,
436       LLDB_INVALID_REGNUM},
437      nullptr,
438      nullptr,
439      nullptr,
440     },
441     {"r30",
442      nullptr,
443      4,
444      0,
445      eEncodingUint,
446      eFormatHex,
447      {dwarf_r30, dwarf_r30, LLDB_REGNUM_GENERIC_FP, LLDB_INVALID_REGNUM,
448       LLDB_INVALID_REGNUM},
449      nullptr,
450      nullptr,
451      nullptr,
452     },
453     {"r31",
454      nullptr,
455      4,
456      0,
457      eEncodingUint,
458      eFormatHex,
459      {dwarf_r31, dwarf_r31, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM,
460       LLDB_INVALID_REGNUM},
461      nullptr,
462      nullptr,
463      nullptr,
464     },
465     {"sr",
466      nullptr,
467      4,
468      0,
469      eEncodingUint,
470      eFormatHex,
471      {dwarf_sr, dwarf_sr, LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM,
472       LLDB_INVALID_REGNUM},
473      nullptr,
474      nullptr,
475      nullptr,
476     },
477     {"lo",
478      nullptr,
479      4,
480      0,
481      eEncodingUint,
482      eFormatHex,
483      {dwarf_lo, dwarf_lo, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
484       LLDB_INVALID_REGNUM},
485      nullptr,
486      nullptr,
487      nullptr,
488     },
489     {"hi",
490      nullptr,
491      4,
492      0,
493      eEncodingUint,
494      eFormatHex,
495      {dwarf_hi, dwarf_hi, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
496       LLDB_INVALID_REGNUM},
497      nullptr,
498      nullptr,
499      nullptr,
500     },
501     {"bad",
502      nullptr,
503      4,
504      0,
505      eEncodingUint,
506      eFormatHex,
507      {dwarf_bad, dwarf_bad, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
508       LLDB_INVALID_REGNUM},
509      nullptr,
510      nullptr,
511      nullptr,
512     },
513     {"cause",
514      nullptr,
515      4,
516      0,
517      eEncodingUint,
518      eFormatHex,
519      {dwarf_cause, dwarf_cause, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
520       LLDB_INVALID_REGNUM},
521      nullptr,
522      nullptr,
523      nullptr,
524     },
525     {"pc",
526      nullptr,
527      4,
528      0,
529      eEncodingUint,
530      eFormatHex,
531      {dwarf_pc, dwarf_pc, LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM,
532       LLDB_INVALID_REGNUM},
533      nullptr,
534      nullptr,
535      nullptr,
536     },
537 };
538 
539 static const uint32_t k_num_register_infos = std::size(g_register_infos);
540 
541 const lldb_private::RegisterInfo *
542 ABISysV_mips::GetRegisterInfoArray(uint32_t &count) {
543   count = k_num_register_infos;
544   return g_register_infos;
545 }
546 
547 size_t ABISysV_mips::GetRedZoneSize() const { return 0; }
548 
549 // Static Functions
550 
551 ABISP
552 ABISysV_mips::CreateInstance(lldb::ProcessSP process_sp, const ArchSpec &arch) {
553   const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
554   if ((arch_type == llvm::Triple::mips) ||
555       (arch_type == llvm::Triple::mipsel)) {
556     return ABISP(
557         new ABISysV_mips(std::move(process_sp), MakeMCRegisterInfo(arch)));
558   }
559   return ABISP();
560 }
561 
562 bool ABISysV_mips::PrepareTrivialCall(Thread &thread, addr_t sp,
563                                       addr_t func_addr, addr_t return_addr,
564                                       llvm::ArrayRef<addr_t> args) const {
565   Log *log = GetLog(LLDBLog::Expressions);
566 
567   if (log) {
568     StreamString s;
569     s.Printf("ABISysV_mips::PrepareTrivialCall (tid = 0x%" PRIx64
570              ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64
571              ", return_addr = 0x%" PRIx64,
572              thread.GetID(), (uint64_t)sp, (uint64_t)func_addr,
573              (uint64_t)return_addr);
574 
575     for (size_t i = 0; i < args.size(); ++i)
576       s.Printf(", arg%zd = 0x%" PRIx64, i + 1, args[i]);
577     s.PutCString(")");
578     log->PutString(s.GetString());
579   }
580 
581   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
582   if (!reg_ctx)
583     return false;
584 
585   const RegisterInfo *reg_info = nullptr;
586 
587   RegisterValue reg_value;
588 
589   // Argument registers
590   const char *reg_names[] = {"r4", "r5", "r6", "r7"};
591 
592   llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
593 
594   // Write arguments to registers
595   for (size_t i = 0; i < std::size(reg_names); ++i) {
596     if (ai == ae)
597       break;
598 
599     reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric,
600                                         LLDB_REGNUM_GENERIC_ARG1 + i);
601     LLDB_LOGF(log, "About to write arg%zd (0x%" PRIx64 ") into %s", i + 1,
602               args[i], reg_info->name);
603 
604     if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
605       return false;
606 
607     ++ai;
608   }
609 
610   // If we have more than 4 arguments --Spill onto the stack
611   if (ai != ae) {
612     // No of arguments to go on stack
613     size_t num_stack_regs = args.size();
614 
615     // Allocate needed space for args on the stack
616     sp -= (num_stack_regs * 4);
617 
618     // Keep the stack 8 byte aligned
619     sp &= ~(8ull - 1ull);
620 
621     // just using arg1 to get the right size
622     const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(
623         eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
624 
625     addr_t arg_pos = sp + 16;
626 
627     size_t i = 4;
628     for (; ai != ae; ++ai) {
629       reg_value.SetUInt32(*ai);
630       LLDB_LOGF(log, "About to write arg%zd (0x%" PRIx64 ") at  0x%" PRIx64 "",
631                 i + 1, args[i], arg_pos);
632 
633       if (reg_ctx
634               ->WriteRegisterValueToMemory(reg_info, arg_pos,
635                                            reg_info->byte_size, reg_value)
636               .Fail())
637         return false;
638       arg_pos += reg_info->byte_size;
639       i++;
640     }
641   }
642 
643   Status error;
644   const RegisterInfo *pc_reg_info =
645       reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
646   const RegisterInfo *sp_reg_info =
647       reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
648   const RegisterInfo *ra_reg_info =
649       reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
650   const RegisterInfo *r25_info = reg_ctx->GetRegisterInfoByName("r25", 0);
651   const RegisterInfo *r0_info = reg_ctx->GetRegisterInfoByName("zero", 0);
652 
653   LLDB_LOGF(log, "Writing R0: 0x%" PRIx64, (uint64_t)0);
654 
655   /* Write r0 with 0, in case we are stopped in syscall,
656    * such setting prevents automatic decrement of the PC.
657    * This clears the bug 23659 for MIPS.
658   */
659   if (!reg_ctx->WriteRegisterFromUnsigned(r0_info, (uint64_t)0))
660     return false;
661 
662   LLDB_LOGF(log, "Writing SP: 0x%" PRIx64, (uint64_t)sp);
663 
664   // Set "sp" to the requested value
665   if (!reg_ctx->WriteRegisterFromUnsigned(sp_reg_info, sp))
666     return false;
667 
668   LLDB_LOGF(log, "Writing RA: 0x%" PRIx64, (uint64_t)return_addr);
669 
670   // Set "ra" to the return address
671   if (!reg_ctx->WriteRegisterFromUnsigned(ra_reg_info, return_addr))
672     return false;
673 
674   LLDB_LOGF(log, "Writing PC: 0x%" PRIx64, (uint64_t)func_addr);
675 
676   // Set pc to the address of the called function.
677   if (!reg_ctx->WriteRegisterFromUnsigned(pc_reg_info, func_addr))
678     return false;
679 
680   LLDB_LOGF(log, "Writing r25: 0x%" PRIx64, (uint64_t)func_addr);
681 
682   // All callers of position independent functions must place the address of
683   // the called function in t9 (r25)
684   if (!reg_ctx->WriteRegisterFromUnsigned(r25_info, func_addr))
685     return false;
686 
687   return true;
688 }
689 
690 bool ABISysV_mips::GetArgumentValues(Thread &thread, ValueList &values) const {
691   return false;
692 }
693 
694 Status ABISysV_mips::SetReturnValueObject(lldb::StackFrameSP &frame_sp,
695                                           lldb::ValueObjectSP &new_value_sp) {
696   Status error;
697   if (!new_value_sp) {
698     error = Status::FromErrorString("Empty value object for return value.");
699     return error;
700   }
701 
702   CompilerType compiler_type = new_value_sp->GetCompilerType();
703   if (!compiler_type) {
704     error = Status::FromErrorString("Null clang type for return value.");
705     return error;
706   }
707 
708   Thread *thread = frame_sp->GetThread().get();
709 
710   bool is_signed;
711   uint32_t count;
712   bool is_complex;
713 
714   RegisterContext *reg_ctx = thread->GetRegisterContext().get();
715 
716   bool set_it_simple = false;
717   if (compiler_type.IsIntegerOrEnumerationType(is_signed) ||
718       compiler_type.IsPointerType()) {
719     DataExtractor data;
720     Status data_error;
721     size_t num_bytes = new_value_sp->GetData(data, data_error);
722     if (data_error.Fail()) {
723       error = Status::FromErrorStringWithFormat(
724           "Couldn't convert return value to raw data: %s",
725           data_error.AsCString());
726       return error;
727     }
728 
729     lldb::offset_t offset = 0;
730     if (num_bytes <= 8) {
731       const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
732       if (num_bytes <= 4) {
733         uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
734 
735         if (reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value))
736           set_it_simple = true;
737       } else {
738         uint32_t raw_value = data.GetMaxU32(&offset, 4);
739 
740         if (reg_ctx->WriteRegisterFromUnsigned(r2_info, raw_value)) {
741           const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
742           uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
743 
744           if (reg_ctx->WriteRegisterFromUnsigned(r3_info, raw_value))
745             set_it_simple = true;
746         }
747       }
748     } else {
749       error = Status::FromErrorString(
750           "We don't support returning longer than 64 bit "
751           "integer values at present.");
752     }
753   } else if (compiler_type.IsFloatingPointType(count, is_complex)) {
754     if (is_complex)
755       error = Status::FromErrorString(
756           "We don't support returning complex values at present");
757     else
758       error = Status::FromErrorString(
759           "We don't support returning float values at present");
760   }
761 
762   if (!set_it_simple)
763     error = Status::FromErrorString(
764         "We only support setting simple integer return types at present.");
765 
766   return error;
767 }
768 
769 ValueObjectSP ABISysV_mips::GetReturnValueObjectSimple(
770     Thread &thread, CompilerType &return_compiler_type) const {
771   ValueObjectSP return_valobj_sp;
772   return return_valobj_sp;
773 }
774 
775 ValueObjectSP ABISysV_mips::GetReturnValueObjectImpl(
776     Thread &thread, CompilerType &return_compiler_type) const {
777   ValueObjectSP return_valobj_sp;
778   Value value;
779 
780   if (!return_compiler_type)
781     return return_valobj_sp;
782 
783   ExecutionContext exe_ctx(thread.shared_from_this());
784   if (exe_ctx.GetTargetPtr() == nullptr || exe_ctx.GetProcessPtr() == nullptr)
785     return return_valobj_sp;
786 
787   Target *target = exe_ctx.GetTargetPtr();
788   const ArchSpec target_arch = target->GetArchitecture();
789   ByteOrder target_byte_order = target_arch.GetByteOrder();
790   value.SetCompilerType(return_compiler_type);
791   uint32_t fp_flag =
792       target_arch.GetFlags() & lldb_private::ArchSpec::eMIPS_ABI_FP_mask;
793 
794   RegisterContext *reg_ctx = thread.GetRegisterContext().get();
795   if (!reg_ctx)
796     return return_valobj_sp;
797 
798   bool is_signed = false;
799   bool is_complex = false;
800   uint32_t count = 0;
801 
802   // In MIPS register "r2" (v0) holds the integer function return values
803   const RegisterInfo *r2_reg_info = reg_ctx->GetRegisterInfoByName("r2", 0);
804   std::optional<uint64_t> bit_width = return_compiler_type.GetBitSize(&thread);
805   if (!bit_width)
806     return return_valobj_sp;
807   if (return_compiler_type.IsIntegerOrEnumerationType(is_signed)) {
808     switch (*bit_width) {
809     default:
810       return return_valobj_sp;
811     case 64: {
812       const RegisterInfo *r3_reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
813       uint64_t raw_value;
814       raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX;
815       raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0) &
816                                UINT32_MAX))
817                    << 32;
818       if (is_signed)
819         value.GetScalar() = (int64_t)raw_value;
820       else
821         value.GetScalar() = (uint64_t)raw_value;
822     } break;
823     case 32:
824       if (is_signed)
825         value.GetScalar() = (int32_t)(
826             reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX);
827       else
828         value.GetScalar() = (uint32_t)(
829             reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX);
830       break;
831     case 16:
832       if (is_signed)
833         value.GetScalar() = (int16_t)(
834             reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT16_MAX);
835       else
836         value.GetScalar() = (uint16_t)(
837             reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT16_MAX);
838       break;
839     case 8:
840       if (is_signed)
841         value.GetScalar() = (int8_t)(
842             reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
843       else
844         value.GetScalar() = (uint8_t)(
845             reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
846       break;
847     }
848   } else if (return_compiler_type.IsPointerType()) {
849     uint32_t ptr =
850         thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_reg_info, 0) &
851         UINT32_MAX;
852     value.GetScalar() = ptr;
853   } else if (return_compiler_type.IsAggregateType()) {
854     // Structure/Vector is always passed in memory and pointer to that memory
855     // is passed in r2.
856     uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(
857         reg_ctx->GetRegisterInfoByName("r2", 0), 0);
858     // We have got the address. Create a memory object out of it
859     return_valobj_sp = ValueObjectMemory::Create(
860         &thread, "", Address(mem_address, nullptr), return_compiler_type);
861     return return_valobj_sp;
862   } else if (return_compiler_type.IsFloatingPointType(count, is_complex)) {
863     if (IsSoftFloat(fp_flag)) {
864       uint64_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0);
865       if (count != 1 && is_complex)
866         return return_valobj_sp;
867       switch (*bit_width) {
868       default:
869         return return_valobj_sp;
870       case 32:
871         static_assert(sizeof(float) == sizeof(uint32_t));
872         value.GetScalar() = *((float *)(&raw_value));
873         break;
874       case 64:
875         static_assert(sizeof(double) == sizeof(uint64_t));
876         const RegisterInfo *r3_reg_info =
877             reg_ctx->GetRegisterInfoByName("r3", 0);
878         if (target_byte_order == eByteOrderLittle)
879           raw_value =
880               ((reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0)) << 32) |
881               raw_value;
882         else
883           raw_value = (raw_value << 32) |
884                       reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0);
885         value.GetScalar() = *((double *)(&raw_value));
886         break;
887       }
888     }
889 
890     else {
891       const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
892       RegisterValue f0_value;
893       DataExtractor f0_data;
894       reg_ctx->ReadRegister(f0_info, f0_value);
895       f0_value.GetData(f0_data);
896       lldb::offset_t offset = 0;
897 
898       if (count == 1 && !is_complex) {
899         switch (*bit_width) {
900         default:
901           return return_valobj_sp;
902         case 64: {
903           static_assert(sizeof(double) == sizeof(uint64_t));
904           const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
905           RegisterValue f1_value;
906           DataExtractor f1_data;
907           reg_ctx->ReadRegister(f1_info, f1_value);
908           DataExtractor *copy_from_extractor = nullptr;
909           WritableDataBufferSP data_sp(new DataBufferHeap(8, 0));
910           DataExtractor return_ext(
911               data_sp, target_byte_order,
912               target->GetArchitecture().GetAddressByteSize());
913 
914           if (target_byte_order == eByteOrderLittle) {
915             copy_from_extractor = &f0_data;
916             copy_from_extractor->CopyByteOrderedData(
917                 offset, 4, data_sp->GetBytes(), 4, target_byte_order);
918             f1_value.GetData(f1_data);
919             copy_from_extractor = &f1_data;
920             copy_from_extractor->CopyByteOrderedData(
921                 offset, 4, data_sp->GetBytes() + 4, 4, target_byte_order);
922           } else {
923             copy_from_extractor = &f0_data;
924             copy_from_extractor->CopyByteOrderedData(
925                 offset, 4, data_sp->GetBytes() + 4, 4, target_byte_order);
926             f1_value.GetData(f1_data);
927             copy_from_extractor = &f1_data;
928             copy_from_extractor->CopyByteOrderedData(
929                 offset, 4, data_sp->GetBytes(), 4, target_byte_order);
930           }
931           value.GetScalar() = (double)return_ext.GetDouble(&offset);
932           break;
933         }
934         case 32: {
935           static_assert(sizeof(float) == sizeof(uint32_t));
936           value.GetScalar() = (float)f0_data.GetFloat(&offset);
937           break;
938         }
939         }
940       } else {
941         // not handled yet
942         return return_valobj_sp;
943       }
944     }
945   } else {
946     // not handled yet
947     return return_valobj_sp;
948   }
949 
950   // If we get here, we have a valid Value, so make our ValueObject out of it:
951 
952   return_valobj_sp = ValueObjectConstResult::Create(
953       thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
954   return return_valobj_sp;
955 }
956 
957 bool ABISysV_mips::CreateFunctionEntryUnwindPlan(UnwindPlan &unwind_plan) {
958   unwind_plan.Clear();
959   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
960 
961   UnwindPlan::RowSP row(new UnwindPlan::Row);
962 
963   // Our Call Frame Address is the stack pointer value
964   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
965 
966   // The previous PC is in the RA
967   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
968   unwind_plan.AppendRow(row);
969 
970   // All other registers are the same.
971 
972   unwind_plan.SetSourceName("mips at-func-entry default");
973   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
974   unwind_plan.SetReturnAddressRegister(dwarf_r31);
975   return true;
976 }
977 
978 bool ABISysV_mips::CreateDefaultUnwindPlan(UnwindPlan &unwind_plan) {
979   unwind_plan.Clear();
980   unwind_plan.SetRegisterKind(eRegisterKindDWARF);
981 
982   UnwindPlan::RowSP row(new UnwindPlan::Row);
983 
984   row->SetUnspecifiedRegistersAreUndefined(true);
985   row->GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
986 
987   row->SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
988 
989   unwind_plan.AppendRow(row);
990   unwind_plan.SetSourceName("mips default unwind plan");
991   unwind_plan.SetSourcedFromCompiler(eLazyBoolNo);
992   unwind_plan.SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
993   unwind_plan.SetUnwindPlanForSignalTrap(eLazyBoolNo);
994   return true;
995 }
996 
997 bool ABISysV_mips::RegisterIsVolatile(const RegisterInfo *reg_info) {
998   return !RegisterIsCalleeSaved(reg_info);
999 }
1000 
1001 bool ABISysV_mips::IsSoftFloat(uint32_t fp_flags) const {
1002   return (fp_flags == lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT);
1003 }
1004 
1005 bool ABISysV_mips::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
1006   if (reg_info) {
1007     // Preserved registers are :
1008     // r16-r23, r28, r29, r30, r31
1009     const char *name = reg_info->name;
1010 
1011     if (name[0] == 'r') {
1012       switch (name[1]) {
1013       case '1':
1014         if (name[2] == '6' || name[2] == '7' || name[2] == '8' ||
1015             name[2] == '9') // r16-r19
1016           return name[3] == '\0';
1017         break;
1018       case '2':
1019         if (name[2] == '0' || name[2] == '1' || name[2] == '2' ||
1020             name[2] == '3'                       // r20-r23
1021             || name[2] == '8' || name[2] == '9') // r28 and r29
1022           return name[3] == '\0';
1023         break;
1024       case '3':
1025         if (name[2] == '0' || name[2] == '1') // r30 and r31
1026           return name[3] == '\0';
1027         break;
1028       }
1029 
1030       if (name[0] == 'g' && name[1] == 'p' && name[2] == '\0') // gp (r28)
1031         return true;
1032       if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') // sp (r29)
1033         return true;
1034       if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0') // fp (r30)
1035         return true;
1036       if (name[0] == 'r' && name[1] == 'a' && name[2] == '\0') // ra (r31)
1037         return true;
1038     }
1039   }
1040   return false;
1041 }
1042 
1043 void ABISysV_mips::Initialize() {
1044   PluginManager::RegisterPlugin(
1045       GetPluginNameStatic(), "System V ABI for mips targets", CreateInstance);
1046 }
1047 
1048 void ABISysV_mips::Terminate() {
1049   PluginManager::UnregisterPlugin(CreateInstance);
1050 }
1051