1 /* -*- mode: C; c-basic-offset: 3; -*- */ 2 3 /*---------------------------------------------------------------*/ 4 /*--- begin host_s390_disasm.c ---*/ 5 /*---------------------------------------------------------------*/ 6 7 /* 8 This file is part of Valgrind, a dynamic binary instrumentation 9 framework. 10 11 Copyright IBM Corp. 2010-2012 12 13 This program is free software; you can redistribute it and/or 14 modify it under the terms of the GNU General Public License as 15 published by the Free Software Foundation; either version 2 of the 16 License, or (at your option) any later version. 17 18 This program is distributed in the hope that it will be useful, but 19 WITHOUT ANY WARRANTY; without even the implied warranty of 20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 21 General Public License for more details. 22 23 You should have received a copy of the GNU General Public License 24 along with this program; if not, write to the Free Software 25 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 26 02110-1301, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 /* Contributed by Florian Krohm */ 32 33 #include <stdarg.h> 34 #include "libvex_basictypes.h" 35 #include "main_util.h" // vassert 36 #include "main_globals.h" // vex_traceflags 37 #include "host_s390_disasm.h" 38 39 /* The format that is used to write out a mnemonic. 40 These should be declared as 'const HChar' but vex_printf needs 41 to be changed for that first */ 42 static HChar s390_mnm_fmt[] = "%-8s"; 43 44 45 /* Return the name of a general purpose register for dis-assembly purposes. */ 46 static const HChar * 47 gpr_operand(UInt archreg) 48 { 49 static const HChar names[16][5] = { 50 "%r0", "%r1", "%r2", "%r3", 51 "%r4", "%r5", "%r6", "%r7", 52 "%r8", "%r9", "%r10", "%r11", 53 "%r12", "%r13", "%r14", "%r15", 54 }; 55 56 vassert(archreg < 16); 57 58 return names[archreg]; 59 } 60 61 62 /* Return the name of a floating point register for dis-assembly purposes. */ 63 static const HChar * 64 fpr_operand(UInt archreg) 65 { 66 static const HChar names[16][5] = { 67 "%f0", "%f1", "%f2", "%f3", 68 "%f4", "%f5", "%f6", "%f7", 69 "%f8", "%f9", "%f10", "%f11", 70 "%f12", "%f13", "%f14", "%f15", 71 }; 72 73 vassert(archreg < 16); 74 75 return names[archreg]; 76 } 77 78 79 /* Return the name of an access register for dis-assembly purposes. */ 80 static const HChar * 81 ar_operand(UInt archreg) 82 { 83 static const HChar names[16][5] = { 84 "%a0", "%a1", "%a2", "%a3", 85 "%a4", "%a5", "%a6", "%a7", 86 "%a8", "%a9", "%a10", "%a11", 87 "%a12", "%a13", "%a14", "%a15", 88 }; 89 90 vassert(archreg < 16); 91 92 return names[archreg]; 93 } 94 95 96 /* Build and return the extended mnemonic for the compare and branch 97 opcodes as introduced by z10. See also the opcodes in file 98 opcodes/s390-opc.txt (from binutils) that have a '$' in their name. */ 99 static const HChar * 100 cab_operand(const HChar *base, UInt mask) 101 { 102 HChar *to; 103 const HChar *from; 104 105 static HChar buf[10]; /* Maximum is 6 + 2 */ 106 107 static HChar *suffix[] = { 108 "", "h", "l", "ne", "e", "nl", "nh", "" 109 }; 110 111 /* strcpy(buf, from); */ 112 for (from = base, to = buf; *from; ++from, ++to) { 113 *to = *from; 114 } 115 /* strcat(buf, suffix); */ 116 for (from = suffix[mask >> 1]; *from; ++from, ++to) { 117 *to = *from; 118 } 119 *to = '\0'; 120 121 return buf; 122 } 123 124 /* Common function used to construct a mnemonic based on a condition code 125 mask. */ 126 static const HChar * 127 construct_mnemonic(const HChar *prefix, const HChar *suffix, UInt mask) 128 { 129 HChar *to; 130 const HChar *from; 131 132 static HChar buf[10]; 133 134 static HChar mask_id[16][4] = { 135 "", /* 0 -> unused */ 136 "o", "h", "nle", "l", "nhe", "lh", "ne", 137 "e", "nlh", "he", "nl", "le", "nh", "no", 138 "" /* 15 -> unused */ 139 }; 140 141 /* Guard against buffer overflow */ 142 vassert(vex_strlen(prefix) + vex_strlen(suffix) + sizeof mask_id[0] <= sizeof buf); 143 144 /* strcpy(buf, prefix); */ 145 for (from = prefix, to = buf; *from; ++from, ++to) { 146 *to = *from; 147 } 148 /* strcat(buf, mask_id); */ 149 for (from = mask_id[mask]; *from; ++from, ++to) { 150 *to = *from; 151 } 152 /* strcat(buf, suffix); */ 153 for (from = suffix; *from; ++from, ++to) { 154 *to = *from; 155 } 156 *to = '\0'; 157 158 return buf; 159 } 160 161 162 /* Return the special mnemonic for the BCR opcode */ 163 static const HChar * 164 bcr_operand(UInt m1) 165 { 166 if (m1 == 0) return "nopr"; 167 if (m1 == 15) return "br"; 168 169 return construct_mnemonic("b", "r", m1); 170 } 171 172 173 /* Return the special mnemonic for the BC opcode */ 174 static const HChar * 175 bc_operand(UInt m1) 176 { 177 if (m1 == 0) return "nop"; 178 if (m1 == 15) return "b"; 179 180 return construct_mnemonic("b", "", m1); 181 } 182 183 184 /* Return the special mnemonic for the BRC opcode */ 185 static const HChar * 186 brc_operand(UInt m1) 187 { 188 if (m1 == 0) return "brc"; 189 if (m1 == 15) return "j"; 190 191 return construct_mnemonic("j", "", m1); 192 } 193 194 195 /* Return the special mnemonic for the BRCL opcode */ 196 static const HChar * 197 brcl_operand(UInt m1) 198 { 199 if (m1 == 0) return "brcl"; 200 if (m1 == 15) return "jg"; 201 202 return construct_mnemonic("jg", "", m1); 203 } 204 205 206 /* Return the special mnemonic for a conditional load/store opcode */ 207 static const HChar * 208 cls_operand(Int kind, UInt mask) 209 { 210 HChar *prefix; 211 212 switch (kind) { 213 case S390_XMNM_LOCR: prefix = "locr"; break; 214 case S390_XMNM_LOCGR: prefix = "locgr"; break; 215 case S390_XMNM_LOC: prefix = "loc"; break; 216 case S390_XMNM_LOCG: prefix = "locg"; break; 217 case S390_XMNM_STOC: prefix = "stoc"; break; 218 case S390_XMNM_STOCG: prefix = "stocg"; break; 219 default: 220 vpanic("cls_operand"); 221 } 222 223 return construct_mnemonic(prefix, "", mask); 224 } 225 226 227 /* An operand with a base register, an index register, and a displacement. 228 If the displacement is signed, the rightmost 20 bit of D need to be 229 sign extended */ 230 static HChar * 231 dxb_operand(HChar *p, UInt d, UInt x, UInt b, Bool displacement_is_signed) 232 { 233 if (displacement_is_signed) { 234 Int displ = ((Int)d << 12) >> 12; /* sign extend */ 235 236 p += vex_sprintf(p, "%d", displ); 237 } else { 238 p += vex_sprintf(p, "%u", d); 239 } 240 if (x != 0) { 241 p += vex_sprintf(p, "(%s", gpr_operand(x)); 242 if (b != 0) { 243 p += vex_sprintf(p, ",%s", gpr_operand(b)); 244 } 245 p += vex_sprintf(p, ")"); 246 } else { 247 if (b != 0) { 248 p += vex_sprintf(p, "(%s)", gpr_operand(b)); 249 } 250 } 251 252 return p; 253 } 254 255 256 /* An operand with base register, unsigned length, and a 12-bit 257 unsigned displacement */ 258 static HChar * 259 udlb_operand(HChar *p, UInt d, UInt length, UInt b) 260 { 261 p += vex_sprintf(p, "%u", d); 262 p += vex_sprintf(p, "(%u", length + 1); // actual length is +1 263 if (b != 0) { 264 p += vex_sprintf(p, ",%s", gpr_operand(b)); 265 } 266 p += vex_sprintf(p, ")"); 267 268 return p; 269 } 270 271 272 /* The first argument is the command that says how to write the disassembled 273 insn. It is understood that the mnemonic comes first and that arguments 274 are separated by a ','. The command holds the arguments. Each argument is 275 encoded using a 4-bit S390_ARG_xyz value. The first argument is placed 276 in the least significant bits of the command and so on. There are at most 277 5 arguments in an insn and a sentinel (S390_ARG_DONE) is needed to identify 278 the end of the argument list. 6 * 4 = 24 bits are required for the 279 command. */ 280 void 281 s390_disasm(UInt command, ...) 282 { 283 va_list args; 284 unsigned argkind; 285 HChar buf[128]; /* holds the disassembled insn */ 286 HChar *p; 287 HChar separator; 288 Int mask_suffix = -1; 289 290 va_start(args, command); 291 292 p = buf; 293 separator = 0; 294 295 while (42) { 296 argkind = command & 0xF; 297 command >>= 4; 298 299 if (argkind == S390_ARG_DONE) goto done; 300 301 if (argkind == S390_ARG_CABM) separator = 0; /* optional */ 302 303 /* Write out the separator */ 304 if (separator) *p++ = separator; 305 306 /* argument */ 307 switch (argkind) { 308 case S390_ARG_MNM: 309 p += vex_sprintf(p, s390_mnm_fmt, va_arg(args, HChar *)); 310 separator = ' '; 311 continue; 312 313 case S390_ARG_XMNM: { 314 UInt mask, kind; 315 const HChar *mnm; 316 317 kind = va_arg(args, UInt); 318 319 separator = ' '; 320 switch (kind) { 321 case S390_XMNM_BC: 322 case S390_XMNM_BCR: 323 mask = va_arg(args, UInt); 324 mnm = kind == S390_XMNM_BCR ? bcr_operand(mask) : bc_operand(mask); 325 p += vex_sprintf(p, s390_mnm_fmt, mnm); 326 /* mask == 0 is a NOP and has no argument */ 327 if (mask == 0) goto done; 328 break; 329 330 case S390_XMNM_BRC: 331 case S390_XMNM_BRCL: 332 mask = va_arg(args, UInt); 333 mnm = kind == S390_XMNM_BRC ? brc_operand(mask) : brcl_operand(mask); 334 p += vex_sprintf(p, s390_mnm_fmt, mnm); 335 336 /* mask == 0 has no special mnemonic */ 337 if (mask == 0) { 338 p += vex_sprintf(p, " 0"); 339 separator = ','; 340 } 341 break; 342 343 case S390_XMNM_CAB: 344 mnm = va_arg(args, HChar *); 345 mask = va_arg(args, UInt); 346 p += vex_sprintf(p, s390_mnm_fmt, cab_operand(mnm, mask)); 347 break; 348 349 case S390_XMNM_LOCR: 350 case S390_XMNM_LOCGR: 351 case S390_XMNM_LOC: 352 case S390_XMNM_LOCG: 353 case S390_XMNM_STOC: 354 case S390_XMNM_STOCG: 355 mask = va_arg(args, UInt); 356 mnm = cls_operand(kind, mask); 357 p += vex_sprintf(p, s390_mnm_fmt, mnm); 358 /* There are no special opcodes when mask == 0 or 15. In that case 359 the integer mask is appended as the final operand */ 360 if (mask == 0 || mask == 15) mask_suffix = mask; 361 break; 362 } 363 } 364 continue; 365 366 case S390_ARG_GPR: 367 p += vex_sprintf(p, "%s", gpr_operand(va_arg(args, UInt))); 368 break; 369 370 case S390_ARG_FPR: 371 p += vex_sprintf(p, "%s", fpr_operand(va_arg(args, UInt))); 372 break; 373 374 case S390_ARG_AR: 375 p += vex_sprintf(p, "%s", ar_operand(va_arg(args, UInt))); 376 break; 377 378 case S390_ARG_UINT: 379 p += vex_sprintf(p, "%u", va_arg(args, UInt)); 380 break; 381 382 case S390_ARG_INT: 383 p += vex_sprintf(p, "%d", (Int)(va_arg(args, UInt))); 384 break; 385 386 case S390_ARG_PCREL: { 387 Int offset = (Int)(va_arg(args, UInt)); 388 389 /* Convert # halfwords to # bytes */ 390 offset <<= 1; 391 392 if (offset < 0) { 393 p += vex_sprintf(p, ".%d", offset); 394 } else { 395 p += vex_sprintf(p, ".+%u", offset); 396 } 397 break; 398 } 399 400 case S390_ARG_SDXB: { 401 UInt dh, dl, x, b; 402 403 dh = va_arg(args, UInt); 404 dl = va_arg(args, UInt); 405 x = va_arg(args, UInt); 406 b = va_arg(args, UInt); 407 408 p = dxb_operand(p, (dh << 12) | dl, x, b, 1 /* signed_displacement */); 409 break; 410 } 411 412 case S390_ARG_UDXB: { 413 UInt d, x, b; 414 415 d = va_arg(args, UInt); 416 x = va_arg(args, UInt); 417 b = va_arg(args, UInt); 418 419 p = dxb_operand(p, d, x, b, 0 /* signed_displacement */); 420 break; 421 } 422 423 case S390_ARG_UDLB: { 424 UInt d, l, b; 425 426 d = va_arg(args, UInt); 427 l = va_arg(args, UInt); 428 b = va_arg(args, UInt); 429 430 p = udlb_operand(p, d, l, b); 431 break; 432 } 433 434 case S390_ARG_CABM: { 435 UInt mask; 436 437 mask = va_arg(args, UInt) & 0xE; 438 if (mask == 0 || mask == 14) { 439 p += vex_sprintf(p, ",%u", mask); 440 } 441 break; 442 } 443 } 444 445 separator = ','; 446 } 447 448 done: 449 va_end(args); 450 451 if (mask_suffix != -1) 452 p += vex_sprintf(p, ",%d", mask_suffix); 453 *p = '\0'; 454 455 vassert(p < buf + sizeof buf); /* detect buffer overwrite */ 456 457 /* Finally, write out the disassembled insn */ 458 vex_printf("%s\n", buf); 459 } 460 461 /*---------------------------------------------------------------*/ 462 /*--- end host_s390_disasm.c ---*/ 463 /*---------------------------------------------------------------*/ 464
