Debian Codegraph @

lldb/source/Plugins/ABI/Mips/ABISysV_mips.cpp

raw
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 =
805 llvm::expectedToOptional(return_compiler_type.GetBitSize(&thread));
806 if (!bit_width)
807 return return_valobj_sp;
808 if (return_compiler_type.IsIntegerOrEnumerationType(is_signed)) {
809 switch (*bit_width) {
810 default:
811 return return_valobj_sp;
812 case 64: {
813 const RegisterInfo *r3_reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
814 uint64_t raw_value;
815 raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX;
816 raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0) &
817 UINT32_MAX))
818 << 32;
819 if (is_signed)
820 value.GetScalar() = (int64_t)raw_value;
821 else
822 value.GetScalar() = (uint64_t)raw_value;
823 } break;
824 case 32:
825 if (is_signed)
826 value.GetScalar() = (int32_t)(
827 reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX);
828 else
829 value.GetScalar() = (uint32_t)(
830 reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX);
831 break;
832 case 16:
833 if (is_signed)
834 value.GetScalar() = (int16_t)(
835 reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT16_MAX);
836 else
837 value.GetScalar() = (uint16_t)(
838 reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT16_MAX);
839 break;
840 case 8:
841 if (is_signed)
842 value.GetScalar() = (int8_t)(
843 reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
844 else
845 value.GetScalar() = (uint8_t)(
846 reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
847 break;
848 }
849 } else if (return_compiler_type.IsPointerType()) {
850 uint32_t ptr =
851 thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_reg_info, 0) &
852 UINT32_MAX;
853 value.GetScalar() = ptr;
854 } else if (return_compiler_type.IsAggregateType()) {
855 // Structure/Vector is always passed in memory and pointer to that memory
856 // is passed in r2.
857 uint64_t mem_address = reg_ctx->ReadRegisterAsUnsigned(
858 reg_ctx->GetRegisterInfoByName("r2", 0), 0);
859 // We have got the address. Create a memory object out of it
860 return_valobj_sp = ValueObjectMemory::Create(
861 &thread, "", Address(mem_address, nullptr), return_compiler_type);
862 return return_valobj_sp;
863 } else if (return_compiler_type.IsFloatingPointType(count, is_complex)) {
864 if (IsSoftFloat(fp_flag)) {
865 uint64_t raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0);
866 if (count != 1 && is_complex)
867 return return_valobj_sp;
868 switch (*bit_width) {
869 default:
870 return return_valobj_sp;
871 case 32:
872 static_assert(sizeof(float) == sizeof(uint32_t));
873 value.GetScalar() = *((float *)(&raw_value));
874 break;
875 case 64:
876 static_assert(sizeof(double) == sizeof(uint64_t));
877 const RegisterInfo *r3_reg_info =
878 reg_ctx->GetRegisterInfoByName("r3", 0);
879 if (target_byte_order == eByteOrderLittle)
880 raw_value =
881 ((reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0)) << 32) |
882 raw_value;
883 else
884 raw_value = (raw_value << 32) |
885 reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0);
886 value.GetScalar() = *((double *)(&raw_value));
887 break;
888 }
889 }
890
891 else {
892 const RegisterInfo *f0_info = reg_ctx->GetRegisterInfoByName("f0", 0);
893 RegisterValue f0_value;
894 DataExtractor f0_data;
895 reg_ctx->ReadRegister(f0_info, f0_value);
896 f0_value.GetData(f0_data);
897 lldb::offset_t offset = 0;
898
899 if (count == 1 && !is_complex) {
900 switch (*bit_width) {
901 default:
902 return return_valobj_sp;
903 case 64: {
904 static_assert(sizeof(double) == sizeof(uint64_t));
905 const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
906 RegisterValue f1_value;
907 DataExtractor f1_data;
908 reg_ctx->ReadRegister(f1_info, f1_value);
909 DataExtractor *copy_from_extractor = nullptr;
910 WritableDataBufferSP data_sp(new DataBufferHeap(8, 0));
911 DataExtractor return_ext(
912 data_sp, target_byte_order,
913 target->GetArchitecture().GetAddressByteSize());
914
915 if (target_byte_order == eByteOrderLittle) {
916 copy_from_extractor = &f0_data;
917 copy_from_extractor->CopyByteOrderedData(
918 offset, 4, data_sp->GetBytes(), 4, target_byte_order);
919 f1_value.GetData(f1_data);
920 copy_from_extractor = &f1_data;
921 copy_from_extractor->CopyByteOrderedData(
922 offset, 4, data_sp->GetBytes() + 4, 4, target_byte_order);
923 } else {
924 copy_from_extractor = &f0_data;
925 copy_from_extractor->CopyByteOrderedData(
926 offset, 4, data_sp->GetBytes() + 4, 4, target_byte_order);
927 f1_value.GetData(f1_data);
928 copy_from_extractor = &f1_data;
929 copy_from_extractor->CopyByteOrderedData(
930 offset, 4, data_sp->GetBytes(), 4, target_byte_order);
931 }
932 value.GetScalar() = (double)return_ext.GetDouble(&offset);
933 break;
934 }
935 case 32: {
936 static_assert(sizeof(float) == sizeof(uint32_t));
937 value.GetScalar() = (float)f0_data.GetFloat(&offset);
938 break;
939 }
940 }
941 } else {
942 // not handled yet
943 return return_valobj_sp;
944 }
945 }
946 } else {
947 // not handled yet
948 return return_valobj_sp;
949 }
950
951 // If we get here, we have a valid Value, so make our ValueObject out of it:
952
953 return_valobj_sp = ValueObjectConstResult::Create(
954 thread.GetStackFrameAtIndex(0).get(), value, ConstString(""));
955 return return_valobj_sp;
956 }
957
958 UnwindPlanSP ABISysV_mips::CreateFunctionEntryUnwindPlan() {
959 UnwindPlan::Row row;
960
961 // Our Call Frame Address is the stack pointer value
962 row.GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
963
964 // The previous PC is in the RA, all other registers are the same.
965 row.SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
966
967 auto plan_sp = std::make_shared<UnwindPlan>(eRegisterKindDWARF);
968 plan_sp->AppendRow(std::move(row));
969 plan_sp->SetSourceName("mips at-func-entry default");
970 plan_sp->SetSourcedFromCompiler(eLazyBoolNo);
971 plan_sp->SetReturnAddressRegister(dwarf_r31);
972 return plan_sp;
973 }
974
975 UnwindPlanSP ABISysV_mips::CreateDefaultUnwindPlan() {
976 UnwindPlan::Row row;
977
978 row.SetUnspecifiedRegistersAreUndefined(true);
979 row.GetCFAValue().SetIsRegisterPlusOffset(dwarf_r29, 0);
980
981 row.SetRegisterLocationToRegister(dwarf_pc, dwarf_r31, true);
982
983 auto plan_sp = std::make_shared<UnwindPlan>(eRegisterKindDWARF);
984 plan_sp->AppendRow(std::move(row));
985 plan_sp->SetSourceName("mips default unwind plan");
986 plan_sp->SetSourcedFromCompiler(eLazyBoolNo);
987 plan_sp->SetUnwindPlanValidAtAllInstructions(eLazyBoolNo);
988 plan_sp->SetUnwindPlanForSignalTrap(eLazyBoolNo);
989 return plan_sp;
990 }
991
992 bool ABISysV_mips::RegisterIsVolatile(const RegisterInfo *reg_info) {
993 return !RegisterIsCalleeSaved(reg_info);
994 }
995
996 bool ABISysV_mips::IsSoftFloat(uint32_t fp_flags) const {
997 return (fp_flags == lldb_private::ArchSpec::eMIPS_ABI_FP_SOFT);
998 }
999
1000 bool ABISysV_mips::RegisterIsCalleeSaved(const RegisterInfo *reg_info) {
1001 if (reg_info) {
1002 // Preserved registers are :
1003 // r16-r23, r28, r29, r30, r31
1004 const char *name = reg_info->name;
1005
1006 if (name[0] == 'r') {
1007 switch (name[1]) {
1008 case '1':
1009 if (name[2] == '6' || name[2] == '7' || name[2] == '8' ||
1010 name[2] == '9') // r16-r19
1011 return name[3] == '\0';
1012 break;
1013 case '2':
1014 if (name[2] == '0' || name[2] == '1' || name[2] == '2' ||
1015 name[2] == '3' // r20-r23
1016 || name[2] == '8' || name[2] == '9') // r28 and r29
1017 return name[3] == '\0';
1018 break;
1019 case '3':
1020 if (name[2] == '0' || name[2] == '1') // r30 and r31
1021 return name[3] == '\0';
1022 break;
1023 }
1024
1025 if (name[0] == 'g' && name[1] == 'p' && name[2] == '\0') // gp (r28)
1026 return true;
1027 if (name[0] == 's' && name[1] == 'p' && name[2] == '\0') // sp (r29)
1028 return true;
1029 if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0') // fp (r30)
1030 return true;
1031 if (name[0] == 'r' && name[1] == 'a' && name[2] == '\0') // ra (r31)
1032 return true;
1033 }
1034 }
1035 return false;
1036 }
1037
1038 void ABISysV_mips::Initialize() {
1039 PluginManager::RegisterPlugin(
1040 GetPluginNameStatic(), "System V ABI for mips targets", CreateInstance);
1041 }
1042
1043 void ABISysV_mips::Terminate() {
1044 PluginManager::UnregisterPlugin(CreateInstance);
1045 }