contrib/llvm/tools/lldb/source/Plugins/ABI/SysV-mips/ABISysV_mips.cpp

   1 //===-- ABISysV_mips.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_mips.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_sr,
  72     gcc_dwarf_lo,
  73     gcc_dwarf_hi,
  74     gcc_dwarf_bad,
  75     gcc_dwarf_cause,
  76     gcc_dwarf_pc
  77 };
  78
  79 enum gdb_regnums
  80 {
  81     gdb_r0 = 0,
  82     gdb_r1,
  83     gdb_r2,
  84     gdb_r3,
  85     gdb_r4,
  86     gdb_r5,
  87     gdb_r6,
  88     gdb_r7,
  89     gdb_r8,
  90     gdb_r9,
  91     gdb_r10,
  92     gdb_r11,
  93     gdb_r12,
  94     gdb_r13,
  95     gdb_r14,
  96     gdb_r15,
  97     gdb_r16,
  98     gdb_r17,
  99     gdb_r18,
 100     gdb_r19,
 101     gdb_r20,
 102     gdb_r21,
 103     gdb_r22,
 104     gdb_r23,
 105     gdb_r24,
 106     gdb_r25,
 107     gdb_r26,
 108     gdb_r27,
 109     gdb_r28,
 110     gdb_r29,
 111     gdb_r30,
 112     gdb_r31,
 113     gdb_sr,
 114     gdb_lo,
 115     gdb_hi,
 116     gdb_bad,
 117     gdb_cause,
 118     gdb_pc
 119 };
 120
 121 static const RegisterInfo
 122 g_register_infos[] =
 123 {
 124    //  NAME      ALT    SZ OFF ENCODING        FORMAT        COMPILER                DWARF                 GENERIC                   GDB           LLDB NATIVE       VALUE REGS  INVALIDATE REGS
 125   //  ========  ======  == === =============  =================== ============ ===================== ==================== =================     ====================== ========== ===============
 126     { "r0"    , "zero", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r0,      gcc_dwarf_r0,           LLDB_INVALID_REGNUM,        gdb_r0,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 127     { "r1"    , "AT",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r1,      gcc_dwarf_r1,           LLDB_INVALID_REGNUM,        gdb_r1,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 128     { "r2"    , "v0",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r2,      gcc_dwarf_r2,           LLDB_INVALID_REGNUM,        gdb_r2,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 129     { "r3"    , "v1",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r3,      gcc_dwarf_r3,           LLDB_INVALID_REGNUM,        gdb_r3,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 130     { "r4"    , "arg1", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r4,      gcc_dwarf_r4,           LLDB_REGNUM_GENERIC_ARG1,   gdb_r4,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 131     { "r5"    , "arg2", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r5,      gcc_dwarf_r5,           LLDB_REGNUM_GENERIC_ARG2,   gdb_r5,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 132     { "r6"    , "arg3", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r6,      gcc_dwarf_r6,           LLDB_REGNUM_GENERIC_ARG3,   gdb_r6,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 133     { "r7"    , "arg4", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r7,      gcc_dwarf_r7,           LLDB_REGNUM_GENERIC_ARG4,   gdb_r7,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 134     { "r8"    , "arg5", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r8,      gcc_dwarf_r8,           LLDB_INVALID_REGNUM,        gdb_r8,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 135     { "r9"    , "arg6", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r9,      gcc_dwarf_r9,           LLDB_INVALID_REGNUM,        gdb_r9,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 136     { "r10"   , "arg7", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r10,     gcc_dwarf_r10,          LLDB_INVALID_REGNUM,        gdb_r10,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 137     { "r11"   , "arg8", 4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r11,     gcc_dwarf_r11,          LLDB_INVALID_REGNUM,        gdb_r11,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 138     { "r12"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r12,     gcc_dwarf_r12,          LLDB_INVALID_REGNUM,        gdb_r12,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 139     { "r13"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r13,     gcc_dwarf_r13,          LLDB_INVALID_REGNUM,        gdb_r13,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 140     { "r14"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r14,     gcc_dwarf_r14,          LLDB_INVALID_REGNUM,        gdb_r14,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 141     { "r15"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r15,     gcc_dwarf_r15,          LLDB_INVALID_REGNUM,        gdb_r15,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 142     { "r16"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r16,     gcc_dwarf_r16,          LLDB_INVALID_REGNUM,        gdb_r16,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 143     { "r17"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r17,     gcc_dwarf_r17,          LLDB_INVALID_REGNUM,        gdb_r17,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 144     { "r18"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r18,     gcc_dwarf_r18,          LLDB_INVALID_REGNUM,        gdb_r18,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 145     { "r19"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r19,     gcc_dwarf_r19,          LLDB_INVALID_REGNUM,        gdb_r19,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 146     { "r20"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r20,     gcc_dwarf_r20,          LLDB_INVALID_REGNUM,        gdb_r20,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 147     { "r21"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r21,     gcc_dwarf_r21,          LLDB_INVALID_REGNUM,        gdb_r21,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 148     { "r22"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r22,     gcc_dwarf_r22,          LLDB_INVALID_REGNUM,        gdb_r22,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 149     { "r23"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r23,     gcc_dwarf_r23,          LLDB_INVALID_REGNUM,        gdb_r23,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 150     { "r24"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r24,     gcc_dwarf_r24,          LLDB_INVALID_REGNUM,        gdb_r24,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 151     { "r25"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r25,     gcc_dwarf_r25,          LLDB_INVALID_REGNUM,        gdb_r25,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 152     { "r26"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r26,     gcc_dwarf_r26,          LLDB_INVALID_REGNUM,        gdb_r26,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 153     { "r27"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r27,     gcc_dwarf_r27,          LLDB_INVALID_REGNUM,        gdb_r27,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 154     { "r28"   , "gp",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r28,     gcc_dwarf_r28,          LLDB_INVALID_REGNUM,        gdb_r28,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 155     { "r29"   , "sp",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r29,     gcc_dwarf_r29,          LLDB_REGNUM_GENERIC_SP,     gdb_r29,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 156     { "r30"   , "fp",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r30,     gcc_dwarf_r30,          LLDB_REGNUM_GENERIC_FP,     gdb_r30,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 157     { "r31"   , "ra",   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_r31,     gcc_dwarf_r31,          LLDB_REGNUM_GENERIC_RA,     gdb_r31,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 158     { "sr"    , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_sr,      gcc_dwarf_sr,           LLDB_REGNUM_GENERIC_FLAGS,  gdb_sr,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 159     { "lo"    , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_lo,      gcc_dwarf_lo,           LLDB_INVALID_REGNUM,        gdb_lo,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 160     { "hi"    , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_hi,      gcc_dwarf_hi,           LLDB_INVALID_REGNUM,        gdb_hi,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 161     { "bad"   , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_bad,     gcc_dwarf_bad,          LLDB_INVALID_REGNUM,        gdb_bad,    LLDB_INVALID_REGNUM },  NULL,      NULL},
 162     { "cause" , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_cause,   gcc_dwarf_cause,        LLDB_INVALID_REGNUM,        gdb_cause,  LLDB_INVALID_REGNUM },  NULL,      NULL},
 163     { "pc"    , NULL,   4,  0, eEncodingUint, eFormatHex,  { gcc_dwarf_pc,      gcc_dwarf_pc,           LLDB_REGNUM_GENERIC_PC,     gdb_pc,     LLDB_INVALID_REGNUM },  NULL,      NULL},
 164 };
 165
 166 static const uint32_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
 167
 168 const lldb_private::RegisterInfo *
 169 ABISysV_mips::GetRegisterInfoArray (uint32_t &count)
 170 {
 171     count = k_num_register_infos;
 172     return g_register_infos;
 173 }
 174
 175 size_t
 176 ABISysV_mips::GetRedZoneSize () const
 177 {
 178     return 0;
 179 }
 180
 181 //------------------------------------------------------------------
 182 // Static Functions
 183 //------------------------------------------------------------------
 184 ABISP
 185 ABISysV_mips::CreateInstance (const ArchSpec &arch)
 186 {
 187     static ABISP g_abi_sp;
 188     const llvm::Triple::ArchType arch_type = arch.GetTriple().getArch();
 189     if ((arch_type == llvm::Triple::mips) ||
 190         (arch_type == llvm::Triple::mipsel))
 191     {
 192         if (!g_abi_sp)
 193             g_abi_sp.reset (new ABISysV_mips);
 194         return g_abi_sp;
 195     }
 196     return ABISP();
 197 }
 198
 199 bool
 200 ABISysV_mips::PrepareTrivialCall (Thread &thread,
 201                                   addr_t sp,
 202                                   addr_t func_addr,
 203                                   addr_t return_addr,
 204                                   llvm::ArrayRef<addr_t> args) const
 205 {
 206     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 207
 208     if (log)
 209     {
 210         StreamString s;
 211         s.Printf("ABISysV_mips::PrepareTrivialCall (tid = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", return_addr = 0x%" PRIx64,
 212                     thread.GetID(),
 213                     (uint64_t)sp,
 214                     (uint64_t)func_addr,
 215                     (uint64_t)return_addr);
 216
 217         for (size_t i = 0; i < args.size(); ++i)
 218             s.Printf (", arg%zd = 0x%" PRIx64, i + 1, args[i]);
 219         s.PutCString (")");
 220         log->PutCString(s.GetString().c_str());
 221     }
 222
 223     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 224     if (!reg_ctx)
 225         return false;
 226
 227     const RegisterInfo *reg_info = NULL;
 228
 229     RegisterValue reg_value;
 230
 231     // Argument registers
 232     const char *reg_names[] = { "r4", "r5", "r6", "r7" };
 233
 234     llvm::ArrayRef<addr_t>::iterator ai = args.begin(), ae = args.end();
 235
 236     // Write arguments to registers
 237     for (size_t i = 0; i < llvm::array_lengthof(reg_names); ++i)
 238     {
 239         if (ai == ae)
 240             break;
 241
 242         reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
 243         if (log)
 244             log->Printf("About to write arg%zd (0x%" PRIx64 ") into %s", i + 1, args[i], reg_info->name);
 245
 246         if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
 247             return false;
 248
 249         ++ai;
 250     }
 251
 252     // If we have more than 4 arguments --Spill onto the stack
 253     if (ai != ae)
 254     {
 255         // No of arguments to go on stack
 256         size_t num_stack_regs = args.size();
 257
 258         // Allocate needed space for args on the stack
 259         sp -= (num_stack_regs * 4);
 260
 261         // Keep the stack 8 byte aligned
 262         sp &= ~(8ull-1ull);
 263
 264         // just using arg1 to get the right size
 265         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1);
 266
 267         addr_t arg_pos = sp+16;
 268
 269         size_t i = 4;
 270         for (; ai != ae; ++ai)
 271         {
 272             reg_value.SetUInt32(*ai);
 273             if (log)
 274                 log->Printf("About to write arg%zd (0x%" PRIx64 ") at  0x%" PRIx64 "", i+1, args[i], arg_pos);
 275
 276             if (reg_ctx->WriteRegisterValueToMemory(reg_info, arg_pos, reg_info->byte_size, reg_value).Fail())
 277                 return false;
 278             arg_pos += reg_info->byte_size;
 279             i++;
 280         }
 281     }
 282
 283     Error error;
 284     const RegisterInfo *pc_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 285     const RegisterInfo *sp_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
 286     const RegisterInfo *ra_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
 287
 288     if (log)
 289     log->Printf("Writing SP: 0x%" PRIx64, (uint64_t)sp);
 290
 291     // Set "sp" to the requested value
 292     if (!reg_ctx->WriteRegisterFromUnsigned (sp_reg_info, sp))
 293         return false;
 294
 295     if (log)
 296     log->Printf("Writing RA: 0x%" PRIx64, (uint64_t)return_addr);
 297
 298     // Set "ra" to the return address
 299     if (!reg_ctx->WriteRegisterFromUnsigned (ra_reg_info, return_addr))
 300         return false;
 301
 302     if (log)
 303         log->Printf("Writing PC: 0x%" PRIx64, (uint64_t)func_addr);
 304
 305     // Set pc to the address of the called function.
 306     if (!reg_ctx->WriteRegisterFromUnsigned (pc_reg_info, func_addr))
 307         return false;
 308
 309     return true;
 310 }
 311
 312 bool
 313 ABISysV_mips::GetArgumentValues (Thread &thread, ValueList &values) const
 314 {
 315     return false;
 316 }
 317
 318 Error
 319 ABISysV_mips::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
 320 {
 321     Error error;
 322     if (!new_value_sp)
 323     {
 324         error.SetErrorString("Empty value object for return value.");
 325         return error;
 326     }
 327
 328     ClangASTType clang_type = new_value_sp->GetClangType();
 329     if (!clang_type)
 330     {
 331         error.SetErrorString ("Null clang type for return value.");
 332         return error;
 333     }
 334
 335     Thread *thread = frame_sp->GetThread().get();
 336
 337     bool is_signed;
 338     uint32_t count;
 339     bool is_complex;
 340
 341     RegisterContext *reg_ctx = thread->GetRegisterContext().get();
 342
 343     bool set_it_simple = false;
 344     if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType())
 345     {
 346         DataExtractor data;
 347         Error data_error;
 348         size_t num_bytes = new_value_sp->GetData(data, data_error);
 349         if (data_error.Fail())
 350         {
 351             error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
 352             return error;
 353         }
 354
 355         lldb::offset_t offset = 0;
 356         if (num_bytes <= 8)
 357         {
 358             const RegisterInfo *r2_info = reg_ctx->GetRegisterInfoByName("r2", 0);
 359             if (num_bytes <= 4)
 360             {
 361                 uint32_t raw_value = data.GetMaxU32(&offset, num_bytes);
 362
 363                 if (reg_ctx->WriteRegisterFromUnsigned (r2_info, raw_value))
 364                     set_it_simple = true;
 365             }
 366             else
 367             {
 368                 uint32_t raw_value = data.GetMaxU32(&offset, 4);
 369
 370                 if (reg_ctx->WriteRegisterFromUnsigned (r2_info, raw_value))
 371                 {
 372                     const RegisterInfo *r3_info = reg_ctx->GetRegisterInfoByName("r3", 0);
 373                     uint32_t raw_value = data.GetMaxU32(&offset, num_bytes - offset);
 374
 375                     if (reg_ctx->WriteRegisterFromUnsigned (r3_info, raw_value))
 376                         set_it_simple = true;
 377                 }
 378             }
 379         }
 380         else
 381         {
 382             error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
 383         }
 384     }
 385     else if (clang_type.IsFloatingPointType (count, is_complex))
 386     {
 387         if (is_complex)
 388             error.SetErrorString ("We don't support returning complex values at present");
 389         else
 390             error.SetErrorString ("We don't support returning float values at present");
 391     }
 392
 393     if (!set_it_simple)
 394         error.SetErrorString ("We only support setting simple integer return types at present.");
 395
 396     return error;
 397 }
 398
 399
 400 ValueObjectSP
 401 ABISysV_mips::GetReturnValueObjectSimple (Thread &thread, ClangASTType &return_clang_type) const
 402 {
 403     ValueObjectSP return_valobj_sp;
 404     return return_valobj_sp;
 405 }
 406
 407 ValueObjectSP
 408 ABISysV_mips::GetReturnValueObjectImpl (Thread &thread, ClangASTType &return_clang_type) const
 409 {
 410     ValueObjectSP return_valobj_sp;
 411     Value value;
 412
 413     if (!return_clang_type)
 414         return return_valobj_sp;
 415
 416     ExecutionContext exe_ctx (thread.shared_from_this());
 417     if (exe_ctx.GetTargetPtr() == NULL || exe_ctx.GetProcessPtr() == NULL)
 418         return return_valobj_sp;
 419
 420     value.SetClangType(return_clang_type);
 421
 422     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 423     if (!reg_ctx)
 424         return return_valobj_sp;
 425
 426     bool is_signed;
 427
 428     // In MIPS register "r2" (v0) holds the integer function return values
 429     const RegisterInfo *r2_reg_info = reg_ctx->GetRegisterInfoByName("r2", 0);
 430
 431     if (return_clang_type.IsIntegerType (is_signed))
 432     {
 433         size_t bit_width = return_clang_type.GetBitSize(&thread);
 434
 435         switch (bit_width)
 436         {
 437             default:
 438                 return return_valobj_sp;
 439             case 64:
 440             {
 441                 const RegisterInfo *r3_reg_info = reg_ctx->GetRegisterInfoByName("r3", 0);
 442                 uint64_t raw_value;
 443                 raw_value = reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX;
 444                 raw_value |= ((uint64_t)(reg_ctx->ReadRegisterAsUnsigned(r3_reg_info, 0) & UINT32_MAX)) << 32;
 445                 if (is_signed)
 446                     value.GetScalar() = (int64_t)raw_value;
 447                 else
 448                     value.GetScalar() = (uint64_t)raw_value;
 449             }
 450                 break;
 451             case 32:
 452                 if (is_signed)
 453                     value.GetScalar() = (int32_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX);
 454                 else
 455                     value.GetScalar() = (uint32_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX);
 456                 break;
 457             case 16:
 458                 if (is_signed)
 459                     value.GetScalar() = (int16_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT16_MAX);
 460                 else
 461                     value.GetScalar() = (uint16_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT16_MAX);
 462                 break;
 463             case 8:
 464                 if (is_signed)
 465                     value.GetScalar() = (int8_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
 466                 else
 467                     value.GetScalar() = (uint8_t)(reg_ctx->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT8_MAX);
 468                 break;
 469         }
 470     }
 471     else if (return_clang_type.IsPointerType ())
 472     {
 473         uint32_t ptr = thread.GetRegisterContext()->ReadRegisterAsUnsigned(r2_reg_info, 0) & UINT32_MAX;
 474         value.GetScalar() = ptr;
 475     }
 476     else
 477     {
 478         // not handled yet
 479         return return_valobj_sp;
 480     }
 481
 482     // If we get here, we have a valid Value, so make our ValueObject out of it:
 483
 484     return_valobj_sp = ValueObjectConstResult::Create(thread.GetStackFrameAtIndex(0).get(),
 485                                                       value,
 486                                                       ConstString(""));
 487     return return_valobj_sp;
 488 }
 489
 490 bool
 491 ABISysV_mips::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
 492 {
 493     unwind_plan.Clear();
 494     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 495
 496     UnwindPlan::RowSP row(new UnwindPlan::Row);
 497
 498     // Our Call Frame Address is the stack pointer value
 499     row->GetCFAValue().SetIsRegisterPlusOffset(gcc_dwarf_r29, 0);
 500
 501     // The previous PC is in the RA
 502     row->SetRegisterLocationToRegister(gcc_dwarf_pc, gcc_dwarf_r31, true);
 503     unwind_plan.AppendRow (row);
 504
 505     // All other registers are the same.
 506
 507     unwind_plan.SetSourceName ("mips at-func-entry default");
 508     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
 509     unwind_plan.SetReturnAddressRegister(gcc_dwarf_r31);
 510     return true;
 511 }
 512
 513 bool
 514 ABISysV_mips::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
 515 {
 516     unwind_plan.Clear();
 517     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
 518
 519     UnwindPlan::RowSP row(new UnwindPlan::Row);
 520
 521     row->GetCFAValue().SetIsRegisterPlusOffset(gcc_dwarf_r29, 0);
 522
 523     row->SetRegisterLocationToRegister(gcc_dwarf_pc, gcc_dwarf_r31, true);
 524
 525     unwind_plan.AppendRow (row);
 526     unwind_plan.SetSourceName ("mips default unwind plan");
 527     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
 528     unwind_plan.SetUnwindPlanValidAtAllInstructions (eLazyBoolNo);
 529     return true;
 530 }
 531
 532 bool
 533 ABISysV_mips::RegisterIsVolatile (const RegisterInfo *reg_info)
 534 {
 535     return !RegisterIsCalleeSaved (reg_info);
 536 }
 537
 538 bool
 539 ABISysV_mips::RegisterIsCalleeSaved (const RegisterInfo *reg_info)
 540 {
 541     if (reg_info)
 542     {
 543         // Preserved registers are :
 544         // r16-r23, r28, r29, r30, r31
 545
 546         int reg = ((reg_info->byte_offset) / 4);
 547
 548         bool save  = (reg >= 16) && (reg <= 23);
 549              save |= (reg >= 28) && (reg <= 31);
 550
 551         return save;
 552     }
 553     return false;
 554 }
 555
 556 void
 557 ABISysV_mips::Initialize()
 558 {
 559     PluginManager::RegisterPlugin (GetPluginNameStatic(),
 560                                    "System V ABI for mips targets",
 561                                    CreateInstance);
 562 }
 563
 564 void
 565 ABISysV_mips::Terminate()
 566 {
 567     PluginManager::UnregisterPlugin (CreateInstance);
 568 }
 569
 570 lldb_private::ConstString
 571 ABISysV_mips::GetPluginNameStatic()
 572 {
 573     static ConstString g_name("sysv-mips");
 574     return g_name;
 575 }
 576
 577 //------------------------------------------------------------------
 578 // PluginInterface protocol
 579 //------------------------------------------------------------------
 580 lldb_private::ConstString
 581 ABISysV_mips::GetPluginName()
 582 {
 583     return GetPluginNameStatic();
 584 }
 585
 586 uint32_t
 587 ABISysV_mips::GetPluginVersion()
 588 {
 589     return 1;
 590 }