1 /* 2 * intel_pt_insn_decoder.c: Intel Processor Trace support 3 * Copyright (c) 2013-2014, Intel Corporation. 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms and conditions of the GNU General Public License, 7 * version 2, as published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 12 * more details. 13 * 14 */ 15 16 #include <stdio.h> 17 #include <string.h> 18 #include <endian.h> 19 #include <byteswap.h> 20 21 #include "event.h" 22 23 #include "insn.h" 24 25 #include "inat.c" 26 #include "insn.c" 27 28 #include "intel-pt-insn-decoder.h" 29 #include "dump-insn.h" 30 31 #if INTEL_PT_INSN_BUF_SZ < MAX_INSN_SIZE || INTEL_PT_INSN_BUF_SZ > MAX_INSN 32 #error Instruction buffer size too small 33 #endif 34 35 /* Based on branch_type() from arch/x86/events/intel/lbr.c */ 36 static void intel_pt_insn_decoder(struct insn *insn, 37 struct intel_pt_insn *intel_pt_insn) 38 { 39 enum intel_pt_insn_op op = INTEL_PT_OP_OTHER; 40 enum intel_pt_insn_branch branch = INTEL_PT_BR_NO_BRANCH; 41 int ext; 42 43 intel_pt_insn->rel = 0; 44 45 if (insn_is_avx(insn)) { 46 intel_pt_insn->op = INTEL_PT_OP_OTHER; 47 intel_pt_insn->branch = INTEL_PT_BR_NO_BRANCH; 48 intel_pt_insn->length = insn->length; 49 return; 50 } 51 52 switch (insn->opcode.bytes[0]) { 53 case 0xf: 54 switch (insn->opcode.bytes[1]) { 55 case 0x05: /* syscall */ 56 case 0x34: /* sysenter */ 57 op = INTEL_PT_OP_SYSCALL; 58 branch = INTEL_PT_BR_INDIRECT; 59 break; 60 case 0x07: /* sysret */ 61 case 0x35: /* sysexit */ 62 op = INTEL_PT_OP_SYSRET; 63 branch = INTEL_PT_BR_INDIRECT; 64 break; 65 case 0x80 ... 0x8f: /* jcc */ 66 op = INTEL_PT_OP_JCC; 67 branch = INTEL_PT_BR_CONDITIONAL; 68 break; 69 default: 70 break; 71 } 72 break; 73 case 0x70 ... 0x7f: /* jcc */ 74 op = INTEL_PT_OP_JCC; 75 branch = INTEL_PT_BR_CONDITIONAL; 76 break; 77 case 0xc2: /* near ret */ 78 case 0xc3: /* near ret */ 79 case 0xca: /* far ret */ 80 case 0xcb: /* far ret */ 81 op = INTEL_PT_OP_RET; 82 branch = INTEL_PT_BR_INDIRECT; 83 break; 84 case 0xcf: /* iret */ 85 op = INTEL_PT_OP_IRET; 86 branch = INTEL_PT_BR_INDIRECT; 87 break; 88 case 0xcc ... 0xce: /* int */ 89 op = INTEL_PT_OP_INT; 90 branch = INTEL_PT_BR_INDIRECT; 91 break; 92 case 0xe8: /* call near rel */ 93 op = INTEL_PT_OP_CALL; 94 branch = INTEL_PT_BR_UNCONDITIONAL; 95 break; 96 case 0x9a: /* call far absolute */ 97 op = INTEL_PT_OP_CALL; 98 branch = INTEL_PT_BR_INDIRECT; 99 break; 100 case 0xe0 ... 0xe2: /* loop */ 101 op = INTEL_PT_OP_LOOP; 102 branch = INTEL_PT_BR_CONDITIONAL; 103 break; 104 case 0xe3: /* jcc */ 105 op = INTEL_PT_OP_JCC; 106 branch = INTEL_PT_BR_CONDITIONAL; 107 break; 108 case 0xe9: /* jmp */ 109 case 0xeb: /* jmp */ 110 op = INTEL_PT_OP_JMP; 111 branch = INTEL_PT_BR_UNCONDITIONAL; 112 break; 113 case 0xea: /* far jmp */ 114 op = INTEL_PT_OP_JMP; 115 branch = INTEL_PT_BR_INDIRECT; 116 break; 117 case 0xff: /* call near absolute, call far absolute ind */ 118 ext = (insn->modrm.bytes[0] >> 3) & 0x7; 119 switch (ext) { 120 case 2: /* near ind call */ 121 case 3: /* far ind call */ 122 op = INTEL_PT_OP_CALL; 123 branch = INTEL_PT_BR_INDIRECT; 124 break; 125 case 4: 126 case 5: 127 op = INTEL_PT_OP_JMP; 128 branch = INTEL_PT_BR_INDIRECT; 129 break; 130 default: 131 break; 132 } 133 break; 134 default: 135 break; 136 } 137 138 intel_pt_insn->op = op; 139 intel_pt_insn->branch = branch; 140 intel_pt_insn->length = insn->length; 141 142 if (branch == INTEL_PT_BR_CONDITIONAL || 143 branch == INTEL_PT_BR_UNCONDITIONAL) { 144 #if __BYTE_ORDER == __BIG_ENDIAN 145 switch (insn->immediate.nbytes) { 146 case 1: 147 intel_pt_insn->rel = insn->immediate.value; 148 break; 149 case 2: 150 intel_pt_insn->rel = 151 bswap_16((short)insn->immediate.value); 152 break; 153 case 4: 154 intel_pt_insn->rel = bswap_32(insn->immediate.value); 155 break; 156 default: 157 intel_pt_insn->rel = 0; 158 break; 159 } 160 #else 161 intel_pt_insn->rel = insn->immediate.value; 162 #endif 163 } 164 } 165 166 int intel_pt_get_insn(const unsigned char *buf, size_t len, int x86_64, 167 struct intel_pt_insn *intel_pt_insn) 168 { 169 struct insn insn; 170 171 insn_init(&insn, buf, len, x86_64); 172 insn_get_length(&insn); 173 if (!insn_complete(&insn) || insn.length > len) 174 return -1; 175 intel_pt_insn_decoder(&insn, intel_pt_insn); 176 if (insn.length < INTEL_PT_INSN_BUF_SZ) 177 memcpy(intel_pt_insn->buf, buf, insn.length); 178 else 179 memcpy(intel_pt_insn->buf, buf, INTEL_PT_INSN_BUF_SZ); 180 return 0; 181 } 182 183 const char *dump_insn(struct perf_insn *x, uint64_t ip __maybe_unused, 184 u8 *inbuf, int inlen, int *lenp) 185 { 186 struct insn insn; 187 int n, i; 188 int left; 189 190 insn_init(&insn, inbuf, inlen, x->is64bit); 191 insn_get_length(&insn); 192 if (!insn_complete(&insn) || insn.length > inlen) 193 return "<bad>"; 194 if (lenp) 195 *lenp = insn.length; 196 left = sizeof(x->out); 197 n = snprintf(x->out, left, "insn: "); 198 left -= n; 199 for (i = 0; i < insn.length; i++) { 200 n += snprintf(x->out + n, left, "%02x ", inbuf[i]); 201 left -= n; 202 } 203 return x->out; 204 } 205 206 const char *branch_name[] = { 207 [INTEL_PT_OP_OTHER] = "Other", 208 [INTEL_PT_OP_CALL] = "Call", 209 [INTEL_PT_OP_RET] = "Ret", 210 [INTEL_PT_OP_JCC] = "Jcc", 211 [INTEL_PT_OP_JMP] = "Jmp", 212 [INTEL_PT_OP_LOOP] = "Loop", 213 [INTEL_PT_OP_IRET] = "IRet", 214 [INTEL_PT_OP_INT] = "Int", 215 [INTEL_PT_OP_SYSCALL] = "Syscall", 216 [INTEL_PT_OP_SYSRET] = "Sysret", 217 }; 218 219 const char *intel_pt_insn_name(enum intel_pt_insn_op op) 220 { 221 return branch_name[op]; 222 } 223 224 int intel_pt_insn_desc(const struct intel_pt_insn *intel_pt_insn, char *buf, 225 size_t buf_len) 226 { 227 switch (intel_pt_insn->branch) { 228 case INTEL_PT_BR_CONDITIONAL: 229 case INTEL_PT_BR_UNCONDITIONAL: 230 return snprintf(buf, buf_len, "%s %s%d", 231 intel_pt_insn_name(intel_pt_insn->op), 232 intel_pt_insn->rel > 0 ? "+" : "", 233 intel_pt_insn->rel); 234 case INTEL_PT_BR_NO_BRANCH: 235 case INTEL_PT_BR_INDIRECT: 236 return snprintf(buf, buf_len, "%s", 237 intel_pt_insn_name(intel_pt_insn->op)); 238 default: 239 break; 240 } 241 return 0; 242 } 243 244 int intel_pt_insn_type(enum intel_pt_insn_op op) 245 { 246 switch (op) { 247 case INTEL_PT_OP_OTHER: 248 return 0; 249 case INTEL_PT_OP_CALL: 250 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL; 251 case INTEL_PT_OP_RET: 252 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN; 253 case INTEL_PT_OP_JCC: 254 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL; 255 case INTEL_PT_OP_JMP: 256 return PERF_IP_FLAG_BRANCH; 257 case INTEL_PT_OP_LOOP: 258 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CONDITIONAL; 259 case INTEL_PT_OP_IRET: 260 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | 261 PERF_IP_FLAG_INTERRUPT; 262 case INTEL_PT_OP_INT: 263 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | 264 PERF_IP_FLAG_INTERRUPT; 265 case INTEL_PT_OP_SYSCALL: 266 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_CALL | 267 PERF_IP_FLAG_SYSCALLRET; 268 case INTEL_PT_OP_SYSRET: 269 return PERF_IP_FLAG_BRANCH | PERF_IP_FLAG_RETURN | 270 PERF_IP_FLAG_SYSCALLRET; 271 default: 272 return 0; 273 } 274 } 275