patch fix-lint
3317 dis(1) should support cross-target disassembly

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 /*
  28  * Copyright 2007 Jason King.  All rights reserved.
  29  * Use is subject to license terms.
  30  * Copyright 2012 Joshua M. Clulow <josh@sysmgr.org>
  31  */
  32 
  33 /*
  34  * The sparc disassembler is mostly straightforward, each instruction is
  35  * represented by an inst_t structure.  The inst_t definitions are organized
  36  * into tables.  The tables are correspond to the opcode maps documented in the
  37  * various sparc architecture manuals.  Each table defines the bit range of the
  38  * instruction whose value act as an index into the array of instructions.  A
  39  * table can also refer to another table if needed.  Each table also contains
  40  * a function pointer of type format_fcn that knows how to output the
  41  * instructions in the table, as well as handle any synthetic instructions
  42  *
  43  * Unfortunately, the changes from sparcv8 -> sparcv9 not only include new
  44  * instructions, they sometimes renamed or just reused the same instruction to
  45  * do different operations (i.e. the sparcv8 coprocessor instructions).  To
  46  * accommodate this, each table can define an overlay table.  The overlay table
  47  * is a list of (table index, architecture, new instruction definition) values.
  48  *
  49  *
  50  * Traversal starts with the first table,
  51  *   get index value from the instruction
  52  *   if an relevant overlay entry exists for this index,
  53  *        grab the overlay definition
  54  *   else
  55  *        grab the definition from the array (corresponding to the index value)
  56  *
  57  * If the entry is an instruction,
  58  *     call print function of instruction.
  59  * If the entry is a pointer to another table
  60  *     traverse the table
  61  * If not valid,
  62  *     return an error
  63  *
  64  *
  65  * To keep dis happy, for sparc, instead of actually returning an error, if
  66  * the instruction cannot be disassembled, we instead merely place the value
  67  * of the instruction into the output buffer.
  68  *
  69  * Adding new instructions:
  70  *
  71  * With the above information, it hopefully makes it clear how to add support
  72  * for decoding new instructions.  Presumably, with new instructions will come
  73  * a new dissassembly mode (I.e. DIS_SPARC_V8, DIS_SPARC_V9, etc.).
  74  *
  75  * If the dissassembled format does not correspond to one of the existing
  76  * formats, a new formatter will have to be written.  The 'flags' value of
  77  * inst_t is intended to instruct the corresponding formatter about how to
  78  * output the instruction.
  79  *
  80  * If the corresponding entry in the correct table is currently unoccupied,
  81  * simply replace the INVALID entry with the correct definition.  The INST and
  82  * TABLE macros are suggested to be used for this.  If there is already an
  83  * instruction defined, then the entry must be placed in an overlay table.  If
  84  * no overlay table exists for the instruction table, one will need to be
  85  * created.
  86  */
  87 
  88 #include <libdisasm.h>
  89 #include <stdlib.h>
  90 #include <stdio.h>
  91 #include <sys/types.h>
  92 #include <sys/byteorder.h>
  93 #include <string.h>
  94 
  95 #include "libdisasm_impl.h"
  96 #include "dis_sparc.h"
  97 
  98 static const inst_t *dis_get_overlay(dis_handle_t *, const table_t *,
  99     uint32_t);
 100 static uint32_t dis_get_bits(uint32_t, int, int);
 101 
 102 #if !defined(DIS_STANDALONE)
 103 static void do_binary(uint32_t);
 104 #endif /* DIS_STANDALONE */
 105 
 106 static void
 107 dis_sparc_handle_detach(dis_handle_t *dhp)
 108 {
 109         dis_free(dhp->dh_arch_private, sizeof (dis_handle_sparc_t));
 110         dhp->dh_arch_private = NULL;
 111 }
 112 
 113 static int
 114 dis_sparc_handle_attach(dis_handle_t *dhp)
 115 {
 116         dis_handle_sparc_t *dhx;
 117 
 118 #if !defined(DIS_STANDALONE)
 119         char *opt = NULL;
 120         char *opt2, *save, *end;
 121 #endif

 122 
 123         /* Validate architecture flags */
 124         if ((dhp->dh_flags & (DIS_SPARC_V8|DIS_SPARC_V9|DIS_SPARC_V9_SGI))
 125             == 0) {
 126                 (void) dis_seterrno(E_DIS_INVALFLAG);
 127                 return (-1);
 128         }
 129 
 130         if ((dhx = dis_zalloc(sizeof (dis_handle_sparc_t))) == NULL) {
 131                 (void) dis_seterrno(E_DIS_NOMEM);
 132                 return (NULL);
 133         }
 134         dhx->dhx_debug = DIS_DEBUG_COMPAT;
 135         dhp->dh_arch_private = dhx;




 136 
 137 #if !defined(DIS_STANDALONE)
 138 
 139         opt = getenv("_LIBDISASM_DEBUG");
 140         if (opt == NULL)
 141                 return (0);
 142 
 143         opt2 = strdup(opt);
 144         if (opt2 == NULL) {
 145                 dis_handle_destroy(dhp);
 146                 dis_free(dhx, sizeof (dis_handle_sparc_t));
 147                 (void) dis_seterrno(E_DIS_NOMEM);
 148                 return (-1);
 149         }
 150         save = opt2;
 151 
 152         while (opt2 != NULL) {
 153                 end = strchr(opt2, ',');
 154 
 155                 if (end != 0)
 156                         *end++ = '\0';
 157 
 158                 if (strcasecmp("synth-all", opt2) == 0)
 159                         dhx->dhx_debug |= DIS_DEBUG_SYN_ALL;
 160 
 161                 if (strcasecmp("compat", opt2) == 0)
 162                         dhx->dhx_debug |= DIS_DEBUG_COMPAT;
 163 
 164                 if (strcasecmp("synth-none", opt2) == 0)
 165                         dhx->dhx_debug &= ~(DIS_DEBUG_SYN_ALL|DIS_DEBUG_COMPAT);
 166 
 167                 if (strcasecmp("binary", opt2) == 0)
 168                         dhx->dhx_debug |= DIS_DEBUG_PRTBIN;
 169 
 170                 if (strcasecmp("format", opt2) == 0)
 171                         dhx->dhx_debug |= DIS_DEBUG_PRTFMT;
 172 
 173                 if (strcasecmp("all", opt2) == 0)
 174                         dhx->dhx_debug = DIS_DEBUG_ALL;
 175 
 176                 if (strcasecmp("none", opt2) == 0)
 177                         dhx->dhx_debug = DIS_DEBUG_NONE;
 178 
 179                 opt2 = end;
 180         }
 181         free(save);
 182 #endif /* DIS_STANDALONE */
 183         return (0);


















 184 }
 185 
 186 /* ARGSUSED */
 187 static int
 188 dis_sparc_max_instrlen(dis_handle_t *dhp)
 189 {
 190         return (4);
 191 }
 192 
 193 /* ARGSUSED */
 194 static int
 195 dis_sparc_min_instrlen(dis_handle_t *dhp)
 196 {
 197         return (4);
 198 }
 199 
 200 /*
 201  * The dis_i386.c comment for this says it returns the previous instruction,
 202  * however, I'm fairly sure it's actually returning the _address_ of the
 203  * nth previous instruction.
 204  */
 205 /* ARGSUSED */
 206 static uint64_t
 207 dis_sparc_previnstr(dis_handle_t *dhp, uint64_t pc, int n)
 208 {
 209         if (n <= 0)
 210                 return (pc);
 211 
 212         if (pc < n)
 213                 return (pc);
 214 
 215         return (pc - n*4);
 216 }
 217 
 218 /* ARGSUSED */
 219 static int
 220 dis_sparc_instrlen(dis_handle_t *dhp, uint64_t pc)
 221 {
 222         return (4);
 223 }
 224 
 225 static int
 226 dis_sparc_disassemble(dis_handle_t *dhp, uint64_t addr, char *buf,
 227     size_t buflen)
 228 {
 229         dis_handle_sparc_t *dhx = dhp->dh_arch_private;
 230         const table_t *tp = &initial_table;
 231         const inst_t *inp = NULL;
 232 
 233         uint32_t instr;
 234         uint32_t idx = 0;
 235 
 236         if (dhp->dh_read(dhp->dh_data, addr, &instr, sizeof (instr)) !=
 237             sizeof (instr))
 238                 return (-1);
 239 
 240         dhx->dhx_buf    = buf;
 241         dhx->dhx_buflen = buflen;
 242         dhp->dh_addr    = addr;
 243 
 244         buf[0] = '\0';
 245 
 246         /* this allows sparc code to be tested on x86 */
 247 #if !defined(DIS_STANDALONE)
 248         instr = BE_32(instr);
 249 #endif /* DIS_STANDALONE */
 250 
 251 #if !defined(DIS_STANDALONE)
 252         if ((dhx->dhx_debug & DIS_DEBUG_PRTBIN) != 0)
 253                 do_binary(instr);
 254 #endif /* DIS_STANDALONE */
 255 
 256         /* CONSTCOND */
 257         while (1) {
 258                 idx = dis_get_bits(instr, tp->tbl_field, tp->tbl_len);
 259                 inp = &tp->tbl_inp[idx];
 260 
 261                 inp = dis_get_overlay(dhp, tp, idx);
 262 
 263                 if ((inp->in_type == INST_NONE) ||
 264                     ((inp->in_arch & dhp->dh_flags) == 0))
 265                         goto error;
 266 
 267                 if (inp->in_type == INST_TBL) {
 268                         tp = inp->in_data.in_tbl;
 269                         continue;
 270                 }
 271 
 272                 break;
 273         }
 274 
 275         if (tp->tbl_fmt(dhp, instr, inp, idx) == 0)
 276                 return (0);
 277 
 278 error:
 279 
 280         (void) dis_snprintf(buf, buflen,
 281             ((dhp->dh_flags & DIS_OCTAL) != 0) ? "0%011lo" : "0x%08lx",
 282             instr);
 283 
 284         return (0);
 285 }
 286 
 287 static uint32_t
 288 dis_get_bits(uint32_t instr, int offset, int length)
 289 {
 290         uint32_t mask, val;
 291         int i;
 292 
 293         for (i = 0, mask = 0; i < length; ++i)
 294                 mask |= (1UL << i);
 295 
 296         mask = mask << (offset - length + 1);
 297 
 298         val = instr & mask;
 299 
 300         val = val >> (offset - length + 1);
 301 
 302         return (val);
 303 }
 304 
 305 static const inst_t *
 306 dis_get_overlay(dis_handle_t *dhp, const table_t *tp, uint32_t idx)
 307 {
 308         const inst_t *ip = &tp->tbl_inp[idx];
 309         int i;
 310 
 311         if (tp->tbl_ovp == NULL)
 312                 return (ip);
 313 
 314         for (i = 0; tp->tbl_ovp[i].ov_idx != -1; ++i) {
 315                 if (tp->tbl_ovp[i].ov_idx != idx)
 316                         continue;
 317 
 318                 if ((tp->tbl_ovp[i].ov_inst.in_arch & dhp->dh_flags) == 0)
 319                         continue;
 320 
 321                 ip = &tp->tbl_ovp[i].ov_inst;
 322                 break;
 323         }
 324 
 325         return (ip);
 326 }
 327 
 328 #if !defined(DIS_STANDALONE)
 329 static void
 330 do_binary(uint32_t instr)
 331 {
 332         (void) fprintf(stderr, "DISASM: ");
 333         prt_binary(instr, 32);
 334         (void) fprintf(stderr, "\n");
 335 }
 336 #endif /* DIS_STANDALONE */
 337 
 338 static int
 339 dis_sparc_supports_flags(int flags)
 340 {
 341         int archflags = flags & DIS_ARCH_MASK;
 342 
 343         if (archflags == DIS_SPARC_V8 ||
 344             (archflags & (DIS_SPARC_V9 | DIS_SPARC_V8)) == DIS_SPARC_V9)
 345                 return (1);
 346 
 347         return (0);
 348 }
 349 
 350 const dis_arch_t dis_arch_sparc = {
 351         dis_sparc_supports_flags,
 352         dis_sparc_handle_attach,
 353         dis_sparc_handle_detach,
 354         dis_sparc_disassemble,
 355         dis_sparc_previnstr,
 356         dis_sparc_min_instrlen,
 357         dis_sparc_max_instrlen,
 358         dis_sparc_instrlen
 359 };
--- EOF ---