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