contrib/llvm/tools/lldb/source/Plugins/ABI/SysV-ppc64/ABISysV_ppc64.cpp

   1 //===-- ABISysV_ppc64.cpp --------------------------------------*- 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 #include "ABISysV_ppc64.h"
  11
  12 #include "lldb/Core/ConstString.h"
  13 #include "lldb/Core/DataExtractor.h"
  14 #include "lldb/Core/Error.h"
  15 #include "lldb/Core/Log.h"
  16 #include "lldb/Core/Module.h"
  17 #include "lldb/Core/PluginManager.h"
  18 #include "lldb/Core/RegisterValue.h"
  19 #include "lldb/Core/Value.h"
  20 #include "lldb/Core/ValueObjectConstResult.h"
  21 #include "lldb/Core/ValueObjectRegister.h"
  22 #include "lldb/Core/ValueObjectMemory.h"
  23 #include "lldb/Symbol/ClangASTContext.h"
  24 #include "lldb/Symbol/UnwindPlan.h"
  25 #include "lldb/Target/Target.h"
  26 #include "lldb/Target/Process.h"
  27 #include "lldb/Target/RegisterContext.h"
  28 #include "lldb/Target/StackFrame.h"
  29 #include "lldb/Target/Thread.h"
  30
  31 #include "llvm/ADT/STLExtras.h"
  32 #include "llvm/ADT/Triple.h"
  33
  34 using namespace lldb;
  35 using namespace lldb_private;
  36
  37 enum gcc_dwarf_regnums
  38 {
  39     gcc_dwarf_r0 = 0,
  40     gcc_dwarf_r1,
  41     gcc_dwarf_r2,
  42     gcc_dwarf_r3,
  43     gcc_dwarf_r4,
  44     gcc_dwarf_r5,
  45     gcc_dwarf_r6,
  46     gcc_dwarf_r7,
  47     gcc_dwarf_r8,
  48     gcc_dwarf_r9,
  49     gcc_dwarf_r10,
  50     gcc_dwarf_r11,
  51     gcc_dwarf_r12,
  52     gcc_dwarf_r13,
  53     gcc_dwarf_r14,
  54     gcc_dwarf_r15,
  55     gcc_dwarf_r16,
  56     gcc_dwarf_r17,
  57     gcc_dwarf_r18,
  58     gcc_dwarf_r19,
  59     gcc_dwarf_r20,
  60     gcc_dwarf_r21,
  61     gcc_dwarf_r22,
  62     gcc_dwarf_r23,
  63     gcc_dwarf_r24,
  64     gcc_dwarf_r25,
  65     gcc_dwarf_r26,
  66     gcc_dwarf_r27,
  67     gcc_dwarf_r28,
  68     gcc_dwarf_r29,
  69     gcc_dwarf_r30,
  70     gcc_dwarf_r31,
  71     gcc_dwarf_f0,
  72     gcc_dwarf_f1,
  73     gcc_dwarf_f2,
  74     gcc_dwarf_f3,
  75     gcc_dwarf_f4,
  76     gcc_dwarf_f5,
  77     gcc_dwarf_f6,
  78     gcc_dwarf_f7,
  79     gcc_dwarf_f8,
  80     gcc_dwarf_f9,
  81     gcc_dwarf_f10,
  82     gcc_dwarf_f11,
  83     gcc_dwarf_f12,
  84     gcc_dwarf_f13,
  85     gcc_dwarf_f14,
  86     gcc_dwarf_f15,
  87     gcc_dwarf_f16,
  88     gcc_dwarf_f17,
  89     gcc_dwarf_f18,
  90     gcc_dwarf_f19,
  91     gcc_dwarf_f20,
  92     gcc_dwarf_f21,
  93     gcc_dwarf_f22,
  94     gcc_dwarf_f23,
  95     gcc_dwarf_f24,
  96     gcc_dwarf_f25,
  97     gcc_dwarf_f26,
  98     gcc_dwarf_f27,
  99     gcc_dwarf_f28,
 100     gcc_dwarf_f29,
 101     gcc_dwarf_f30,
 102     gcc_dwarf_f31,
 103     gcc_dwarf_cr,
 104     gcc_dwarf_fpscr,
 105     gcc_dwarf_xer = 101,
 106     gcc_dwarf_lr = 108,
 107     gcc_dwarf_ctr,
 108     gcc_dwarf_pc,
 109     gcc_dwarf_cfa,
 110 };
 111
 112 enum gdb_regnums
 113 {
 114     gdb_r0 = 0,
 115     gdb_r1,
 116     gdb_r2,
 117     gdb_r3,
 118     gdb_r4,
 119     gdb_r5,
 120     gdb_r6,
 121     gdb_r7,
 122     gdb_r8,
 123     gdb_r9,
 124     gdb_r10,
 125     gdb_r11,
 126     gdb_r12,
 127     gdb_r13,
 128     gdb_r14,
 129     gdb_r15,
 130     gdb_r16,
 131     gdb_r17,
 132     gdb_r18,
 133     gdb_r19,
 134     gdb_r20,
 135     gdb_r21,
 136     gdb_r22,
 137     gdb_r23,
 138     gdb_r24,
 139     gdb_r25,
 140     gdb_r26,
 141     gdb_r27,
 142     gdb_r28,
 143     gdb_r29,
 144     gdb_r30,
 145     gdb_r31,
 146     gdb_lr,
 147     gdb_cr,
 148     gdb_xer,
 149     gdb_ctr,
 150     gdb_pc,
 151 };
 152
 153
 154 // Note that the size and offset will be updated by platform-specific classes.
 155 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)           \
 156     { #reg, alt, 8, 0, eEncodingUint, \
 157       eFormatHex, { kind1, kind2, kind3, kind4}, NULL, NULL }
 158 static const RegisterInfo
 159 g_register_infos[] =
 160 {
 161     // General purpose registers.                 GCC,                  DWARF,              Generic,                GDB
 162     DEFINE_GPR(r0,       NULL,  gcc_dwarf_r0,    gcc_dwarf_r0,    LLDB_INVALID_REGNUM,    gdb_r0),
 163     DEFINE_GPR(r1,       "sp",  gcc_dwarf_r1,    gcc_dwarf_r1,    LLDB_REGNUM_GENERIC_SP, gdb_r1),
 164     DEFINE_GPR(r2,       NULL,  gcc_dwarf_r2,    gcc_dwarf_r2,    LLDB_INVALID_REGNUM,    gdb_r2),
 165     DEFINE_GPR(r3,       "arg1",gcc_dwarf_r3,    gcc_dwarf_r3,    LLDB_REGNUM_GENERIC_ARG1, gdb_r3),
 166     DEFINE_GPR(r4,       "arg2",gcc_dwarf_r4,    gcc_dwarf_r4,    LLDB_REGNUM_GENERIC_ARG2 ,gdb_r4),
 167     DEFINE_GPR(r5,       "arg3",gcc_dwarf_r5,    gcc_dwarf_r5,    LLDB_REGNUM_GENERIC_ARG3, gdb_r5),
 168     DEFINE_GPR(r6,       "arg4",gcc_dwarf_r6,    gcc_dwarf_r6,    LLDB_REGNUM_GENERIC_ARG4, gdb_r6),
 169     DEFINE_GPR(r7,       "arg5",gcc_dwarf_r7,    gcc_dwarf_r7,    LLDB_REGNUM_GENERIC_ARG5, gdb_r7),
 170     DEFINE_GPR(r8,       "arg6",gcc_dwarf_r8,    gcc_dwarf_r8,    LLDB_REGNUM_GENERIC_ARG6, gdb_r8),
 171     DEFINE_GPR(r9,       "arg7",gcc_dwarf_r9,    gcc_dwarf_r9,    LLDB_REGNUM_GENERIC_ARG7, gdb_r9),
 172     DEFINE_GPR(r10,      "arg8",gcc_dwarf_r10,   gcc_dwarf_r10,   LLDB_REGNUM_GENERIC_ARG8, gdb_r10),
 173     DEFINE_GPR(r11,      NULL,  gcc_dwarf_r11,   gcc_dwarf_r11,   LLDB_INVALID_REGNUM,    gdb_r11),
 174     DEFINE_GPR(r12,      NULL,  gcc_dwarf_r12,   gcc_dwarf_r12,   LLDB_INVALID_REGNUM,    gdb_r12),
 175     DEFINE_GPR(r13,      NULL,  gcc_dwarf_r13,   gcc_dwarf_r13,   LLDB_INVALID_REGNUM,    gdb_r13),
 176     DEFINE_GPR(r14,      NULL,  gcc_dwarf_r14,   gcc_dwarf_r14,   LLDB_INVALID_REGNUM,    gdb_r14),
 177     DEFINE_GPR(r15,      NULL,  gcc_dwarf_r15,   gcc_dwarf_r15,   LLDB_INVALID_REGNUM,    gdb_r15),
 178     DEFINE_GPR(r16,      NULL,  gcc_dwarf_r16,   gcc_dwarf_r16,   LLDB_INVALID_REGNUM,    gdb_r16),
 179     DEFINE_GPR(r17,      NULL,  gcc_dwarf_r17,   gcc_dwarf_r17,   LLDB_INVALID_REGNUM,    gdb_r17),
 180     DEFINE_GPR(r18,      NULL,  gcc_dwarf_r18,   gcc_dwarf_r18,   LLDB_INVALID_REGNUM,    gdb_r18),
 181     DEFINE_GPR(r19,      NULL,  gcc_dwarf_r19,   gcc_dwarf_r19,   LLDB_INVALID_REGNUM,    gdb_r19),
 182     DEFINE_GPR(r20,      NULL,  gcc_dwarf_r20,   gcc_dwarf_r20,   LLDB_INVALID_REGNUM,    gdb_r20),
 183     DEFINE_GPR(r21,      NULL,  gcc_dwarf_r21,   gcc_dwarf_r21,   LLDB_INVALID_REGNUM,    gdb_r21),
 184     DEFINE_GPR(r22,      NULL,  gcc_dwarf_r22,   gcc_dwarf_r22,   LLDB_INVALID_REGNUM,    gdb_r22),
 185     DEFINE_GPR(r23,      NULL,  gcc_dwarf_r23,   gcc_dwarf_r23,   LLDB_INVALID_REGNUM,    gdb_r23),
 186     DEFINE_GPR(r24,      NULL,  gcc_dwarf_r24,   gcc_dwarf_r24,   LLDB_INVALID_REGNUM,    gdb_r24),
 187     DEFINE_GPR(r25,      NULL,  gcc_dwarf_r25,   gcc_dwarf_r25,   LLDB_INVALID_REGNUM,    gdb_r25),
 188     DEFINE_GPR(r26,      NULL,  gcc_dwarf_r26,   gcc_dwarf_r26,   LLDB_INVALID_REGNUM,    gdb_r26),
 189     DEFINE_GPR(r27,      NULL,  gcc_dwarf_r27,   gcc_dwarf_r27,   LLDB_INVALID_REGNUM,    gdb_r27),
 190     DEFINE_GPR(r28,      NULL,  gcc_dwarf_r28,   gcc_dwarf_r28,   LLDB_INVALID_REGNUM,    gdb_r28),
 191     DEFINE_GPR(r29,      NULL,  gcc_dwarf_r29,   gcc_dwarf_r29,   LLDB_INVALID_REGNUM,    gdb_r29),
 192     DEFINE_GPR(r30,      NULL,  gcc_dwarf_r30,   gcc_dwarf_r30,   LLDB_INVALID_REGNUM,    gdb_r30),
 193     DEFINE_GPR(r31,      NULL,  gcc_dwarf_r31,   gcc_dwarf_r31,   LLDB_INVALID_REGNUM,    gdb_r31),
 194     DEFINE_GPR(lr,       "lr",  gcc_dwarf_lr,    gcc_dwarf_lr,    LLDB_REGNUM_GENERIC_RA, gdb_lr),
 195     DEFINE_GPR(cr,       "cr",  gcc_dwarf_cr,    gcc_dwarf_cr,    LLDB_REGNUM_GENERIC_FLAGS, LLDB_INVALID_REGNUM),
 196     DEFINE_GPR(xer,      "xer", gcc_dwarf_xer,   gcc_dwarf_xer,   LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
 197     DEFINE_GPR(ctr,      "ctr", gcc_dwarf_ctr,   gcc_dwarf_ctr,   LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
 198     DEFINE_GPR(pc,       "pc",  gcc_dwarf_pc,    gcc_dwarf_pc,    LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM),
 199     { NULL, NULL, 8, 0, eEncodingUint, eFormatHex, { gcc_dwarf_cfa, gcc_dwarf_cfa, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM}, NULL, NULL},
 200 };
 201
 202 static const uint32_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
 203
 204 const lldb_private::RegisterInfo *
 205 ABISysV_ppc64::GetRegisterInfoArray (uint32_t &count)
 206 {
 207     count = k_num_register_infos;
 208     return g_register_infos;
 209 }
 210
 211
 212 size_t
 213 ABISysV_ppc64::GetRedZoneSize () const
 214 {
 215     return 224;
 216 }
 217
 218 //------------------------------------------------------------------
 219 // Static Functions
 220 //------------------------------------------------------------------
 221 ABISP
 222 ABISysV_ppc64::CreateInstance (const ArchSpec &arch)
 223 {
 224     static ABISP g_abi_sp;
 225     if (arch.GetTriple().getArch() == llvm::Triple::ppc64)
 226     {
 227         if (!g_abi_sp)
 228             g_abi_sp.reset (new ABISysV_ppc64);
 229         return g_abi_sp;
 230     }
 231     return ABISP();
 232 }
 233
 234 bool
 235 ABISysV_ppc64::PrepareTrivialCall (Thread &thread,
 236                                     addr_t sp,
 237                                     addr_t func_addr,
 238                                     addr_t return_addr,
 239                                     llvm::ArrayRef<addr_t> args) const
 240 {
 241     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 242
 243     if (log)
 244     {
 245         StreamString s;
 246         s.Printf("ABISysV_ppc64::PrepareTrivialCall (tid = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", return_addr = 0x%" PRIx64,
 247                     thread.GetID(),
 248                     (uint64_t)sp,
 249                     (uint64_t)func_addr,
 250                     (uint64_t)return_addr);
 251
 252         for (size_t i = 0; i < args.size(); ++i)
 253             s.Printf (", arg%zd = 0x%" PRIx64, i + 1, args[i]);
 254         s.PutCString (")");
 255         log->PutCString(s.GetString().c_str());
 256     }
 257
 258     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 259     if (!reg_ctx)
 260         return false;
 261
 262     const RegisterInfo *reg_info = NULL;
 263
 264     if (args.size() > 8) // TODO handle more than 8 arguments
 265         return false;
 266
 267     for (size_t i = 0; i < args.size(); ++i)
 268     {
 269         reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
 270         if (log)
 271             log->Printf("About to write arg%zd (0x%" PRIx64 ") into %s", i + 1, args[i], reg_info->name);
 272         if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
 273             return false;
 274     }
 275
 276     // First, align the SP
 277
 278     if (log)
 279         log->Printf("16-byte aligning SP: 0x%" PRIx64 " to 0x%" PRIx64, (uint64_t)sp, (uint64_t)(sp & ~0xfull));
 280
 281     sp &= ~(0xfull); // 16-byte alignment
 282
 283     sp -= 8;
 284
 285     Error error;
 286     const RegisterInfo *pc_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 287     const RegisterInfo *sp_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
 288     ProcessSP process_sp (thread.GetProcess());
 289
 290     RegisterValue reg_value;
 291
 292 #if 0
 293     // This code adds an extra frame so that we don't lose the function that we came from
 294     // by pushing the PC and the FP and then writing the current FP to point to the FP value
 295     // we just pushed. It is disabled for now until the stack backtracing code can be debugged.
 296
 297     // Save current PC
 298     const RegisterInfo *fp_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP);
 299     if (reg_ctx->ReadRegister(pc_reg_info, reg_value))
 300     {
 301         if (log)
 302             log->Printf("Pushing the current PC onto the stack: 0x%" PRIx64 ": 0x%" PRIx64, (uint64_t)sp, reg_value.GetAsUInt64());
 303
 304         if (!process_sp->WritePointerToMemory(sp, reg_value.GetAsUInt64(), error))
 305             return false;
 306
 307         sp -= 8;
 308
 309         // Save current FP
 310         if (reg_ctx->ReadRegister(fp_reg_info, reg_value))
 311         {
 312             if (log)
 313                 log->Printf("Pushing the current FP onto the stack: 0x%" PRIx64 ": 0x%" PRIx64, (uint64_t)sp, reg_value.GetAsUInt64());
 314
 315             if (!process_sp->WritePointerToMemory(sp, reg_value.GetAsUInt64(), error))
 316                 return false;
 317         }
 318         // Setup FP backchain
 319         reg_value.SetUInt64 (sp);
 320
 321         if (log)
 322             log->Printf("Writing FP:  0x%" PRIx64 " (for FP backchain)", reg_value.GetAsUInt64());
 323
 324         if (!reg_ctx->WriteRegister(fp_reg_info, reg_value))
 325         {
 326             return false;
 327         }
 328
 329         sp -= 8;
 330     }
 331 #endif
 332
 333     if (log)
 334         log->Printf("Pushing the return address onto the stack: 0x%" PRIx64 ": 0x%" PRIx64, (uint64_t)sp, (uint64_t)return_addr);
 335
 336     // Save return address onto the stack
 337     if (!process_sp->WritePointerToMemory(sp, return_addr, error))
 338         return false;
 339
 340     // %r1 is set to the actual stack value.
 341
 342     if (log)
 343         log->Printf("Writing SP: 0x%" PRIx64, (uint64_t)sp);
 344
 345     if (!reg_ctx->WriteRegisterFromUnsigned (sp_reg_info, sp))
 346         return false;
 347
 348     // %pc is set to the address of the called function.
 349
 350     if (log)
 351         log->Printf("Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
 352
 353     if (!reg_ctx->WriteRegisterFromUnsigned (pc_reg_info, func_addr))
 354         return false;
 355
 356     return true;
 357 }
 358
 359 static bool ReadIntegerArgument(Scalar           &scalar,
 360                                 unsigned int     bit_width,
 361                                 bool             is_signed,
 362                                 Thread           &thread,
 363                                 uint32_t         *argument_register_ids,
 364                                 unsigned int     &current_argument_register,
 365                                 addr_t           &current_stack_argument)
 366 {
 367     if (bit_width > 64)
 368         return false; // Scalar can't hold large integer arguments
 369
 370     if (current_argument_register < 6)
 371     {
 372         scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(argument_register_ids[current_argument_register], 0);
 373         current_argument_register++;
 374         if (is_signed)
 375             scalar.SignExtend (bit_width);
 376     }
 377     else
 378     {
 379         uint32_t byte_size = (bit_width + (8-1))/8;
 380         Error error;
 381         if (thread.GetProcess()->ReadScalarIntegerFromMemory(current_stack_argument, byte_size, is_signed, scalar, error))
 382         {
 383             current_stack_argument += byte_size;
 384             return true;
 385         }
 386         return false;
 387     }
 388     return true;
 389 }
 390
 391 bool
 392 ABISysV_ppc64::GetArgumentValues (Thread &thread,
 393                                    ValueList &values) const
 394 {
 395     unsigned int num_values = values.GetSize();
 396     unsigned int value_index;
 397
 398     // Extract the register context so we can read arguments from registers
 399
 400     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 401
 402     if (!reg_ctx)
 403         return false;
 404
 405     // Get the pointer to the first stack argument so we have a place to start
 406     // when reading data
 407
 408     addr_t sp = reg_ctx->GetSP(0);
 409
 410     if (!sp)
 411         return false;
 412
 413     addr_t current_stack_argument = sp + 48; // jump over return address
 414
 415     uint32_t argument_register_ids[8];
 416
 417     argument_register_ids[0] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1)->kinds[eRegisterKindLLDB];
 418     argument_register_ids[1] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2)->kinds[eRegisterKindLLDB];
 419     argument_register_ids[2] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG3)->kinds[eRegisterKindLLDB];
 420     argument_register_ids[3] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG4)->kinds[eRegisterKindLLDB];
 421     argument_register_ids[4] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG5)->kinds[eRegisterKindLLDB];
 422     argument_register_ids[5] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG6)->kinds[eRegisterKindLLDB];
 423     argument_register_ids[6] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG7)->kinds[eRegisterKindLLDB];
 424     argument_register_ids[7] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG8)->kinds[eRegisterKindLLDB];
 425
 426     unsigned int current_argument_register = 0;
 427
 428     for (value_index = 0;
 429          value_index < num_values;
 430          ++value_index)
 431     {
 432         Value *value = values.GetValueAtIndex(value_index);
 433
 434         if (!value)
 435             return false;
 436
 437         // We currently only support extracting values with Clang QualTypes.
 438         // Do we care about others?
 439         ClangASTType clang_type = value->GetClangType();
 440         if (!clang_type)
 441             return false;
 442         bool is_signed;
 443
 444         if (clang_type.IsIntegerType (is_signed))
 445         {
 446             ReadIntegerArgument(value->GetScalar(),
 447                                 clang_type.GetBitSize(),
 448                                 is_signed,
 449                                 thread,
 450                                 argument_register_ids,
 451                                 current_argument_register,
 452                                 current_stack_argument);
 453         }
 454         else if (clang_type.IsPointerType ())
 455         {
 456             ReadIntegerArgument(value->GetScalar(),
 457                                 clang_type.GetBitSize(),
 458                                 false,
 459                                 thread,
 460                                 argument_register_ids,
 461                                 current_argument_register,
 462                                 current_stack_argument);
 463         }
 464     }
 465
 466     return true;
 467 }
 468
 469 Error
 470 ABISysV_ppc64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
 471 {
 472     Error error;
 473     if (!new_value_sp)
 474     {
 475         error.SetErrorString("Empty value object for return value.");
 476         return error;
 477     }
 478
 479     ClangASTType clang_type = new_value_sp->GetClangType();
 480     if (!clang_type)
 481     {
 482         error.SetErrorString ("Null clang type for return value.");
 483         return error;
 484     }
 485
 486     Thread *thread = frame_sp->GetThread().get();
 487
 488     bool is_signed;
 489     uint32_t count;
 490     bool is_complex;
 491
 492     RegisterContext *reg_ctx = thread->GetRegisterContext().get();
 493
 494     bool set_it_simple = false;
 495     if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType())
 496     {
 497         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
 498
 499         DataExtractor data;
 500         Error data_error;
 501         size_t num_bytes = new_value_sp->GetData(data, data_error);
 502         if (data_error.Fail())
 503         {
 504             error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
 505             return error;
 506         }
 507         lldb::offset_t offset = 0;
 508         if (num_bytes <= 8)
 509         {
 510             uint64_t raw_value = data.GetMaxU64(&offset, num_bytes);
 511
 512             if (reg_ctx->WriteRegisterFromUnsigned (reg_info, raw_value))
 513                 set_it_simple = true;
 514         }
 515         else
 516         {
 517             error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
 518         }
 519
 520     }
 521     else if (clang_type.IsFloatingPointType (count, is_complex))
 522     {
 523         if (is_complex)
 524             error.SetErrorString ("We don't support returning complex values at present");
 525         else
 526         {
 527             size_t bit_width = clang_type.GetBitSize();
 528             if (bit_width <= 64)
 529             {
 530                 DataExtractor data;
 531                 Error data_error;
 532                 size_t num_bytes = new_value_sp->GetData(data, data_error);
 533                 if (data_error.Fail())
 534                 {
 535                     error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
 536                     return error;
 537                 }
 538
 539                 unsigned char buffer[16];
 540                 ByteOrder byte_order = data.GetByteOrder();
 541
 542                 data.CopyByteOrderedData (0, num_bytes, buffer, 16, byte_order);
 543                 set_it_simple = true;
 544             }
 545             else
 546             {
 547                 // FIXME - don't know how to do 80 bit long doubles yet.
 548                 error.SetErrorString ("We don't support returning float values > 64 bits at present");
 549             }
 550         }
 551     }
 552
 553     if (!set_it_simple)
 554     {
 555         // Okay we've got a structure or something that doesn't fit in a simple register.
 556         // We should figure out where it really goes, but we don't support this yet.
 557         error.SetErrorString ("We only support setting simple integer and float return types at present.");
 558     }
 559
 560     return error;
 561 }
 562
 563
 564 ValueObjectSP
 565 ABISysV_ppc64::GetReturnValueObjectSimple (Thread &thread,
 566                                             ClangASTType &return_clang_type) const
 567 {
 568     ValueObjectSP return_valobj_sp;
 569     Value value;
 570
 571     if (!return_clang_type)
 572         return return_valobj_sp;
 573
 574     //value.SetContext (Value::eContextTypeClangType, return_value_type);
 575     value.SetClangType (return_clang_type);
 576
 577     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 578     if (!reg_ctx)
 579         return return_valobj_sp;
 580
 581     const uint32_t type_flags = return_clang_type.GetTypeInfo ();
 582     if (type_flags & eTypeIsScalar)
 583     {
 584         value.SetValueType(Value::eValueTypeScalar);
 585
 586         bool success = false;
 587         if (type_flags & eTypeIsInteger)
 588         {
 589             // Extract the register context so we can read arguments from registers
 590
 591             const size_t byte_size = return_clang_type.GetByteSize();
 592             uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("r3", 0), 0);
 593             const bool is_signed = (type_flags & eTypeIsSigned) != 0;
 594             switch (byte_size)
 595             {
 596             default:
 597                 break;
 598
 599             case sizeof(uint64_t):
 600                 if (is_signed)
 601                     value.GetScalar() = (int64_t)(raw_value);
 602                 else
 603                     value.GetScalar() = (uint64_t)(raw_value);
 604                 success = true;
 605                 break;
 606
 607             case sizeof(uint32_t):
 608                 if (is_signed)
 609                     value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
 610                 else
 611                     value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
 612                 success = true;
 613                 break;
 614
 615             case sizeof(uint16_t):
 616                 if (is_signed)
 617                     value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
 618                 else
 619                     value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
 620                 success = true;
 621                 break;
 622
 623             case sizeof(uint8_t):
 624                 if (is_signed)
 625                     value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
 626                 else
 627                     value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
 628                 success = true;
 629                 break;
 630             }
 631         }
 632         else if (type_flags & eTypeIsFloat)
 633         {
 634             if (type_flags & eTypeIsComplex)
 635             {
 636                 // Don't handle complex yet.
 637             }
 638             else
 639             {
 640                 const size_t byte_size = return_clang_type.GetByteSize();
 641                 if (byte_size <= sizeof(long double))
 642                 {
 643                     const RegisterInfo *f1_info = reg_ctx->GetRegisterInfoByName("f1", 0);
 644                     RegisterValue f1_value;
 645                     if (reg_ctx->ReadRegister (f1_info, f1_value))
 646                     {
 647                         DataExtractor data;
 648                         if (f1_value.GetData(data))
 649                         {
 650                             lldb::offset_t offset = 0;
 651                             if (byte_size == sizeof(float))
 652                             {
 653                                 value.GetScalar() = (float) data.GetFloat(&offset);
 654                                 success = true;
 655                             }
 656                             else if (byte_size == sizeof(double))
 657                             {
 658                                 value.GetScalar() = (double) data.GetDouble(&offset);
 659                                 success = true;
 660                             }
 661                         }
 662                     }
 663                 }
 664             }
 665         }
 666
 667         if (success)
 668             return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
 669                                                                value,
 670                                                                ConstString(""));
 671
 672     }
 673     else if (type_flags & eTypeIsPointer)
 674     {
 675         unsigned r3_id = reg_ctx->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB];
 676         value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
 677         value.SetValueType(Value::eValueTypeScalar);
 678         return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
 679                                                            value,
 680                                                            ConstString(""));
 681     }
 682     else if (type_flags & eTypeIsVector)
 683     {
 684         const size_t byte_size = return_clang_type.GetByteSize();
 685         if (byte_size > 0)
 686         {
 687
 688             const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("v0", 0);
 689             if (altivec_reg == NULL)
 690                 altivec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
 691             if (altivec_reg)
 692             {
 693                 if (byte_size <= altivec_reg->byte_size)
 694                 {
 695                     ProcessSP process_sp (thread.GetProcess());
 696                     if (process_sp)
 697                     {
 698                         std::unique_ptr<DataBufferHeap> heap_data_ap (new DataBufferHeap(byte_size, 0));
 699                         const ByteOrder byte_order = process_sp->GetByteOrder();
 700                         RegisterValue reg_value;
 701                         if (reg_ctx->ReadRegister(altivec_reg, reg_value))
 702                         {
 703                             Error error;
 704                             if (reg_value.GetAsMemoryData (altivec_reg,
 705                                                            heap_data_ap->GetBytes(),
 706                                                            heap_data_ap->GetByteSize(),
 707                                                            byte_order,
 708                                                            error))
 709                             {
 710                                 DataExtractor data (DataBufferSP (heap_data_ap.release()),
 711                                                     byte_order,
 712                                                     process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
 713                                 return_valobj_sp = ValueObjectConstResult::Create (&thread,
 714                                                                                    return_clang_type,
 715                                                                                    ConstString(""),
 716                                                                                    data);
 717                             }
 718                         }
 719                     }
 720                 }
 721             }
 722         }
 723     }
 724
 725     return return_valobj_sp;
 726 }
 727
 728 ValueObjectSP
 729 ABISysV_ppc64::GetReturnValueObjectImpl (Thread &thread, ClangASTType &return_clang_type) const
 730 {
 731     ValueObjectSP return_valobj_sp;
 732
 733     if (!return_clang_type)
 734         return return_valobj_sp;
 735
 736     ExecutionContext exe_ctx (thread.shared_from_this());
 737     return_valobj_sp = GetReturnValueObjectSimple(thread, return_clang_type);
 738     if (return_valobj_sp)
 739         return return_valobj_sp;
 740
 741     RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
 742     if (!reg_ctx_sp)
 743         return return_valobj_sp;
 744
 745     const size_t bit_width = return_clang_type.GetBitSize();
 746     if (return_clang_type.IsAggregateType())
 747     {
 748         Target *target = exe_ctx.GetTargetPtr();
 749         bool is_memory = true;
 750         if (bit_width <= 128)
 751         {
 752             ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
 753             DataBufferSP data_sp (new DataBufferHeap(16, 0));
 754             DataExtractor return_ext (data_sp,
 755                                       target_byte_order,
 756                                       target->GetArchitecture().GetAddressByteSize());
 757
 758             const RegisterInfo *r3_info = reg_ctx_sp->GetRegisterInfoByName("r3", 0);
 759             const RegisterInfo *rdx_info = reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
 760
 761             RegisterValue r3_value, rdx_value;
 762             reg_ctx_sp->ReadRegister (r3_info, r3_value);
 763             reg_ctx_sp->ReadRegister (rdx_info, rdx_value);
 764
 765             DataExtractor r3_data, rdx_data;
 766
 767             r3_value.GetData(r3_data);
 768             rdx_value.GetData(rdx_data);
 769
 770             uint32_t fp_bytes = 0;       // Tracks how much of the xmm registers we've consumed so far
 771             uint32_t integer_bytes = 0;  // Tracks how much of the r3/rds registers we've consumed so far
 772
 773             const uint32_t num_children = return_clang_type.GetNumFields ();
 774
 775             // Since we are in the small struct regime, assume we are not in memory.
 776             is_memory = false;
 777
 778             for (uint32_t idx = 0; idx < num_children; idx++)
 779             {
 780                 std::string name;
 781                 uint64_t field_bit_offset = 0;
 782                 bool is_signed;
 783                 bool is_complex;
 784                 uint32_t count;
 785
 786                 ClangASTType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
 787                 const size_t field_bit_width = field_clang_type.GetBitSize();
 788
 789                 // If there are any unaligned fields, this is stored in memory.
 790                 if (field_bit_offset % field_bit_width != 0)
 791                 {
 792                     is_memory = true;
 793                     break;
 794                 }
 795
 796                 uint32_t field_byte_width = field_bit_width/8;
 797                 uint32_t field_byte_offset = field_bit_offset/8;
 798
 799
 800                 DataExtractor *copy_from_extractor = NULL;
 801                 uint32_t       copy_from_offset    = 0;
 802
 803                 if (field_clang_type.IsIntegerType (is_signed) || field_clang_type.IsPointerType ())
 804                 {
 805                     if (integer_bytes < 8)
 806                     {
 807                         if (integer_bytes + field_byte_width <= 8)
 808                         {
 809                             // This is in RAX, copy from register to our result structure:
 810                             copy_from_extractor = &r3_data;
 811                             copy_from_offset = integer_bytes;
 812                             integer_bytes += field_byte_width;
 813                         }
 814                         else
 815                         {
 816                             // The next field wouldn't fit in the remaining space, so we pushed it to rdx.
 817                             copy_from_extractor = &rdx_data;
 818                             copy_from_offset = 0;
 819                             integer_bytes = 8 + field_byte_width;
 820
 821                         }
 822                     }
 823                     else if (integer_bytes + field_byte_width <= 16)
 824                     {
 825                         copy_from_extractor = &rdx_data;
 826                         copy_from_offset = integer_bytes - 8;
 827                         integer_bytes += field_byte_width;
 828                     }
 829                     else
 830                     {
 831                         // The last field didn't fit.  I can't see how that would happen w/o the overall size being
 832                         // greater than 16 bytes.  For now, return a NULL return value object.
 833                         return return_valobj_sp;
 834                     }
 835                 }
 836                 else if (field_clang_type.IsFloatingPointType (count, is_complex))
 837                 {
 838                     // Structs with long doubles are always passed in memory.
 839                     if (field_bit_width == 128)
 840                     {
 841                         is_memory = true;
 842                         break;
 843                     }
 844                     else if (field_bit_width == 64)
 845                     {
 846                         copy_from_offset = 0;
 847                         fp_bytes += field_byte_width;
 848                     }
 849                     else if (field_bit_width == 32)
 850                     {
 851                         // This one is kind of complicated.  If we are in an "eightbyte" with another float, we'll
 852                         // be stuffed into an xmm register with it.  If we are in an "eightbyte" with one or more ints,
 853                         // then we will be stuffed into the appropriate GPR with them.
 854                         bool in_gpr;
 855                         if (field_byte_offset % 8 == 0)
 856                         {
 857                             // We are at the beginning of one of the eightbytes, so check the next element (if any)
 858                             if (idx == num_children - 1)
 859                                 in_gpr = false;
 860                             else
 861                             {
 862                                 uint64_t next_field_bit_offset = 0;
 863                                 ClangASTType next_field_clang_type = return_clang_type.GetFieldAtIndex (idx + 1,
 864                                                                                                         name,
 865                                                                                                         &next_field_bit_offset,
 866                                                                                                         NULL,
 867                                                                                                         NULL);
 868                                 if (next_field_clang_type.IsIntegerType (is_signed))
 869                                     in_gpr = true;
 870                                 else
 871                                 {
 872                                     copy_from_offset = 0;
 873                                     in_gpr = false;
 874                                 }
 875                             }
 876
 877                         }
 878                         else if (field_byte_offset % 4 == 0)
 879                         {
 880                             // We are inside of an eightbyte, so see if the field before us is floating point:
 881                             // This could happen if somebody put padding in the structure.
 882                             if (idx == 0)
 883                                 in_gpr = false;
 884                             else
 885                             {
 886                                 uint64_t prev_field_bit_offset = 0;
 887                                 ClangASTType prev_field_clang_type = return_clang_type.GetFieldAtIndex (idx - 1,
 888                                                                                                         name,
 889                                                                                                         &prev_field_bit_offset,
 890                                                                                                         NULL,
 891                                                                                                         NULL);
 892                                 if (prev_field_clang_type.IsIntegerType (is_signed))
 893                                     in_gpr = true;
 894                                 else
 895                                 {
 896                                     copy_from_offset = 4;
 897                                     in_gpr = false;
 898                                 }
 899                             }
 900
 901                         }
 902                         else
 903                         {
 904                             is_memory = true;
 905                             continue;
 906                         }
 907
 908                         // Okay, we've figured out whether we are in GPR or XMM, now figure out which one.
 909                         if (in_gpr)
 910                         {
 911                             if (integer_bytes < 8)
 912                             {
 913                                 // This is in RAX, copy from register to our result structure:
 914                                 copy_from_extractor = &r3_data;
 915                                 copy_from_offset = integer_bytes;
 916                                 integer_bytes += field_byte_width;
 917                             }
 918                             else
 919                             {
 920                                 copy_from_extractor = &rdx_data;
 921                                 copy_from_offset = integer_bytes - 8;
 922                                 integer_bytes += field_byte_width;
 923                             }
 924                         }
 925                         else
 926                         {
 927                             fp_bytes += field_byte_width;
 928                         }
 929                     }
 930                 }
 931
 932                 // These two tests are just sanity checks.  If I somehow get the
 933                 // type calculation wrong above it is better to just return nothing
 934                 // than to assert or crash.
 935                 if (!copy_from_extractor)
 936                     return return_valobj_sp;
 937                 if (copy_from_offset + field_byte_width > copy_from_extractor->GetByteSize())
 938                     return return_valobj_sp;
 939
 940                 copy_from_extractor->CopyByteOrderedData (copy_from_offset,
 941                                                           field_byte_width,
 942                                                           data_sp->GetBytes() + field_byte_offset,
 943                                                           field_byte_width,
 944                                                           target_byte_order);
 945             }
 946
 947             if (!is_memory)
 948             {
 949                 // The result is in our data buffer.  Let's make a variable object out of it:
 950                 return_valobj_sp = ValueObjectConstResult::Create (&thread,
 951                                                                    return_clang_type,
 952                                                                    ConstString(""),
 953                                                                    return_ext);
 954             }
 955         }
 956
 957
 958         // FIXME: This is just taking a guess, r3 may very well no longer hold the return storage location.
 959         // If we are going to do this right, when we make a new frame we should check to see if it uses a memory
 960         // return, and if we are at the first instruction and if so stash away the return location.  Then we would
 961         // only return the memory return value if we know it is valid.
 962
 963         if (is_memory)
 964         {
 965             unsigned r3_id = reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB];
 966             lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0);
 967             return_valobj_sp = ValueObjectMemory::Create (&thread,
 968                                                           "",
 969                                                           Address (storage_addr, NULL),
 970                                                           return_clang_type);
 971         }
 972     }
 973
 974     return return_valobj_sp;
 975 }
 976
 977 bool
 978 ABISysV_ppc64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
 979 {
 980     unwind_plan.Clear();
 981     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 982
 983     uint32_t lr_reg_num = gcc_dwarf_lr;
 984     uint32_t sp_reg_num = gcc_dwarf_r1;
 985     uint32_t pc_reg_num = gcc_dwarf_pc;
 986
 987     UnwindPlan::RowSP row(new UnwindPlan::Row);
 988
 989     // Our Call Frame Address is the stack pointer value
 990     row->SetCFARegister (sp_reg_num);
 991
 992     // The previous PC is in the LR
 993     row->SetRegisterLocationToRegister(pc_reg_num, lr_reg_num, true);
 994     unwind_plan.AppendRow (row);
 995
 996     // All other registers are the same.
 997
 998     unwind_plan.SetSourceName ("ppc64 at-func-entry default");
 999     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
1000
1001     return true;
1002 }
1003
1004 bool
1005 ABISysV_ppc64::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
1006 {
1007     unwind_plan.Clear();
1008     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
1009
1010     uint32_t sp_reg_num = gcc_dwarf_r1;
1011     uint32_t pc_reg_num = gcc_dwarf_lr;
1012
1013     UnwindPlan::RowSP row(new UnwindPlan::Row);
1014
1015     const int32_t ptr_size = 8;
1016     row->SetCFARegister (sp_reg_num);
1017     row->SetCFAType(lldb_private::UnwindPlan::Row::CFAIsRegisterDereferenced);
1018
1019     row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * 2, true);
1020     row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
1021     row->SetRegisterLocationToAtCFAPlusOffset(gcc_dwarf_cr, ptr_size, true);
1022
1023     unwind_plan.AppendRow (row);
1024     unwind_plan.SetSourceName ("ppc64 default unwind plan");
1025     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
1026     unwind_plan.SetUnwindPlanValidAtAllInstructions (eLazyBoolNo);
1027     unwind_plan.SetReturnAddressRegister(gcc_dwarf_lr);
1028     return true;
1029 }
1030
1031 bool
1032 ABISysV_ppc64::RegisterIsVolatile (const RegisterInfo *reg_info)
1033 {
1034     return !RegisterIsCalleeSaved (reg_info);
1035 }
1036
1037
1038
1039 // See "Register Usage" in the
1040 // "System V Application Binary Interface"
1041 // "64-bit PowerPC ELF Application Binary Interface Supplement"
1042 // current version is 1.9 released 2004 at http://refspecs.linuxfoundation.org/ELF/ppc64/PPC-elf64abi-1.9.pdf
1043
1044 bool
1045 ABISysV_ppc64::RegisterIsCalleeSaved (const RegisterInfo *reg_info)
1046 {
1047     if (reg_info)
1048     {
1049         // Preserved registers are :
1050         //    r1,r2,r13-r31
1051         //    cr2-cr4 (partially preserved)
1052         //    f14-f31 (not yet)
1053         //    v20-v31 (not yet)
1054         //    vrsave (not yet)
1055
1056         const char *name = reg_info->name;
1057         if (name[0] == 'r')
1058         {
1059             if ((name[1] == '1' || name[1] == '2') && name[2] == '\0')
1060                 return true;
1061             if (name[1] == '1' && name[2] > '2')
1062                 return true;
1063             if ((name[1] == '2' || name[1] == '3') && name[2] != '\0')
1064                 return true;
1065         }
1066
1067         if (name[0] == 'f' && name[1] >= '0' && name[2] <= '9')
1068         {
1069             if (name[2] == '\0')
1070                 return false;
1071             if (name[1] == '1' && name[2] >= '4')
1072                 return true;
1073             if ((name[1] == '2' || name[1] == '3') && name[2] != '\0')
1074                 return true;
1075         }
1076
1077         if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')   // sp
1078             return true;
1079         if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0')   // fp
1080             return true;
1081         if (name[0] == 'p' && name[1] == 'c' && name[2] == '\0')   // pc
1082             return true;
1083     }
1084     return false;
1085 }
1086
1087
1088
1089 void
1090 ABISysV_ppc64::Initialize()
1091 {
1092     PluginManager::RegisterPlugin (GetPluginNameStatic(),
1093                                    "System V ABI for ppc64 targets",
1094                                    CreateInstance);
1095 }
1096
1097 void
1098 ABISysV_ppc64::Terminate()
1099 {
1100     PluginManager::UnregisterPlugin (CreateInstance);
1101 }
1102
1103 lldb_private::ConstString
1104 ABISysV_ppc64::GetPluginNameStatic()
1105 {
1106     static ConstString g_name("sysv-ppc64");
1107     return g_name;
1108 }
1109
1110 //------------------------------------------------------------------
1111 // PluginInterface protocol
1112 //------------------------------------------------------------------
1113 lldb_private::ConstString
1114 ABISysV_ppc64::GetPluginName()
1115 {
1116     return GetPluginNameStatic();
1117 }
1118
1119 uint32_t
1120 ABISysV_ppc64::GetPluginVersion()
1121 {
1122     return 1;
1123 }
1124