contrib/llvm/tools/lldb/source/Plugins/ABI/SysV-x86_64/ABISysV_x86_64.cpp

   1 //===-- ABISysV_x86_64.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_x86_64.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_rax = 0,
  40     gcc_dwarf_rdx,
  41     gcc_dwarf_rcx,
  42     gcc_dwarf_rbx,
  43     gcc_dwarf_rsi,
  44     gcc_dwarf_rdi,
  45     gcc_dwarf_rbp,
  46     gcc_dwarf_rsp,
  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_rip,
  56     gcc_dwarf_xmm0,
  57     gcc_dwarf_xmm1,
  58     gcc_dwarf_xmm2,
  59     gcc_dwarf_xmm3,
  60     gcc_dwarf_xmm4,
  61     gcc_dwarf_xmm5,
  62     gcc_dwarf_xmm6,
  63     gcc_dwarf_xmm7,
  64     gcc_dwarf_xmm8,
  65     gcc_dwarf_xmm9,
  66     gcc_dwarf_xmm10,
  67     gcc_dwarf_xmm11,
  68     gcc_dwarf_xmm12,
  69     gcc_dwarf_xmm13,
  70     gcc_dwarf_xmm14,
  71     gcc_dwarf_xmm15,
  72     gcc_dwarf_stmm0,
  73     gcc_dwarf_stmm1,
  74     gcc_dwarf_stmm2,
  75     gcc_dwarf_stmm3,
  76     gcc_dwarf_stmm4,
  77     gcc_dwarf_stmm5,
  78     gcc_dwarf_stmm6,
  79     gcc_dwarf_stmm7,
  80     gcc_dwarf_ymm0,
  81     gcc_dwarf_ymm1,
  82     gcc_dwarf_ymm2,
  83     gcc_dwarf_ymm3,
  84     gcc_dwarf_ymm4,
  85     gcc_dwarf_ymm5,
  86     gcc_dwarf_ymm6,
  87     gcc_dwarf_ymm7,
  88     gcc_dwarf_ymm8,
  89     gcc_dwarf_ymm9,
  90     gcc_dwarf_ymm10,
  91     gcc_dwarf_ymm11,
  92     gcc_dwarf_ymm12,
  93     gcc_dwarf_ymm13,
  94     gcc_dwarf_ymm14,
  95     gcc_dwarf_ymm15
  96 };
  97
  98 enum gdb_regnums
  99 {
 100     gdb_rax     =   0,
 101     gdb_rbx     =   1,
 102     gdb_rcx     =   2,
 103     gdb_rdx     =   3,
 104     gdb_rsi     =   4,
 105     gdb_rdi     =   5,
 106     gdb_rbp     =   6,
 107     gdb_rsp     =   7,
 108     gdb_r8      =   8,
 109     gdb_r9      =   9,
 110     gdb_r10     =  10,
 111     gdb_r11     =  11,
 112     gdb_r12     =  12,
 113     gdb_r13     =  13,
 114     gdb_r14     =  14,
 115     gdb_r15     =  15,
 116     gdb_rip     =  16,
 117     gdb_rflags  =  17,
 118     gdb_cs      =  18,
 119     gdb_ss      =  19,
 120     gdb_ds      =  20,
 121     gdb_es      =  21,
 122     gdb_fs      =  22,
 123     gdb_gs      =  23,
 124     gdb_stmm0   =  24,
 125     gdb_stmm1   =  25,
 126     gdb_stmm2   =  26,
 127     gdb_stmm3   =  27,
 128     gdb_stmm4   =  28,
 129     gdb_stmm5   =  29,
 130     gdb_stmm6   =  30,
 131     gdb_stmm7   =  31,
 132     gdb_fctrl   =  32,  gdb_fcw = gdb_fctrl,
 133     gdb_fstat   =  33,  gdb_fsw = gdb_fstat,
 134     gdb_ftag    =  34,  gdb_ftw = gdb_ftag,
 135     gdb_fiseg   =  35,  gdb_fpu_cs  = gdb_fiseg,
 136     gdb_fioff   =  36,  gdb_ip  = gdb_fioff,
 137     gdb_foseg   =  37,  gdb_fpu_ds  = gdb_foseg,
 138     gdb_fooff   =  38,  gdb_dp  = gdb_fooff,
 139     gdb_fop     =  39,
 140     gdb_xmm0    =  40,
 141     gdb_xmm1    =  41,
 142     gdb_xmm2    =  42,
 143     gdb_xmm3    =  43,
 144     gdb_xmm4    =  44,
 145     gdb_xmm5    =  45,
 146     gdb_xmm6    =  46,
 147     gdb_xmm7    =  47,
 148     gdb_xmm8    =  48,
 149     gdb_xmm9    =  49,
 150     gdb_xmm10   =  50,
 151     gdb_xmm11   =  51,
 152     gdb_xmm12   =  52,
 153     gdb_xmm13   =  53,
 154     gdb_xmm14   =  54,
 155     gdb_xmm15   =  55,
 156     gdb_mxcsr   =  56,
 157     gdb_ymm0    =  57,
 158     gdb_ymm1    =  58,
 159     gdb_ymm2    =  59,
 160     gdb_ymm3    =  60,
 161     gdb_ymm4    =  61,
 162     gdb_ymm5    =  62,
 163     gdb_ymm6    =  63,
 164     gdb_ymm7    =  64,
 165     gdb_ymm8    =  65,
 166     gdb_ymm9    =  66,
 167     gdb_ymm10   =  67,
 168     gdb_ymm11   =  68,
 169     gdb_ymm12   =  69,
 170     gdb_ymm13   =  70,
 171     gdb_ymm14   =  71,
 172     gdb_ymm15   =  72
 173 };
 174
 175
 176 static RegisterInfo g_register_infos[] =
 177 {
 178   //  NAME      ALT      SZ OFF ENCODING         FORMAT              COMPILER                DWARF                 GENERIC                     GDB                   LLDB NATIVE            VALUE REGS    INVALIDATE REGS
 179   //  ========  =======  == === =============    =================== ======================= ===================== =========================== ===================== ====================== ==========    ===============
 180     { "rax"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rax       , gcc_dwarf_rax       , LLDB_INVALID_REGNUM       , gdb_rax            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 181     { "rbx"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rbx       , gcc_dwarf_rbx       , LLDB_INVALID_REGNUM       , gdb_rbx            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 182     { "rcx"   , "arg4",  8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rcx       , gcc_dwarf_rcx       , LLDB_REGNUM_GENERIC_ARG4  , gdb_rcx            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 183     { "rdx"   , "arg3",  8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rdx       , gcc_dwarf_rdx       , LLDB_REGNUM_GENERIC_ARG3  , gdb_rdx            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 184     { "rsi"   , "arg2",  8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rsi       , gcc_dwarf_rsi       , LLDB_REGNUM_GENERIC_ARG2  , gdb_rsi            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 185     { "rdi"   , "arg1",  8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rdi       , gcc_dwarf_rdi       , LLDB_REGNUM_GENERIC_ARG1  , gdb_rdi            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 186     { "rbp"   , "fp",    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rbp       , gcc_dwarf_rbp       , LLDB_REGNUM_GENERIC_FP    , gdb_rbp            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 187     { "rsp"   , "sp",    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rsp       , gcc_dwarf_rsp       , LLDB_REGNUM_GENERIC_SP    , gdb_rsp            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 188     { "r8"    , "arg5",  8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r8        , gcc_dwarf_r8        , LLDB_REGNUM_GENERIC_ARG5  , gdb_r8             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 189     { "r9"    , "arg6",  8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r9        , gcc_dwarf_r9        , LLDB_REGNUM_GENERIC_ARG6  , gdb_r9             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 190     { "r10"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r10       , gcc_dwarf_r10       , LLDB_INVALID_REGNUM       , gdb_r10            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 191     { "r11"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r11       , gcc_dwarf_r11       , LLDB_INVALID_REGNUM       , gdb_r11            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 192     { "r12"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r12       , gcc_dwarf_r12       , LLDB_INVALID_REGNUM       , gdb_r12            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 193     { "r13"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r13       , gcc_dwarf_r13       , LLDB_INVALID_REGNUM       , gdb_r13            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 194     { "r14"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r14       , gcc_dwarf_r14       , LLDB_INVALID_REGNUM       , gdb_r14            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 195     { "r15"   , NULL,    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_r15       , gcc_dwarf_r15       , LLDB_INVALID_REGNUM       , gdb_r15            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 196     { "rip"   , "pc",    8,  0, eEncodingUint  , eFormatHex          , { gcc_dwarf_rip       , gcc_dwarf_rip       , LLDB_REGNUM_GENERIC_PC    , gdb_rip            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 197     { "rflags", NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_REGNUM_GENERIC_FLAGS , gdb_rflags         , LLDB_INVALID_REGNUM },      NULL,              NULL},
 198     { "cs"    , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_cs             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 199     { "ss"    , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_ss             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 200     { "ds"    , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_ds             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 201     { "es"    , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_es             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 202     { "fs"    , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fs             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 203     { "gs"    , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_gs             , LLDB_INVALID_REGNUM },      NULL,              NULL},
 204     { "stmm0" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm0     , gcc_dwarf_stmm0     , LLDB_INVALID_REGNUM       , gdb_stmm0          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 205     { "stmm1" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm1     , gcc_dwarf_stmm1     , LLDB_INVALID_REGNUM       , gdb_stmm1          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 206     { "stmm2" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm2     , gcc_dwarf_stmm2     , LLDB_INVALID_REGNUM       , gdb_stmm2          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 207     { "stmm3" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm3     , gcc_dwarf_stmm3     , LLDB_INVALID_REGNUM       , gdb_stmm3          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 208     { "stmm4" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm4     , gcc_dwarf_stmm4     , LLDB_INVALID_REGNUM       , gdb_stmm4          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 209     { "stmm5" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm5     , gcc_dwarf_stmm5     , LLDB_INVALID_REGNUM       , gdb_stmm5          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 210     { "stmm6" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm6     , gcc_dwarf_stmm6     , LLDB_INVALID_REGNUM       , gdb_stmm6          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 211     { "stmm7" , NULL,   10,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_stmm7     , gcc_dwarf_stmm7     , LLDB_INVALID_REGNUM       , gdb_stmm7          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 212     { "fctrl" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fctrl          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 213     { "fstat" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fstat          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 214     { "ftag"  , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_ftag           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 215     { "fiseg" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fiseg          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 216     { "fioff" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fioff          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 217     { "foseg" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_foseg          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 218     { "fooff" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fooff          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 219     { "fop"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_fop            , LLDB_INVALID_REGNUM },      NULL,              NULL},
 220     { "xmm0"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm0      , gcc_dwarf_xmm0      , LLDB_INVALID_REGNUM       , gdb_xmm0           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 221     { "xmm1"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm1      , gcc_dwarf_xmm1      , LLDB_INVALID_REGNUM       , gdb_xmm1           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 222     { "xmm2"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm2      , gcc_dwarf_xmm2      , LLDB_INVALID_REGNUM       , gdb_xmm2           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 223     { "xmm3"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm3      , gcc_dwarf_xmm3      , LLDB_INVALID_REGNUM       , gdb_xmm3           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 224     { "xmm4"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm4      , gcc_dwarf_xmm4      , LLDB_INVALID_REGNUM       , gdb_xmm4           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 225     { "xmm5"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm5      , gcc_dwarf_xmm5      , LLDB_INVALID_REGNUM       , gdb_xmm5           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 226     { "xmm6"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm6      , gcc_dwarf_xmm6      , LLDB_INVALID_REGNUM       , gdb_xmm6           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 227     { "xmm7"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm7      , gcc_dwarf_xmm7      , LLDB_INVALID_REGNUM       , gdb_xmm7           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 228     { "xmm8"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm8      , gcc_dwarf_xmm8      , LLDB_INVALID_REGNUM       , gdb_xmm8           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 229     { "xmm9"  , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm9      , gcc_dwarf_xmm9      , LLDB_INVALID_REGNUM       , gdb_xmm9           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 230     { "xmm10" , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm10     , gcc_dwarf_xmm10     , LLDB_INVALID_REGNUM       , gdb_xmm10          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 231     { "xmm11" , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm11     , gcc_dwarf_xmm11     , LLDB_INVALID_REGNUM       , gdb_xmm11          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 232     { "xmm12" , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm12     , gcc_dwarf_xmm12     , LLDB_INVALID_REGNUM       , gdb_xmm12          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 233     { "xmm13" , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm13     , gcc_dwarf_xmm13     , LLDB_INVALID_REGNUM       , gdb_xmm13          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 234     { "xmm14" , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm14     , gcc_dwarf_xmm14     , LLDB_INVALID_REGNUM       , gdb_xmm14          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 235     { "xmm15" , NULL,   16,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_xmm15     , gcc_dwarf_xmm15     , LLDB_INVALID_REGNUM       , gdb_xmm15          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 236     { "mxcsr" , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM       , gdb_mxcsr          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 237     { "ymm0"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm0      , gcc_dwarf_ymm0      , LLDB_INVALID_REGNUM       , gdb_ymm0           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 238     { "ymm1"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm1      , gcc_dwarf_ymm1      , LLDB_INVALID_REGNUM       , gdb_ymm1           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 239     { "ymm2"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm2      , gcc_dwarf_ymm2      , LLDB_INVALID_REGNUM       , gdb_ymm2           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 240     { "ymm3"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm3      , gcc_dwarf_ymm3      , LLDB_INVALID_REGNUM       , gdb_ymm3           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 241     { "ymm4"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm4      , gcc_dwarf_ymm4      , LLDB_INVALID_REGNUM       , gdb_ymm4           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 242     { "ymm5"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm5      , gcc_dwarf_ymm5      , LLDB_INVALID_REGNUM       , gdb_ymm5           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 243     { "ymm6"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm6      , gcc_dwarf_ymm6      , LLDB_INVALID_REGNUM       , gdb_ymm6           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 244     { "ymm7"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm7      , gcc_dwarf_ymm7      , LLDB_INVALID_REGNUM       , gdb_ymm7           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 245     { "ymm8"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm8      , gcc_dwarf_ymm8      , LLDB_INVALID_REGNUM       , gdb_ymm8           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 246     { "ymm9"  , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm9      , gcc_dwarf_ymm9      , LLDB_INVALID_REGNUM       , gdb_ymm9           , LLDB_INVALID_REGNUM },      NULL,              NULL},
 247     { "ymm10" , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm10     , gcc_dwarf_ymm10     , LLDB_INVALID_REGNUM       , gdb_ymm10          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 248     { "ymm11" , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm11     , gcc_dwarf_ymm11     , LLDB_INVALID_REGNUM       , gdb_ymm11          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 249     { "ymm12" , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm12     , gcc_dwarf_ymm12     , LLDB_INVALID_REGNUM       , gdb_ymm12          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 250     { "ymm13" , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm13     , gcc_dwarf_ymm13     , LLDB_INVALID_REGNUM       , gdb_ymm13          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 251     { "ymm14" , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm14     , gcc_dwarf_ymm14     , LLDB_INVALID_REGNUM       , gdb_ymm14          , LLDB_INVALID_REGNUM },      NULL,              NULL},
 252     { "ymm15" , NULL,   32,  0, eEncodingVector, eFormatVectorOfUInt8, { gcc_dwarf_ymm15     , gcc_dwarf_ymm15     , LLDB_INVALID_REGNUM       , gdb_ymm15          , LLDB_INVALID_REGNUM },      NULL,              NULL}
 253 };
 254
 255 static const uint32_t k_num_register_infos = llvm::array_lengthof(g_register_infos);
 256 static bool g_register_info_names_constified = false;
 257
 258 const lldb_private::RegisterInfo *
 259 ABISysV_x86_64::GetRegisterInfoArray (uint32_t &count)
 260 {
 261     // Make the C-string names and alt_names for the register infos into const
 262     // C-string values by having the ConstString unique the names in the global
 263     // constant C-string pool.
 264     if (!g_register_info_names_constified)
 265     {
 266         g_register_info_names_constified = true;
 267         for (uint32_t i=0; i<k_num_register_infos; ++i)
 268         {
 269             if (g_register_infos[i].name)
 270                 g_register_infos[i].name = ConstString(g_register_infos[i].name).GetCString();
 271             if (g_register_infos[i].alt_name)
 272                 g_register_infos[i].alt_name = ConstString(g_register_infos[i].alt_name).GetCString();
 273         }
 274     }
 275     count = k_num_register_infos;
 276     return g_register_infos;
 277 }
 278
 279
 280 size_t
 281 ABISysV_x86_64::GetRedZoneSize () const
 282 {
 283     return 128;
 284 }
 285
 286 //------------------------------------------------------------------
 287 // Static Functions
 288 //------------------------------------------------------------------
 289 ABISP
 290 ABISysV_x86_64::CreateInstance (const ArchSpec &arch)
 291 {
 292     static ABISP g_abi_sp;
 293     if (arch.GetTriple().getArch() == llvm::Triple::x86_64)
 294     {
 295         if (!g_abi_sp)
 296             g_abi_sp.reset (new ABISysV_x86_64);
 297         return g_abi_sp;
 298     }
 299     return ABISP();
 300 }
 301
 302 bool
 303 ABISysV_x86_64::PrepareTrivialCall (Thread &thread,
 304                                     addr_t sp,
 305                                     addr_t func_addr,
 306                                     addr_t return_addr,
 307                                     llvm::ArrayRef<addr_t> args) const
 308 {
 309     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 310
 311     if (log)
 312     {
 313         StreamString s;
 314         s.Printf("ABISysV_x86_64::PrepareTrivialCall (tid = 0x%" PRIx64 ", sp = 0x%" PRIx64 ", func_addr = 0x%" PRIx64 ", return_addr = 0x%" PRIx64,
 315                     thread.GetID(),
 316                     (uint64_t)sp,
 317                     (uint64_t)func_addr,
 318                     (uint64_t)return_addr);
 319
 320         for (size_t i = 0; i < args.size(); ++i)
 321             s.Printf (", arg%zd = 0x%" PRIx64, i + 1, args[i]);
 322         s.PutCString (")");
 323         log->PutCString(s.GetString().c_str());
 324     }
 325
 326     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 327     if (!reg_ctx)
 328         return false;
 329
 330     const RegisterInfo *reg_info = NULL;
 331
 332     if (args.size() > 6) // TODO handle more than 6 arguments
 333         return false;
 334
 335     for (size_t i = 0; i < args.size(); ++i)
 336     {
 337         reg_info = reg_ctx->GetRegisterInfo(eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1 + i);
 338         if (log)
 339             log->Printf("About to write arg%zd (0x%" PRIx64 ") into %s", i + 1, args[i], reg_info->name);
 340         if (!reg_ctx->WriteRegisterFromUnsigned(reg_info, args[i]))
 341             return false;
 342     }
 343
 344     // First, align the SP
 345
 346     if (log)
 347         log->Printf("16-byte aligning SP: 0x%" PRIx64 " to 0x%" PRIx64, (uint64_t)sp, (uint64_t)(sp & ~0xfull));
 348
 349     sp &= ~(0xfull); // 16-byte alignment
 350
 351     sp -= 8;
 352
 353     Error error;
 354     const RegisterInfo *pc_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
 355     const RegisterInfo *sp_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
 356     ProcessSP process_sp (thread.GetProcess());
 357
 358     RegisterValue reg_value;
 359
 360 #if 0
 361     // This code adds an extra frame so that we don't lose the function that we came from
 362     // by pushing the PC and the FP and then writing the current FP to point to the FP value
 363     // we just pushed. It is disabled for now until the stack backtracing code can be debugged.
 364
 365     // Save current PC
 366     const RegisterInfo *fp_reg_info = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP);
 367     if (reg_ctx->ReadRegister(pc_reg_info, reg_value))
 368     {
 369         if (log)
 370             log->Printf("Pushing the current PC onto the stack: 0x%" PRIx64 ": 0x%" PRIx64, (uint64_t)sp, reg_value.GetAsUInt64());
 371
 372         if (!process_sp->WritePointerToMemory(sp, reg_value.GetAsUInt64(), error))
 373             return false;
 374
 375         sp -= 8;
 376
 377         // Save current FP
 378         if (reg_ctx->ReadRegister(fp_reg_info, reg_value))
 379         {
 380             if (log)
 381                 log->Printf("Pushing the current FP onto the stack: 0x%" PRIx64 ": 0x%" PRIx64, (uint64_t)sp, reg_value.GetAsUInt64());
 382
 383             if (!process_sp->WritePointerToMemory(sp, reg_value.GetAsUInt64(), error))
 384                 return false;
 385         }
 386         // Setup FP backchain
 387         reg_value.SetUInt64 (sp);
 388
 389         if (log)
 390             log->Printf("Writing FP:  0x%" PRIx64 " (for FP backchain)", reg_value.GetAsUInt64());
 391
 392         if (!reg_ctx->WriteRegister(fp_reg_info, reg_value))
 393         {
 394             return false;
 395         }
 396
 397         sp -= 8;
 398     }
 399 #endif
 400
 401     if (log)
 402         log->Printf("Pushing the return address onto the stack: 0x%" PRIx64 ": 0x%" PRIx64, (uint64_t)sp, (uint64_t)return_addr);
 403
 404     // Save return address onto the stack
 405     if (!process_sp->WritePointerToMemory(sp, return_addr, error))
 406         return false;
 407
 408     // %rsp is set to the actual stack value.
 409
 410     if (log)
 411         log->Printf("Writing SP: 0x%" PRIx64, (uint64_t)sp);
 412
 413     if (!reg_ctx->WriteRegisterFromUnsigned (sp_reg_info, sp))
 414         return false;
 415
 416     // %rip is set to the address of the called function.
 417
 418     if (log)
 419         log->Printf("Writing IP: 0x%" PRIx64, (uint64_t)func_addr);
 420
 421     if (!reg_ctx->WriteRegisterFromUnsigned (pc_reg_info, func_addr))
 422         return false;
 423
 424     return true;
 425 }
 426
 427 static bool ReadIntegerArgument(Scalar           &scalar,
 428                                 unsigned int     bit_width,
 429                                 bool             is_signed,
 430                                 Thread           &thread,
 431                                 uint32_t         *argument_register_ids,
 432                                 unsigned int     &current_argument_register,
 433                                 addr_t           &current_stack_argument)
 434 {
 435     if (bit_width > 64)
 436         return false; // Scalar can't hold large integer arguments
 437
 438     if (current_argument_register < 6)
 439     {
 440         scalar = thread.GetRegisterContext()->ReadRegisterAsUnsigned(argument_register_ids[current_argument_register], 0);
 441         current_argument_register++;
 442         if (is_signed)
 443             scalar.SignExtend (bit_width);
 444     }
 445     else
 446     {
 447         uint32_t byte_size = (bit_width + (8-1))/8;
 448         Error error;
 449         if (thread.GetProcess()->ReadScalarIntegerFromMemory(current_stack_argument, byte_size, is_signed, scalar, error))
 450         {
 451             current_stack_argument += byte_size;
 452             return true;
 453         }
 454         return false;
 455     }
 456     return true;
 457 }
 458
 459 bool
 460 ABISysV_x86_64::GetArgumentValues (Thread &thread,
 461                                    ValueList &values) const
 462 {
 463     unsigned int num_values = values.GetSize();
 464     unsigned int value_index;
 465
 466     // Extract the register context so we can read arguments from registers
 467
 468     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 469
 470     if (!reg_ctx)
 471         return false;
 472
 473     // Get the pointer to the first stack argument so we have a place to start
 474     // when reading data
 475
 476     addr_t sp = reg_ctx->GetSP(0);
 477
 478     if (!sp)
 479         return false;
 480
 481     addr_t current_stack_argument = sp + 8; // jump over return address
 482
 483     uint32_t argument_register_ids[6];
 484
 485     argument_register_ids[0] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG1)->kinds[eRegisterKindLLDB];
 486     argument_register_ids[1] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG2)->kinds[eRegisterKindLLDB];
 487     argument_register_ids[2] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG3)->kinds[eRegisterKindLLDB];
 488     argument_register_ids[3] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG4)->kinds[eRegisterKindLLDB];
 489     argument_register_ids[4] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG5)->kinds[eRegisterKindLLDB];
 490     argument_register_ids[5] = reg_ctx->GetRegisterInfo (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_ARG6)->kinds[eRegisterKindLLDB];
 491
 492     unsigned int current_argument_register = 0;
 493
 494     for (value_index = 0;
 495          value_index < num_values;
 496          ++value_index)
 497     {
 498         Value *value = values.GetValueAtIndex(value_index);
 499
 500         if (!value)
 501             return false;
 502
 503         // We currently only support extracting values with Clang QualTypes.
 504         // Do we care about others?
 505         ClangASTType clang_type = value->GetClangType();
 506         if (!clang_type)
 507             return false;
 508         bool is_signed;
 509
 510         if (clang_type.IsIntegerType (is_signed))
 511         {
 512             ReadIntegerArgument(value->GetScalar(),
 513                                 clang_type.GetBitSize(),
 514                                 is_signed,
 515                                 thread,
 516                                 argument_register_ids,
 517                                 current_argument_register,
 518                                 current_stack_argument);
 519         }
 520         else if (clang_type.IsPointerType ())
 521         {
 522             ReadIntegerArgument(value->GetScalar(),
 523                                 clang_type.GetBitSize(),
 524                                 false,
 525                                 thread,
 526                                 argument_register_ids,
 527                                 current_argument_register,
 528                                 current_stack_argument);
 529         }
 530     }
 531
 532     return true;
 533 }
 534
 535 Error
 536 ABISysV_x86_64::SetReturnValueObject(lldb::StackFrameSP &frame_sp, lldb::ValueObjectSP &new_value_sp)
 537 {
 538     Error error;
 539     if (!new_value_sp)
 540     {
 541         error.SetErrorString("Empty value object for return value.");
 542         return error;
 543     }
 544
 545     ClangASTType clang_type = new_value_sp->GetClangType();
 546     if (!clang_type)
 547     {
 548         error.SetErrorString ("Null clang type for return value.");
 549         return error;
 550     }
 551
 552     Thread *thread = frame_sp->GetThread().get();
 553
 554     bool is_signed;
 555     uint32_t count;
 556     bool is_complex;
 557
 558     RegisterContext *reg_ctx = thread->GetRegisterContext().get();
 559
 560     bool set_it_simple = false;
 561     if (clang_type.IsIntegerType (is_signed) || clang_type.IsPointerType())
 562     {
 563         const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName("rax", 0);
 564
 565         DataExtractor data;
 566         Error data_error;
 567         size_t num_bytes = new_value_sp->GetData(data, data_error);
 568         if (data_error.Fail())
 569         {
 570             error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
 571             return error;
 572         }
 573         lldb::offset_t offset = 0;
 574         if (num_bytes <= 8)
 575         {
 576             uint64_t raw_value = data.GetMaxU64(&offset, num_bytes);
 577
 578             if (reg_ctx->WriteRegisterFromUnsigned (reg_info, raw_value))
 579                 set_it_simple = true;
 580         }
 581         else
 582         {
 583             error.SetErrorString("We don't support returning longer than 64 bit integer values at present.");
 584         }
 585
 586     }
 587     else if (clang_type.IsFloatingPointType (count, is_complex))
 588     {
 589         if (is_complex)
 590             error.SetErrorString ("We don't support returning complex values at present");
 591         else
 592         {
 593             size_t bit_width = clang_type.GetBitSize();
 594             if (bit_width <= 64)
 595             {
 596                 const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0);
 597                 RegisterValue xmm0_value;
 598                 DataExtractor data;
 599                 Error data_error;
 600                 size_t num_bytes = new_value_sp->GetData(data, data_error);
 601                 if (data_error.Fail())
 602                 {
 603                     error.SetErrorStringWithFormat("Couldn't convert return value to raw data: %s", data_error.AsCString());
 604                     return error;
 605                 }
 606
 607                 unsigned char buffer[16];
 608                 ByteOrder byte_order = data.GetByteOrder();
 609
 610                 data.CopyByteOrderedData (0, num_bytes, buffer, 16, byte_order);
 611                 xmm0_value.SetBytes(buffer, 16, byte_order);
 612                 reg_ctx->WriteRegister(xmm0_info, xmm0_value);
 613                 set_it_simple = true;
 614             }
 615             else
 616             {
 617                 // FIXME - don't know how to do 80 bit long doubles yet.
 618                 error.SetErrorString ("We don't support returning float values > 64 bits at present");
 619             }
 620         }
 621     }
 622
 623     if (!set_it_simple)
 624     {
 625         // Okay we've got a structure or something that doesn't fit in a simple register.
 626         // We should figure out where it really goes, but we don't support this yet.
 627         error.SetErrorString ("We only support setting simple integer and float return types at present.");
 628     }
 629
 630     return error;
 631 }
 632
 633
 634 ValueObjectSP
 635 ABISysV_x86_64::GetReturnValueObjectSimple (Thread &thread,
 636                                             ClangASTType &return_clang_type) const
 637 {
 638     ValueObjectSP return_valobj_sp;
 639     Value value;
 640
 641     if (!return_clang_type)
 642         return return_valobj_sp;
 643
 644     //value.SetContext (Value::eContextTypeClangType, return_value_type);
 645     value.SetClangType (return_clang_type);
 646
 647     RegisterContext *reg_ctx = thread.GetRegisterContext().get();
 648     if (!reg_ctx)
 649         return return_valobj_sp;
 650
 651     const uint32_t type_flags = return_clang_type.GetTypeInfo ();
 652     if (type_flags & ClangASTType::eTypeIsScalar)
 653     {
 654         value.SetValueType(Value::eValueTypeScalar);
 655
 656         bool success = false;
 657         if (type_flags & ClangASTType::eTypeIsInteger)
 658         {
 659             // Extract the register context so we can read arguments from registers
 660
 661             const size_t byte_size = return_clang_type.GetByteSize();
 662             uint64_t raw_value = thread.GetRegisterContext()->ReadRegisterAsUnsigned(reg_ctx->GetRegisterInfoByName("rax", 0), 0);
 663             const bool is_signed = (type_flags & ClangASTType::eTypeIsSigned) != 0;
 664             switch (byte_size)
 665             {
 666             default:
 667                 break;
 668
 669             case sizeof(uint64_t):
 670                 if (is_signed)
 671                     value.GetScalar() = (int64_t)(raw_value);
 672                 else
 673                     value.GetScalar() = (uint64_t)(raw_value);
 674                 success = true;
 675                 break;
 676
 677             case sizeof(uint32_t):
 678                 if (is_signed)
 679                     value.GetScalar() = (int32_t)(raw_value & UINT32_MAX);
 680                 else
 681                     value.GetScalar() = (uint32_t)(raw_value & UINT32_MAX);
 682                 success = true;
 683                 break;
 684
 685             case sizeof(uint16_t):
 686                 if (is_signed)
 687                     value.GetScalar() = (int16_t)(raw_value & UINT16_MAX);
 688                 else
 689                     value.GetScalar() = (uint16_t)(raw_value & UINT16_MAX);
 690                 success = true;
 691                 break;
 692
 693             case sizeof(uint8_t):
 694                 if (is_signed)
 695                     value.GetScalar() = (int8_t)(raw_value & UINT8_MAX);
 696                 else
 697                     value.GetScalar() = (uint8_t)(raw_value & UINT8_MAX);
 698                 success = true;
 699                 break;
 700             }
 701         }
 702         else if (type_flags & ClangASTType::eTypeIsFloat)
 703         {
 704             if (type_flags & ClangASTType::eTypeIsComplex)
 705             {
 706                 // Don't handle complex yet.
 707             }
 708             else
 709             {
 710                 const size_t byte_size = return_clang_type.GetByteSize();
 711                 if (byte_size <= sizeof(long double))
 712                 {
 713                     const RegisterInfo *xmm0_info = reg_ctx->GetRegisterInfoByName("xmm0", 0);
 714                     RegisterValue xmm0_value;
 715                     if (reg_ctx->ReadRegister (xmm0_info, xmm0_value))
 716                     {
 717                         DataExtractor data;
 718                         if (xmm0_value.GetData(data))
 719                         {
 720                             lldb::offset_t offset = 0;
 721                             if (byte_size == sizeof(float))
 722                             {
 723                                 value.GetScalar() = (float) data.GetFloat(&offset);
 724                                 success = true;
 725                             }
 726                             else if (byte_size == sizeof(double))
 727                             {
 728                                 value.GetScalar() = (double) data.GetDouble(&offset);
 729                                 success = true;
 730                             }
 731                             else if (byte_size == sizeof(long double))
 732                             {
 733                                 // Don't handle long double since that can be encoded as 80 bit floats...
 734                             }
 735                         }
 736                     }
 737                 }
 738             }
 739         }
 740
 741         if (success)
 742             return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
 743                                                                value,
 744                                                                ConstString(""));
 745
 746     }
 747     else if (type_flags & ClangASTType::eTypeIsPointer)
 748     {
 749         unsigned rax_id = reg_ctx->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
 750         value.GetScalar() = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id, 0);
 751         value.SetValueType(Value::eValueTypeScalar);
 752         return_valobj_sp = ValueObjectConstResult::Create (thread.GetStackFrameAtIndex(0).get(),
 753                                                            value,
 754                                                            ConstString(""));
 755     }
 756     else if (type_flags & ClangASTType::eTypeIsVector)
 757     {
 758         const size_t byte_size = return_clang_type.GetByteSize();
 759         if (byte_size > 0)
 760         {
 761
 762             const RegisterInfo *altivec_reg = reg_ctx->GetRegisterInfoByName("ymm0", 0);
 763             if (altivec_reg == NULL)
 764             {
 765                 altivec_reg = reg_ctx->GetRegisterInfoByName("xmm0", 0);
 766                 if (altivec_reg == NULL)
 767                     altivec_reg = reg_ctx->GetRegisterInfoByName("mm0", 0);
 768             }
 769
 770             if (altivec_reg)
 771             {
 772                 if (byte_size <= altivec_reg->byte_size)
 773                 {
 774                     ProcessSP process_sp (thread.GetProcess());
 775                     if (process_sp)
 776                     {
 777                         std::unique_ptr<DataBufferHeap> heap_data_ap (new DataBufferHeap(byte_size, 0));
 778                         const ByteOrder byte_order = process_sp->GetByteOrder();
 779                         RegisterValue reg_value;
 780                         if (reg_ctx->ReadRegister(altivec_reg, reg_value))
 781                         {
 782                             Error error;
 783                             if (reg_value.GetAsMemoryData (altivec_reg,
 784                                                            heap_data_ap->GetBytes(),
 785                                                            heap_data_ap->GetByteSize(),
 786                                                            byte_order,
 787                                                            error))
 788                             {
 789                                 DataExtractor data (DataBufferSP (heap_data_ap.release()),
 790                                                     byte_order,
 791                                                     process_sp->GetTarget().GetArchitecture().GetAddressByteSize());
 792                                 return_valobj_sp = ValueObjectConstResult::Create (&thread,
 793                                                                                    return_clang_type,
 794                                                                                    ConstString(""),
 795                                                                                    data);
 796                             }
 797                         }
 798                     }
 799                 }
 800             }
 801         }
 802     }
 803
 804     return return_valobj_sp;
 805 }
 806
 807 ValueObjectSP
 808 ABISysV_x86_64::GetReturnValueObjectImpl (Thread &thread, ClangASTType &return_clang_type) const
 809 {
 810     ValueObjectSP return_valobj_sp;
 811
 812     if (!return_clang_type)
 813         return return_valobj_sp;
 814
 815     ExecutionContext exe_ctx (thread.shared_from_this());
 816     return_valobj_sp = GetReturnValueObjectSimple(thread, return_clang_type);
 817     if (return_valobj_sp)
 818         return return_valobj_sp;
 819
 820     RegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
 821     if (!reg_ctx_sp)
 822         return return_valobj_sp;
 823
 824     const size_t bit_width = return_clang_type.GetBitSize();
 825     if (return_clang_type.IsAggregateType())
 826     {
 827         Target *target = exe_ctx.GetTargetPtr();
 828         bool is_memory = true;
 829         if (bit_width <= 128)
 830         {
 831             ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder();
 832             DataBufferSP data_sp (new DataBufferHeap(16, 0));
 833             DataExtractor return_ext (data_sp,
 834                                       target_byte_order,
 835                                       target->GetArchitecture().GetAddressByteSize());
 836
 837             const RegisterInfo *rax_info = reg_ctx_sp->GetRegisterInfoByName("rax", 0);
 838             const RegisterInfo *rdx_info = reg_ctx_sp->GetRegisterInfoByName("rdx", 0);
 839             const RegisterInfo *xmm0_info = reg_ctx_sp->GetRegisterInfoByName("xmm0", 0);
 840             const RegisterInfo *xmm1_info = reg_ctx_sp->GetRegisterInfoByName("xmm1", 0);
 841
 842             RegisterValue rax_value, rdx_value, xmm0_value, xmm1_value;
 843             reg_ctx_sp->ReadRegister (rax_info, rax_value);
 844             reg_ctx_sp->ReadRegister (rdx_info, rdx_value);
 845             reg_ctx_sp->ReadRegister (xmm0_info, xmm0_value);
 846             reg_ctx_sp->ReadRegister (xmm1_info, xmm1_value);
 847
 848             DataExtractor rax_data, rdx_data, xmm0_data, xmm1_data;
 849
 850             rax_value.GetData(rax_data);
 851             rdx_value.GetData(rdx_data);
 852             xmm0_value.GetData(xmm0_data);
 853             xmm1_value.GetData(xmm1_data);
 854
 855             uint32_t fp_bytes = 0;       // Tracks how much of the xmm registers we've consumed so far
 856             uint32_t integer_bytes = 0;  // Tracks how much of the rax/rds registers we've consumed so far
 857
 858             const uint32_t num_children = return_clang_type.GetNumFields ();
 859
 860             // Since we are in the small struct regime, assume we are not in memory.
 861             is_memory = false;
 862
 863             for (uint32_t idx = 0; idx < num_children; idx++)
 864             {
 865                 std::string name;
 866                 uint64_t field_bit_offset = 0;
 867                 bool is_signed;
 868                 bool is_complex;
 869                 uint32_t count;
 870
 871                 ClangASTType field_clang_type = return_clang_type.GetFieldAtIndex (idx, name, &field_bit_offset, NULL, NULL);
 872                 const size_t field_bit_width = field_clang_type.GetBitSize();
 873
 874                 // If there are any unaligned fields, this is stored in memory.
 875                 if (field_bit_offset % field_bit_width != 0)
 876                 {
 877                     is_memory = true;
 878                     break;
 879                 }
 880
 881                 uint32_t field_byte_width = field_bit_width/8;
 882                 uint32_t field_byte_offset = field_bit_offset/8;
 883
 884
 885                 DataExtractor *copy_from_extractor = NULL;
 886                 uint32_t       copy_from_offset    = 0;
 887
 888                 if (field_clang_type.IsIntegerType (is_signed) || field_clang_type.IsPointerType ())
 889                 {
 890                     if (integer_bytes < 8)
 891                     {
 892                         if (integer_bytes + field_byte_width <= 8)
 893                         {
 894                             // This is in RAX, copy from register to our result structure:
 895                             copy_from_extractor = &rax_data;
 896                             copy_from_offset = integer_bytes;
 897                             integer_bytes += field_byte_width;
 898                         }
 899                         else
 900                         {
 901                             // The next field wouldn't fit in the remaining space, so we pushed it to rdx.
 902                             copy_from_extractor = &rdx_data;
 903                             copy_from_offset = 0;
 904                             integer_bytes = 8 + field_byte_width;
 905
 906                         }
 907                     }
 908                     else if (integer_bytes + field_byte_width <= 16)
 909                     {
 910                         copy_from_extractor = &rdx_data;
 911                         copy_from_offset = integer_bytes - 8;
 912                         integer_bytes += field_byte_width;
 913                     }
 914                     else
 915                     {
 916                         // The last field didn't fit.  I can't see how that would happen w/o the overall size being
 917                         // greater than 16 bytes.  For now, return a NULL return value object.
 918                         return return_valobj_sp;
 919                     }
 920                 }
 921                 else if (field_clang_type.IsFloatingPointType (count, is_complex))
 922                 {
 923                     // Structs with long doubles are always passed in memory.
 924                     if (field_bit_width == 128)
 925                     {
 926                         is_memory = true;
 927                         break;
 928                     }
 929                     else if (field_bit_width == 64)
 930                     {
 931                         // These have to be in a single xmm register.
 932                         if (fp_bytes == 0)
 933                             copy_from_extractor = &xmm0_data;
 934                         else
 935                             copy_from_extractor = &xmm1_data;
 936
 937                         copy_from_offset = 0;
 938                         fp_bytes += field_byte_width;
 939                     }
 940                     else if (field_bit_width == 32)
 941                     {
 942                         // This one is kind of complicated.  If we are in an "eightbyte" with another float, we'll
 943                         // be stuffed into an xmm register with it.  If we are in an "eightbyte" with one or more ints,
 944                         // then we will be stuffed into the appropriate GPR with them.
 945                         bool in_gpr;
 946                         if (field_byte_offset % 8 == 0)
 947                         {
 948                             // We are at the beginning of one of the eightbytes, so check the next element (if any)
 949                             if (idx == num_children - 1)
 950                                 in_gpr = false;
 951                             else
 952                             {
 953                                 uint64_t next_field_bit_offset = 0;
 954                                 ClangASTType next_field_clang_type = return_clang_type.GetFieldAtIndex (idx + 1,
 955                                                                                                         name,
 956                                                                                                         &next_field_bit_offset,
 957                                                                                                         NULL,
 958                                                                                                         NULL);
 959                                 if (next_field_clang_type.IsIntegerType (is_signed))
 960                                     in_gpr = true;
 961                                 else
 962                                 {
 963                                     copy_from_offset = 0;
 964                                     in_gpr = false;
 965                                 }
 966                             }
 967
 968                         }
 969                         else if (field_byte_offset % 4 == 0)
 970                         {
 971                             // We are inside of an eightbyte, so see if the field before us is floating point:
 972                             // This could happen if somebody put padding in the structure.
 973                             if (idx == 0)
 974                                 in_gpr = false;
 975                             else
 976                             {
 977                                 uint64_t prev_field_bit_offset = 0;
 978                                 ClangASTType prev_field_clang_type = return_clang_type.GetFieldAtIndex (idx - 1,
 979                                                                                                         name,
 980                                                                                                         &prev_field_bit_offset,
 981                                                                                                         NULL,
 982                                                                                                         NULL);
 983                                 if (prev_field_clang_type.IsIntegerType (is_signed))
 984                                     in_gpr = true;
 985                                 else
 986                                 {
 987                                     copy_from_offset = 4;
 988                                     in_gpr = false;
 989                                 }
 990                             }
 991
 992                         }
 993                         else
 994                         {
 995                             is_memory = true;
 996                             continue;
 997                         }
 998
 999                         // Okay, we've figured out whether we are in GPR or XMM, now figure out which one.
1000                         if (in_gpr)
1001                         {
1002                             if (integer_bytes < 8)
1003                             {
1004                                 // This is in RAX, copy from register to our result structure:
1005                                 copy_from_extractor = &rax_data;
1006                                 copy_from_offset = integer_bytes;
1007                                 integer_bytes += field_byte_width;
1008                             }
1009                             else
1010                             {
1011                                 copy_from_extractor = &rdx_data;
1012                                 copy_from_offset = integer_bytes - 8;
1013                                 integer_bytes += field_byte_width;
1014                             }
1015                         }
1016                         else
1017                         {
1018                             if (fp_bytes < 8)
1019                                 copy_from_extractor = &xmm0_data;
1020                             else
1021                                 copy_from_extractor = &xmm1_data;
1022
1023                             fp_bytes += field_byte_width;
1024                         }
1025                     }
1026                 }
1027
1028                 // These two tests are just sanity checks.  If I somehow get the
1029                 // type calculation wrong above it is better to just return nothing
1030                 // than to assert or crash.
1031                 if (!copy_from_extractor)
1032                     return return_valobj_sp;
1033                 if (copy_from_offset + field_byte_width > copy_from_extractor->GetByteSize())
1034                     return return_valobj_sp;
1035
1036                 copy_from_extractor->CopyByteOrderedData (copy_from_offset,
1037                                                           field_byte_width,
1038                                                           data_sp->GetBytes() + field_byte_offset,
1039                                                           field_byte_width,
1040                                                           target_byte_order);
1041             }
1042
1043             if (!is_memory)
1044             {
1045                 // The result is in our data buffer.  Let's make a variable object out of it:
1046                 return_valobj_sp = ValueObjectConstResult::Create (&thread,
1047                                                                    return_clang_type,
1048                                                                    ConstString(""),
1049                                                                    return_ext);
1050             }
1051         }
1052
1053
1054         // FIXME: This is just taking a guess, rax may very well no longer hold the return storage location.
1055         // If we are going to do this right, when we make a new frame we should check to see if it uses a memory
1056         // return, and if we are at the first instruction and if so stash away the return location.  Then we would
1057         // only return the memory return value if we know it is valid.
1058
1059         if (is_memory)
1060         {
1061             unsigned rax_id = reg_ctx_sp->GetRegisterInfoByName("rax", 0)->kinds[eRegisterKindLLDB];
1062             lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(rax_id, 0);
1063             return_valobj_sp = ValueObjectMemory::Create (&thread,
1064                                                           "",
1065                                                           Address (storage_addr, NULL),
1066                                                           return_clang_type);
1067         }
1068     }
1069
1070     return return_valobj_sp;
1071 }
1072
1073 bool
1074 ABISysV_x86_64::CreateFunctionEntryUnwindPlan (UnwindPlan &unwind_plan)
1075 {
1076     unwind_plan.Clear();
1077     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
1078
1079     uint32_t sp_reg_num = gcc_dwarf_rsp;
1080     uint32_t pc_reg_num = gcc_dwarf_rip;
1081
1082     UnwindPlan::RowSP row(new UnwindPlan::Row);
1083     row->SetCFARegister (sp_reg_num);
1084     row->SetCFAOffset (8);
1085     row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, -8, false);
1086     unwind_plan.AppendRow (row);
1087     unwind_plan.SetSourceName ("x86_64 at-func-entry default");
1088     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
1089     return true;
1090 }
1091
1092 bool
1093 ABISysV_x86_64::CreateDefaultUnwindPlan (UnwindPlan &unwind_plan)
1094 {
1095     unwind_plan.Clear();
1096     unwind_plan.SetRegisterKind (eRegisterKindDWARF);
1097
1098     uint32_t fp_reg_num = gcc_dwarf_rbp;
1099     uint32_t sp_reg_num = gcc_dwarf_rsp;
1100     uint32_t pc_reg_num = gcc_dwarf_rip;
1101
1102     UnwindPlan::RowSP row(new UnwindPlan::Row);
1103
1104     const int32_t ptr_size = 8;
1105     row->SetCFARegister (gcc_dwarf_rbp);
1106     row->SetCFAOffset (2 * ptr_size);
1107     row->SetOffset (0);
1108
1109     row->SetRegisterLocationToAtCFAPlusOffset(fp_reg_num, ptr_size * -2, true);
1110     row->SetRegisterLocationToAtCFAPlusOffset(pc_reg_num, ptr_size * -1, true);
1111     row->SetRegisterLocationToIsCFAPlusOffset(sp_reg_num, 0, true);
1112
1113     unwind_plan.AppendRow (row);
1114     unwind_plan.SetSourceName ("x86_64 default unwind plan");
1115     unwind_plan.SetSourcedFromCompiler (eLazyBoolNo);
1116     unwind_plan.SetUnwindPlanValidAtAllInstructions (eLazyBoolNo);
1117     return true;
1118 }
1119
1120 bool
1121 ABISysV_x86_64::RegisterIsVolatile (const RegisterInfo *reg_info)
1122 {
1123     return !RegisterIsCalleeSaved (reg_info);
1124 }
1125
1126
1127
1128 // See "Register Usage" in the
1129 // "System V Application Binary Interface"
1130 // "AMD64 Architecture Processor Supplement"
1131 // (or "x86-64(tm) Architecture Processor Supplement" in earlier revisions)
1132 // (this doc is also commonly referred to as the x86-64/AMD64 psABI)
1133 // Edited by Michael Matz, Jan Hubicka, Andreas Jaeger, and Mark Mitchell
1134 // current version is 0.99.6 released 2012-07-02 at http://refspecs.linuxfoundation.org/elf/x86-64-abi-0.99.pdf
1135
1136 bool
1137 ABISysV_x86_64::RegisterIsCalleeSaved (const RegisterInfo *reg_info)
1138 {
1139     if (reg_info)
1140     {
1141         // Preserved registers are :
1142         //    rbx, rsp, rbp, r12, r13, r14, r15
1143         //    mxcsr (partially preserved)
1144         //    x87 control word
1145
1146         const char *name = reg_info->name;
1147         if (name[0] == 'r')
1148         {
1149             switch (name[1])
1150             {
1151             case '1': // r12, r13, r14, r15
1152                 if (name[2] >= '2' && name[2] <= '5')
1153                     return name[3] == '\0';
1154                 break;
1155
1156             default:
1157                 break;
1158             }
1159         }
1160
1161         // Accept shorter-variant versions, rbx/ebx, rip/ eip, etc.
1162         if (name[0] == 'r' || name[0] == 'e')
1163         {
1164             switch (name[1])
1165             {
1166             case 'b': // rbp, rbx
1167                 if (name[2] == 'p' || name[2] == 'x')
1168                     return name[3] == '\0';
1169                 break;
1170
1171             case 'i': // rip
1172                 if (name[2] == 'p')
1173                     return name[3] == '\0';
1174                 break;
1175
1176             case 's': // rsp
1177                 if (name[2] == 'p')
1178                     return name[3] == '\0';
1179                 break;
1180
1181             }
1182         }
1183         if (name[0] == 's' && name[1] == 'p' && name[2] == '\0')   // sp
1184             return true;
1185         if (name[0] == 'f' && name[1] == 'p' && name[2] == '\0')   // fp
1186             return true;
1187         if (name[0] == 'p' && name[1] == 'c' && name[2] == '\0')   // pc
1188             return true;
1189     }
1190     return false;
1191 }
1192
1193
1194
1195 void
1196 ABISysV_x86_64::Initialize()
1197 {
1198     PluginManager::RegisterPlugin (GetPluginNameStatic(),
1199                                    "System V ABI for x86_64 targets",
1200                                    CreateInstance);
1201 }
1202
1203 void
1204 ABISysV_x86_64::Terminate()
1205 {
1206     PluginManager::UnregisterPlugin (CreateInstance);
1207 }
1208
1209 lldb_private::ConstString
1210 ABISysV_x86_64::GetPluginNameStatic()
1211 {
1212     static ConstString g_name("sysv-x86_64");
1213     return g_name;
1214 }
1215
1216 //------------------------------------------------------------------
1217 // PluginInterface protocol
1218 //------------------------------------------------------------------
1219 lldb_private::ConstString
1220 ABISysV_x86_64::GetPluginName()
1221 {
1222     return GetPluginNameStatic();
1223 }
1224
1225 uint32_t
1226 ABISysV_x86_64::GetPluginVersion()
1227 {
1228     return 1;
1229 }
1230