Merge with git://www.denx.de/git/u-boot.git
[platform/kernel/u-boot.git] / common / bedbug.c
1 /* $Id$ */
2
3 #include <common.h>
4
5 #if (CONFIG_COMMANDS & CFG_CMD_BEDBUG)
6
7 #include <linux/ctype.h>
8 #include <bedbug/bedbug.h>
9 #include <bedbug/ppc.h>
10 #include <bedbug/regs.h>
11 #include <bedbug/tables.h>
12
13 #define Elf32_Word      unsigned long
14
15 /* USE_SOURCE_CODE enables some symbolic debugging functions of this
16    code.  This is only useful if the program will have access to the
17    source code for the binary being examined.
18 */
19
20 /* #define USE_SOURCE_CODE 1 */
21
22 #ifdef USE_SOURCE_CODE
23 extern int line_info_from_addr __P ((Elf32_Word, char *, char *, int *));
24 extern struct symreflist *symByAddr;
25 extern char *symbol_name_from_addr __P ((Elf32_Word, int, int *));
26 #endif /* USE_SOURCE_CODE */
27
28 int print_operands __P ((struct ppc_ctx *));
29 int get_operand_value __P ((struct opcode *, unsigned long,
30                                 enum OP_FIELD, unsigned long *));
31 struct opcode *find_opcode __P ((unsigned long));
32 struct opcode *find_opcode_by_name __P ((char *));
33 char *spr_name __P ((int));
34 int spr_value __P ((char *));
35 char *tbr_name __P ((int));
36 int tbr_value __P ((char *));
37 int parse_operand __P ((unsigned long, struct opcode *,
38                         struct operand *, char *, int *));
39 int get_word __P ((char **, char *));
40 long read_number __P ((char *));
41 int downstring __P ((char *));
42 \f
43
44 /*======================================================================
45  * Entry point for the PPC disassembler.
46  *
47  * Arguments:
48  *      memaddr         The address to start disassembling from.
49  *
50  *      virtual         If this value is non-zero, then this will be
51  *                      used as the base address for the output and
52  *                      symbol lookups.  If this value is zero then
53  *                      memaddr is used as the absolute address.
54  *
55  *      num_instr       The number of instructions to disassemble.  Since
56  *                      each instruction is 32 bits long, this can be
57  *                      computed if you know the total size of the region.
58  *
59  *      pfunc           The address of a function that is called to print
60  *                      each line of output.  The function should take a
61  *                      single character pointer as its parameters a la puts.
62  *
63  *      flags           Sets options for the output.  This is a
64  *                      bitwise-inclusive-OR of the following
65  *                      values.  Note that only one of the radix
66  *                      options may be set.
67  *
68  *                      F_RADOCTAL      - output radix is unsigned base 8.
69  *                      F_RADUDECIMAL   - output radix is unsigned base 10.
70  *                      F_RADSDECIMAL   - output radix is signed base 10.
71  *                      F_RADHEX        - output radix is unsigned base 16.
72  *                      F_SIMPLE        - use simplified mnemonics.
73  *                      F_SYMBOL        - lookup symbols for addresses.
74  *                      F_INSTR         - output raw instruction.
75  *                      F_LINENO        - show line # info if available.
76  *
77  * Returns TRUE if the area was successfully disassembled or FALSE if
78  * a problem was encountered with accessing the memory.
79  */
80
81 int disppc (unsigned char *memaddr, unsigned char *virtual, int num_instr,
82                         int (*pfunc) (const char *), unsigned long flags)
83 {
84         int i;
85         struct ppc_ctx ctx;
86
87 #ifdef USE_SOURCE_CODE
88         int line_no = 0;
89         int last_line_no = 0;
90         char funcname[128] = { 0 };
91         char filename[256] = { 0 };
92         char last_funcname[128] = { 0 };
93         int symoffset;
94         char *symname;
95         char *cursym = (char *) 0;
96 #endif /* USE_SOURCE_CODE */
97   /*------------------------------------------------------------*/
98
99         ctx.flags = flags;
100         ctx.virtual = virtual;
101
102         /* Figure out the output radix before we go any further */
103
104         if (ctx.flags & F_RADOCTAL) {
105                 /* Unsigned octal output */
106                 strcpy (ctx.radix_fmt, "O%o");
107         } else if (ctx.flags & F_RADUDECIMAL) {
108                 /* Unsigned decimal output */
109                 strcpy (ctx.radix_fmt, "%u");
110         } else if (ctx.flags & F_RADSDECIMAL) {
111                 /* Signed decimal output */
112                 strcpy (ctx.radix_fmt, "%d");
113         } else {
114                 /* Unsigned hex output */
115                 strcpy (ctx.radix_fmt, "0x%x");
116         }
117
118         if (ctx.virtual == 0) {
119                 ctx.virtual = memaddr;
120         }
121 #ifdef USE_SOURCE_CODE
122         if (ctx.flags & F_SYMBOL) {
123                 if (symByAddr == 0)             /* no symbols loaded */
124                         ctx.flags &= ~F_SYMBOL;
125                 else {
126                         cursym = (char *) 0;
127                         symoffset = 0;
128                 }
129         }
130 #endif /* USE_SOURCE_CODE */
131
132         /* format each line as "XXXXXXXX: <symbol> IIIIIIII  disassembly" where,
133            XXXXXXXX is the memory address in hex,
134            <symbol> is the symbolic location if F_SYMBOL is set.
135            IIIIIIII is the raw machine code in hex if F_INSTR is set,
136            and disassembly is the disassembled machine code with numbers
137            formatted according to the 'radix' parameter */
138
139         for (i = 0; i < num_instr; ++i, memaddr += 4, ctx.virtual += 4) {
140 #ifdef USE_SOURCE_CODE
141                 if (ctx.flags & F_LINENO) {
142                         if ((line_info_from_addr ((Elf32_Word) ctx.virtual, filename,
143                                                                           funcname, &line_no) == TRUE) &&
144                                 ((line_no != last_line_no) ||
145                                  (strcmp (last_funcname, funcname) != 0))) {
146                                 print_source_line (filename, funcname, line_no, pfunc);
147                         }
148                         last_line_no = line_no;
149                         strcpy (last_funcname, funcname);
150                 }
151 #endif /* USE_SOURCE_CODE */
152
153                 sprintf (ctx.data, "%08lx: ", (unsigned long) ctx.virtual);
154                 ctx.datalen = 10;
155
156 #ifdef USE_SOURCE_CODE
157                 if (ctx.flags & F_SYMBOL) {
158                         if ((symname =
159                                  symbol_name_from_addr ((Elf32_Word) ctx.virtual,
160                                                                                 TRUE, 0)) != 0) {
161                                 cursym = symname;
162                                 symoffset = 0;
163                         } else {
164                                 if ((cursym == 0) &&
165                                         ((symname =
166                                           symbol_name_from_addr ((Elf32_Word) ctx.virtual,
167                                                                                          FALSE, &symoffset)) != 0)) {
168                                         cursym = symname;
169                                 } else {
170                                         symoffset += 4;
171                                 }
172                         }
173
174                         if (cursym != 0) {
175                                 sprintf (&ctx.data[ctx.datalen], "<%s+", cursym);
176                                 ctx.datalen = strlen (ctx.data);
177                                 sprintf (&ctx.data[ctx.datalen], ctx.radix_fmt, symoffset);
178                                 strcat (ctx.data, ">");
179                                 ctx.datalen = strlen (ctx.data);
180                         }
181                 }
182 #endif /* USE_SOURCE_CODE */
183
184                 ctx.instr = INSTRUCTION (memaddr);
185
186                 if (ctx.flags & F_INSTR) {
187                         /* Find the opcode structure for this opcode.  If one is not found
188                            then it must be an illegal instruction */
189                         sprintf (&ctx.data[ctx.datalen],
190                                          "   %02lx %02lx %02lx %02lx    ",
191                                          ((ctx.instr >> 24) & 0xff),
192                                          ((ctx.instr >> 16) & 0xff), ((ctx.instr >> 8) & 0xff),
193                                          (ctx.instr & 0xff));
194                         ctx.datalen += 18;
195                 } else {
196                         strcat (ctx.data, "   ");
197                         ctx.datalen += 3;
198                 }
199
200                 if ((ctx.op = find_opcode (ctx.instr)) == 0) {
201                         /* Illegal Opcode */
202                         sprintf (&ctx.data[ctx.datalen], "        .long 0x%08lx",
203                                          ctx.instr);
204                         ctx.datalen += 24;
205                         (*pfunc) (ctx.data);
206                         continue;
207                 }
208
209                 if (((ctx.flags & F_SIMPLE) == 0) ||
210                         (ctx.op->hfunc == 0) || ((*ctx.op->hfunc) (&ctx) == FALSE)) {
211                         sprintf (&ctx.data[ctx.datalen], "%-7s ", ctx.op->name);
212                         ctx.datalen += 8;
213                         print_operands (&ctx);
214                 }
215
216                 (*pfunc) (ctx.data);
217         }
218
219         return TRUE;
220 }                                                               /* disppc */
221 \f
222
223
224 /*======================================================================
225  * Called by the disassembler to print the operands for an instruction.
226  *
227  * Arguments:
228  *      ctx             A pointer to the disassembler context record.
229  *
230  * always returns 0.
231  */
232
233 int print_operands (struct ppc_ctx *ctx)
234 {
235         int open_parens = 0;
236         int field;
237         unsigned long operand;
238         struct operand *opr;
239
240 #ifdef USE_SOURCE_CODE
241         char *symname;
242         int offset;
243 #endif /* USE_SOURCE_CODE */
244   /*------------------------------------------------------------*/
245
246         /* Walk through the operands and list each in order */
247         for (field = 0; ctx->op->fields[field] != 0; ++field) {
248                 if (ctx->op->fields[field] > n_operands) {
249                         continue;                       /* bad operand ?! */
250                 }
251
252                 opr = &operands[ctx->op->fields[field] - 1];
253
254                 if (opr->hint & OH_SILENT) {
255                         continue;
256                 }
257
258                 if ((field > 0) && !open_parens) {
259                         strcat (ctx->data, ",");
260                         ctx->datalen++;
261                 }
262
263                 operand = (ctx->instr >> opr->shift) & ((1 << opr->bits) - 1);
264
265                 if (opr->hint & OH_ADDR) {
266                         if ((operand & (1 << (opr->bits - 1))) != 0) {
267                                 operand = operand - (1 << opr->bits);
268                         }
269
270                         if (ctx->op->hint & H_RELATIVE)
271                                 operand = (operand << 2) + (unsigned long) ctx->virtual;
272                         else
273                                 operand = (operand << 2);
274
275
276                         sprintf (&ctx->data[ctx->datalen], "0x%lx", operand);
277                         ctx->datalen = strlen (ctx->data);
278
279 #ifdef USE_SOURCE_CODE
280                         if ((ctx->flags & F_SYMBOL) &&
281                                 ((symname =
282                                   symbol_name_from_addr (operand, 0, &offset)) != 0)) {
283                                 sprintf (&ctx->data[ctx->datalen], " <%s", symname);
284                                 if (offset != 0) {
285                                         strcat (ctx->data, "+");
286                                         ctx->datalen = strlen (ctx->data);
287                                         sprintf (&ctx->data[ctx->datalen], ctx->radix_fmt,
288                                                          offset);
289                                 }
290                                 strcat (ctx->data, ">");
291                         }
292 #endif /* USE_SOURCE_CODE */
293                 }
294
295                 else if (opr->hint & OH_REG) {
296                         if ((operand == 0) &&
297                                 (opr->field == O_rA) && (ctx->op->hint & H_RA0_IS_0)) {
298                                 strcat (ctx->data, "0");
299                         } else {
300                                 sprintf (&ctx->data[ctx->datalen], "r%d", (short) operand);
301                         }
302
303                         if (open_parens) {
304                                 strcat (ctx->data, ")");
305                                 open_parens--;
306                         }
307                 }
308
309                 else if (opr->hint & OH_SPR) {
310                         strcat (ctx->data, spr_name (operand));
311                 }
312
313                 else if (opr->hint & OH_TBR) {
314                         strcat (ctx->data, tbr_name (operand));
315                 }
316
317                 else if (opr->hint & OH_LITERAL) {
318                         switch (opr->field) {
319                         case O_cr2:
320                                 strcat (ctx->data, "cr2");
321                                 ctx->datalen += 3;
322                                 break;
323
324                         default:
325                                 break;
326                         }
327                 }
328
329                 else {
330                         sprintf (&ctx->data[ctx->datalen], ctx->radix_fmt,
331                                          (unsigned short) operand);
332
333                         if (open_parens) {
334                                 strcat (ctx->data, ")");
335                                 open_parens--;
336                         }
337
338                         else if (opr->hint & OH_OFFSET) {
339                                 strcat (ctx->data, "(");
340                                 open_parens++;
341                         }
342                 }
343
344                 ctx->datalen = strlen (ctx->data);
345         }
346
347         return 0;
348 }                                                               /* print_operands */
349 \f
350
351
352 /*======================================================================
353  * Called to get the value of an arbitrary operand with in an instruction.
354  *
355  * Arguments:
356  *      op              The pointer to the opcode structure to which
357  *                      the operands belong.
358  *
359  *      instr           The instruction (32 bits) containing the opcode
360  *                      and the operands to print.  By the time that
361  *                      this routine is called the operand has already
362  *                      been added to the output.
363  *
364  *      field           The field (operand) to get the value of.
365  *
366  *      value           The address of an unsigned long to be filled in
367  *                      with the value of the operand if it is found.  This
368  *                      will only be filled in if the function returns
369  *                      TRUE.  This may be passed as 0 if the value is
370  *                      not required.
371  *
372  * Returns TRUE if the operand was found or FALSE if it was not.
373  */
374
375 int get_operand_value (struct opcode *op, unsigned long instr,
376                                            enum OP_FIELD field, unsigned long *value)
377 {
378         int i;
379         struct operand *opr;
380
381   /*------------------------------------------------------------*/
382
383         if (field > n_operands) {
384                 return FALSE;                   /* bad operand ?! */
385         }
386
387         /* Walk through the operands and list each in order */
388         for (i = 0; op->fields[i] != 0; ++i) {
389                 if (op->fields[i] != field) {
390                         continue;
391                 }
392
393                 opr = &operands[op->fields[i] - 1];
394
395                 if (value) {
396                         *value = (instr >> opr->shift) & ((1 << opr->bits) - 1);
397                 }
398                 return TRUE;
399         }
400
401         return FALSE;
402 }                                                               /* operand_value */
403 \f
404
405
406 /*======================================================================
407  * Called by the disassembler to match an opcode value to an opcode structure.
408  *
409  * Arguments:
410  *      instr           The instruction (32 bits) to match.  This value
411  *                      may contain operand values as well as the opcode
412  *                      since they will be masked out anyway for this
413  *                      search.
414  *
415  * Returns the address of an opcode struct (from the opcode table) if the
416  * operand successfully matched an entry, or 0 if no match was found.
417  */
418
419 struct opcode *find_opcode (unsigned long instr)
420 {
421         struct opcode *ptr;
422         int top = 0;
423         int bottom = n_opcodes - 1;
424         int idx;
425
426   /*------------------------------------------------------------*/
427
428         while (top <= bottom) {
429                 idx = (top + bottom) >> 1;
430                 ptr = &opcodes[idx];
431
432                 if ((instr & ptr->mask) < ptr->opcode) {
433                         bottom = idx - 1;
434                 } else if ((instr & ptr->mask) > ptr->opcode) {
435                         top = idx + 1;
436                 } else {
437                         return ptr;
438                 }
439         }
440
441         return (struct opcode *) 0;
442 }                                                               /* find_opcode */
443 \f
444
445
446 /*======================================================================
447  * Called by the assembler to match an opcode name to an opcode structure.
448  *
449  * Arguments:
450  *      name            The text name of the opcode, e.g. "b", "mtspr", etc.
451  *
452  * The opcodes are sorted numerically by their instruction binary code
453  * so a search for the name cannot use the binary search used by the
454  * other find routine.
455  *
456  * Returns the address of an opcode struct (from the opcode table) if the
457  * name successfully matched an entry, or 0 if no match was found.
458  */
459
460 struct opcode *find_opcode_by_name (char *name)
461 {
462         int idx;
463
464   /*------------------------------------------------------------*/
465
466         downstring (name);
467
468         for (idx = 0; idx < n_opcodes; ++idx) {
469                 if (!strcmp (name, opcodes[idx].name))
470                         return &opcodes[idx];
471         }
472
473         return (struct opcode *) 0;
474 }                                                               /* find_opcode_by_name */
475 \f
476
477
478 /*======================================================================
479  * Convert the 'spr' operand from its numeric value to its symbolic name.
480  *
481  * Arguments:
482  *      value           The value of the 'spr' operand.  This value should
483  *                      be unmodified from its encoding in the instruction.
484  *                      the split-field computations will be performed
485  *                      here before the switch.
486  *
487  * Returns the address of a character array containing the name of the
488  * special purpose register defined by the 'value' parameter, or the
489  * address of a character array containing "???" if no match was found.
490  */
491
492 char *spr_name (int value)
493 {
494         unsigned short spr;
495         static char other[10];
496         int i;
497
498   /*------------------------------------------------------------*/
499
500         /* spr is a 10 bit field whose interpretation has the high and low
501            five-bit fields reversed from their encoding in the operand */
502
503         spr = ((value >> 5) & 0x1f) | ((value & 0x1f) << 5);
504
505         for (i = 0; i < n_sprs; ++i) {
506                 if (spr == spr_map[i].spr_val)
507                         return spr_map[i].spr_name;
508         }
509
510         sprintf (other, "%d", spr);
511         return other;
512 }                                                               /* spr_name */
513 \f
514
515
516 /*======================================================================
517  * Convert the 'spr' operand from its symbolic name to its numeric value
518  *
519  * Arguments:
520  *      name            The symbolic name of the 'spr' operand.  The
521  *                      split-field encoding will be done by this routine.
522  *                      NOTE: name can be a number.
523  *
524  * Returns the numeric value for the spr appropriate for encoding a machine
525  * instruction.  Returns 0 if unable to find the SPR.
526  */
527
528 int spr_value (char *name)
529 {
530         struct spr_info *sprp;
531         int spr;
532         int i;
533
534   /*------------------------------------------------------------*/
535
536         if (!name || !*name)
537                 return 0;
538
539         if (isdigit ((int) name[0])) {
540                 i = htonl (read_number (name));
541                 spr = ((i >> 5) & 0x1f) | ((i & 0x1f) << 5);
542                 return spr;
543         }
544
545         downstring (name);
546
547         for (i = 0; i < n_sprs; ++i) {
548                 sprp = &spr_map[i];
549
550                 if (strcmp (name, sprp->spr_name) == 0) {
551                         /* spr is a 10 bit field whose interpretation has the high and low
552                            five-bit fields reversed from their encoding in the operand */
553                         i = htonl (sprp->spr_val);
554                         spr = ((i >> 5) & 0x1f) | ((i & 0x1f) << 5);
555
556                         return spr;
557                 }
558         }
559
560         return 0;
561 }                                                               /* spr_value */
562 \f
563
564
565 /*======================================================================
566  * Convert the 'tbr' operand from its numeric value to its symbolic name.
567  *
568  * Arguments:
569  *      value           The value of the 'tbr' operand.  This value should
570  *                      be unmodified from its encoding in the instruction.
571  *                      the split-field computations will be performed
572  *                      here before the switch.
573  *
574  * Returns the address of a character array containing the name of the
575  * time base register defined by the 'value' parameter, or the address
576  * of a character array containing "???" if no match was found.
577  */
578
579 char *tbr_name (int value)
580 {
581         unsigned short tbr;
582
583   /*------------------------------------------------------------*/
584
585         /* tbr is a 10 bit field whose interpretation has the high and low
586            five-bit fields reversed from their encoding in the operand */
587
588         tbr = ((value >> 5) & 0x1f) | ((value & 0x1f) << 5);
589
590         if (tbr == 268)
591                 return "TBL";
592
593         else if (tbr == 269)
594                 return "TBU";
595
596
597         return "???";
598 }                                                               /* tbr_name */
599 \f
600
601
602 /*======================================================================
603  * Convert the 'tbr' operand from its symbolic name to its numeric value.
604  *
605  * Arguments:
606  *      name            The symbolic name of the 'tbr' operand.  The
607  *                      split-field encoding will be done by this routine.
608  *
609  * Returns the numeric value for the spr appropriate for encoding a machine
610  * instruction.  Returns 0 if unable to find the TBR.
611  */
612
613 int tbr_value (char *name)
614 {
615         int tbr;
616         int val;
617
618   /*------------------------------------------------------------*/
619
620         if (!name || !*name)
621                 return 0;
622
623         downstring (name);
624
625         if (isdigit ((int) name[0])) {
626                 val = read_number (name);
627
628                 if (val != 268 && val != 269)
629                         return 0;
630         } else if (strcmp (name, "tbl") == 0)
631                 val = 268;
632         else if (strcmp (name, "tbu") == 0)
633                 val = 269;
634         else
635                 return 0;
636
637         /* tbr is a 10 bit field whose interpretation has the high and low
638            five-bit fields reversed from their encoding in the operand */
639
640         val = htonl (val);
641         tbr = ((val >> 5) & 0x1f) | ((val & 0x1f) << 5);
642         return tbr;
643 }                                                               /* tbr_name */
644 \f
645
646
647 /*======================================================================
648  * The next several functions (handle_xxx) are the routines that handle
649  * disassembling the opcodes with simplified mnemonics.
650  *
651  * Arguments:
652  *      ctx             A pointer to the disassembler context record.
653  *
654  * Returns TRUE if the simpler form was printed or FALSE if it was not.
655  */
656
657 int handle_bc (struct ppc_ctx *ctx)
658 {
659         unsigned long bo;
660         unsigned long bi;
661         static struct opcode blt = { B_OPCODE (16, 0, 0), B_MASK, {O_BD, 0},
662         0, "blt", H_RELATIVE
663         };
664         static struct opcode bne =
665                         { B_OPCODE (16, 0, 0), B_MASK, {O_cr2, O_BD, 0},
666         0, "bne", H_RELATIVE
667         };
668         static struct opcode bdnz = { B_OPCODE (16, 0, 0), B_MASK, {O_BD, 0},
669         0, "bdnz", H_RELATIVE
670         };
671
672   /*------------------------------------------------------------*/
673
674         if (get_operand_value (ctx->op, ctx->instr, O_BO, &bo) == FALSE)
675                 return FALSE;
676
677         if (get_operand_value (ctx->op, ctx->instr, O_BI, &bi) == FALSE)
678                 return FALSE;
679
680         if ((bo == 12) && (bi == 0)) {
681                 ctx->op = &blt;
682                 sprintf (&ctx->data[ctx->datalen], "%-7s ", ctx->op->name);
683                 ctx->datalen += 8;
684                 print_operands (ctx);
685                 return TRUE;
686         } else if ((bo == 4) && (bi == 10)) {
687                 ctx->op = &bne;
688                 sprintf (&ctx->data[ctx->datalen], "%-7s ", ctx->op->name);
689                 ctx->datalen += 8;
690                 print_operands (ctx);
691                 return TRUE;
692         } else if ((bo == 16) && (bi == 0)) {
693                 ctx->op = &bdnz;
694                 sprintf (&ctx->data[ctx->datalen], "%-7s ", ctx->op->name);
695                 ctx->datalen += 8;
696                 print_operands (ctx);
697                 return TRUE;
698         }
699
700         return FALSE;
701 }                                                               /* handle_blt */
702 \f
703
704
705 /*======================================================================
706  * Outputs source line information for the disassembler.  This should
707  * be modified in the future to lookup the actual line of source code
708  * from the file, but for now this will do.
709  *
710  * Arguments:
711  *      filename        The address of a character array containing the
712  *                      absolute path and file name of the source file.
713  *
714  *      funcname        The address of a character array containing the
715  *                      name of the function (not C++ demangled (yet))
716  *                      to which this code belongs.
717  *
718  *      line_no         An integer specifying the source line number that
719  *                      generated this code.
720  *
721  *      pfunc           The address of a function to call to print the output.
722  *
723  *
724  * Returns TRUE if it was able to output the line info, or false if it was
725  * not.
726  */
727
728 int print_source_line (char *filename, char *funcname,
729                                            int line_no, int (*pfunc) (const char *))
730 {
731         char out_buf[256];
732
733   /*------------------------------------------------------------*/
734
735         (*pfunc) ("");                          /* output a newline */
736         sprintf (out_buf, "%s %s(): line %d", filename, funcname, line_no);
737         (*pfunc) (out_buf);
738
739         return TRUE;
740 }                                                               /* print_source_line */
741 \f
742
743
744 /*======================================================================
745  * Entry point for the PPC assembler.
746  *
747  * Arguments:
748  *      asm_buf         An array of characters containing the assembly opcode
749  *                      and operands to convert to a POWERPC machine
750  *                      instruction.
751  *
752  * Returns the machine instruction or zero.
753  */
754
755 unsigned long asmppc (unsigned long memaddr, char *asm_buf, int *err)
756 {
757         struct opcode *opc;
758         struct operand *oper[MAX_OPERANDS];
759         unsigned long instr;
760         unsigned long param;
761         char *ptr = asm_buf;
762         char scratch[20];
763         int i;
764         int w_operands = 0;                     /* wanted # of operands */
765         int n_operands = 0;                     /* # of operands read */
766         int asm_debug = 0;
767
768   /*------------------------------------------------------------*/
769
770         if (err)
771                 *err = 0;
772
773         if (get_word (&ptr, scratch) == 0)
774                 return 0;
775
776         /* Lookup the opcode structure based on the opcode name */
777         if ((opc = find_opcode_by_name (scratch)) == (struct opcode *) 0) {
778                 if (err)
779                         *err = E_ASM_BAD_OPCODE;
780                 return 0;
781         }
782
783         if (asm_debug) {
784                 printf ("asmppc: Opcode = \"%s\"\n", opc->name);
785         }
786
787         for (i = 0; i < 8; ++i) {
788                 if (opc->fields[i] == 0)
789                         break;
790                 ++w_operands;
791         }
792
793         if (asm_debug) {
794                 printf ("asmppc: Expecting %d operands\n", w_operands);
795         }
796
797         instr = opc->opcode;
798
799         /* read each operand */
800         while (n_operands < w_operands) {
801
802                 oper[n_operands] = &operands[opc->fields[n_operands] - 1];
803
804                 if (oper[n_operands]->hint & OH_SILENT) {
805                         /* Skip silent operands, they are covered in opc->opcode */
806
807                         if (asm_debug) {
808                                 printf ("asmppc: Operand %d \"%s\" SILENT\n", n_operands,
809                                                 oper[n_operands]->name);
810                         }
811
812                         ++n_operands;
813                         continue;
814                 }
815
816                 if (get_word (&ptr, scratch) == 0)
817                         break;
818
819                 if (asm_debug) {
820                         printf ("asmppc: Operand %d \"%s\" : \"%s\"\n", n_operands,
821                                         oper[n_operands]->name, scratch);
822                 }
823
824                 if ((param = parse_operand (memaddr, opc, oper[n_operands],
825                                                                         scratch, err)) == -1)
826                         return 0;
827
828                 instr |= param;
829                 ++n_operands;
830         }
831
832         if (n_operands < w_operands) {
833                 if (err)
834                         *err = E_ASM_NUM_OPERANDS;
835                 return 0;
836         }
837
838         if (asm_debug) {
839                 printf ("asmppc: Instruction = 0x%08lx\n", instr);
840         }
841
842         return instr;
843 }                                                               /* asmppc */
844 \f
845
846
847 /*======================================================================
848  * Called by the assembler to interpret a single operand
849  *
850  * Arguments:
851  *      ctx             A pointer to the disassembler context record.
852  *
853  * Returns 0 if the operand is ok, or -1 if it is bad.
854  */
855
856 int parse_operand (unsigned long memaddr, struct opcode *opc,
857                                    struct operand *oper, char *txt, int *err)
858 {
859         long data;
860         long mask;
861         int is_neg = 0;
862
863   /*------------------------------------------------------------*/
864
865         mask = (1 << oper->bits) - 1;
866
867         if (oper->hint & OH_ADDR) {
868                 data = read_number (txt);
869
870                 if (opc->hint & H_RELATIVE)
871                         data = data - memaddr;
872
873                 if (data < 0)
874                         is_neg = 1;
875
876                 data >>= 2;
877                 data &= (mask >> 1);
878
879                 if (is_neg)
880                         data |= 1 << (oper->bits - 1);
881         }
882
883         else if (oper->hint & OH_REG) {
884                 if (txt[0] == 'r' || txt[0] == 'R')
885                         txt++;
886                 else if (txt[0] == '%' && (txt[1] == 'r' || txt[1] == 'R'))
887                         txt += 2;
888
889                 data = read_number (txt);
890                 if (data > 31) {
891                         if (err)
892                                 *err = E_ASM_BAD_REGISTER;
893                         return -1;
894                 }
895
896                 data = htonl (data);
897         }
898
899         else if (oper->hint & OH_SPR) {
900                 if ((data = spr_value (txt)) == 0) {
901                         if (err)
902                                 *err = E_ASM_BAD_SPR;
903                         return -1;
904                 }
905         }
906
907         else if (oper->hint & OH_TBR) {
908                 if ((data = tbr_value (txt)) == 0) {
909                         if (err)
910                                 *err = E_ASM_BAD_TBR;
911                         return -1;
912                 }
913         }
914
915         else {
916                 data = htonl (read_number (txt));
917         }
918
919         return (data & mask) << oper->shift;
920 }                                                               /* parse_operand */
921
922
923 char *asm_error_str (int err)
924 {
925         switch (err) {
926         case E_ASM_BAD_OPCODE:
927                 return "Bad opcode";
928         case E_ASM_NUM_OPERANDS:
929                 return "Bad number of operands";
930         case E_ASM_BAD_REGISTER:
931                 return "Bad register number";
932         case E_ASM_BAD_SPR:
933                 return "Bad SPR name or number";
934         case E_ASM_BAD_TBR:
935                 return "Bad TBR name or number";
936         }
937
938         return "";
939 }                                                               /* asm_error_str */
940 \f
941
942
943 /*======================================================================
944  * Copy a word from one buffer to another, ignores leading white spaces.
945  *
946  * Arguments:
947  *      src             The address of a character pointer to the
948  *                      source buffer.
949  *      dest            A pointer to a character buffer to write the word
950  *                      into.
951  *
952  * Returns the number of non-white space characters copied, or zero.
953  */
954
955 int get_word (char **src, char *dest)
956 {
957         char *ptr = *src;
958         int nchars = 0;
959
960   /*------------------------------------------------------------*/
961
962         /* Eat white spaces */
963         while (*ptr && isblank (*ptr))
964                 ptr++;
965
966         if (*ptr == 0) {
967                 *src = ptr;
968                 return 0;
969         }
970
971         /* Find the text of the word */
972         while (*ptr && !isblank (*ptr) && (*ptr != ','))
973                 dest[nchars++] = *ptr++;
974         ptr = (*ptr == ',') ? ptr + 1 : ptr;
975         dest[nchars] = 0;
976
977         *src = ptr;
978         return nchars;
979 }                                                               /* get_word */
980 \f
981
982
983 /*======================================================================
984  * Convert a numeric string to a number, be aware of base notations.
985  *
986  * Arguments:
987  *      txt             The numeric string.
988  *
989  * Returns the converted numeric value.
990  */
991
992 long read_number (char *txt)
993 {
994         long val;
995         int is_neg = 0;
996
997   /*------------------------------------------------------------*/
998
999         if (txt == 0 || *txt == 0)
1000                 return 0;
1001
1002         if (*txt == '-') {
1003                 is_neg = 1;
1004                 ++txt;
1005         }
1006
1007         if (txt[0] == '0' && (txt[1] == 'x' || txt[1] == 'X'))  /* hex */
1008                 val = simple_strtoul (&txt[2], NULL, 16);
1009         else                                            /* decimal */
1010                 val = simple_strtoul (txt, NULL, 10);
1011
1012         if (is_neg)
1013                 val = -val;
1014
1015         return val;
1016 }                                                               /* read_number */
1017
1018
1019 int downstring (char *s)
1020 {
1021         if (!s || !*s)
1022                 return 0;
1023
1024         while (*s) {
1025                 if (isupper (*s))
1026                         *s = tolower (*s);
1027                 s++;
1028         }
1029
1030         return 0;
1031 }                                                               /* downstring */
1032 \f
1033
1034
1035 /*======================================================================
1036  * Examines the instruction at the current address and determines the
1037  * next address to be executed.  This will take into account branches
1038  * of different types so that a "step" and "next" operations can be
1039  * supported.
1040  *
1041  * Arguments:
1042  *      nextaddr        The address (to be filled in) of the next
1043  *                      instruction to execute.  This will only be a valid
1044  *                      address if TRUE is returned.
1045  *
1046  *      step_over       A flag indicating how to compute addresses for
1047  *                      branch statements:
1048  *                       TRUE  = Step over the branch (next)
1049  *                       FALSE = step into the branch (step)
1050  *
1051  * Returns TRUE if it was able to compute the address.  Returns FALSE if
1052  * it has a problem reading the current instruction or one of the registers.
1053  */
1054
1055 int find_next_address (unsigned char *nextaddr, int step_over,
1056                                            struct pt_regs *regs)
1057 {
1058         unsigned long pc;                       /* SRR0 register from PPC */
1059         unsigned long ctr;                      /* CTR register from PPC */
1060         unsigned long cr;                       /* CR register from PPC */
1061         unsigned long lr;                       /* LR register from PPC */
1062         unsigned long instr;            /* instruction at SRR0 */
1063         unsigned long next;                     /* computed instruction for 'next' */
1064         unsigned long step;                     /* computed instruction for 'step' */
1065         unsigned long addr = 0;         /* target address operand */
1066         unsigned long aa = 0;           /* AA operand */
1067         unsigned long lk = 0;           /* LK operand */
1068         unsigned long bo = 0;           /* BO operand */
1069         unsigned long bi = 0;           /* BI operand */
1070         struct opcode *op = 0;          /* opcode structure for 'instr' */
1071         int ctr_ok = 0;
1072         int cond_ok = 0;
1073         int conditional = 0;
1074         int branch = 0;
1075
1076   /*------------------------------------------------------------*/
1077
1078         if (nextaddr == 0 || regs == 0) {
1079                 printf ("find_next_address: bad args");
1080                 return FALSE;
1081         }
1082
1083         pc = regs->nip & 0xfffffffc;
1084         instr = INSTRUCTION (pc);
1085
1086         if ((op = find_opcode (instr)) == (struct opcode *) 0) {
1087                 printf ("find_next_address: can't parse opcode 0x%lx", instr);
1088                 return FALSE;
1089         }
1090
1091         ctr = regs->ctr;
1092         cr = regs->ccr;
1093         lr = regs->link;
1094
1095         switch (op->opcode) {
1096         case B_OPCODE (16, 0, 0):       /* bc */
1097         case B_OPCODE (16, 0, 1):       /* bcl */
1098         case B_OPCODE (16, 1, 0):       /* bca */
1099         case B_OPCODE (16, 1, 1):       /* bcla */
1100                 if (!get_operand_value (op, instr, O_BD, &addr) ||
1101                         !get_operand_value (op, instr, O_BO, &bo) ||
1102                         !get_operand_value (op, instr, O_BI, &bi) ||
1103                         !get_operand_value (op, instr, O_AA, &aa) ||
1104                         !get_operand_value (op, instr, O_LK, &lk))
1105                         return FALSE;
1106
1107                 if ((addr & (1 << 13)) != 0)
1108                         addr = addr - (1 << 14);
1109                 addr <<= 2;
1110                 conditional = 1;
1111                 branch = 1;
1112                 break;
1113
1114         case I_OPCODE (18, 0, 0):       /* b */
1115         case I_OPCODE (18, 0, 1):       /* bl */
1116         case I_OPCODE (18, 1, 0):       /* ba */
1117         case I_OPCODE (18, 1, 1):       /* bla */
1118                 if (!get_operand_value (op, instr, O_LI, &addr) ||
1119                         !get_operand_value (op, instr, O_AA, &aa) ||
1120                         !get_operand_value (op, instr, O_LK, &lk))
1121                         return FALSE;
1122
1123                 if ((addr & (1 << 23)) != 0)
1124                         addr = addr - (1 << 24);
1125                 addr <<= 2;
1126                 conditional = 0;
1127                 branch = 1;
1128                 break;
1129
1130         case XL_OPCODE (19, 528, 0):    /* bcctr */
1131         case XL_OPCODE (19, 528, 1):    /* bcctrl */
1132                 if (!get_operand_value (op, instr, O_BO, &bo) ||
1133                         !get_operand_value (op, instr, O_BI, &bi) ||
1134                         !get_operand_value (op, instr, O_LK, &lk))
1135                         return FALSE;
1136
1137                 addr = ctr;
1138                 aa = 1;
1139                 conditional = 1;
1140                 branch = 1;
1141                 break;
1142
1143         case XL_OPCODE (19, 16, 0):     /* bclr */
1144         case XL_OPCODE (19, 16, 1):     /* bclrl */
1145                 if (!get_operand_value (op, instr, O_BO, &bo) ||
1146                         !get_operand_value (op, instr, O_BI, &bi) ||
1147                         !get_operand_value (op, instr, O_LK, &lk))
1148                         return FALSE;
1149
1150                 addr = lr;
1151                 aa = 1;
1152                 conditional = 1;
1153                 branch = 1;
1154                 break;
1155
1156         default:
1157                 conditional = 0;
1158                 branch = 0;
1159                 break;
1160         }
1161
1162         if (conditional) {
1163                 switch ((bo & 0x1e) >> 1) {
1164                 case 0:                         /* 0000y */
1165                         if (--ctr != 0)
1166                                 ctr_ok = 1;
1167
1168                         cond_ok = !(cr & (1 << (31 - bi)));
1169                         break;
1170
1171                 case 1:                         /* 0001y */
1172                         if (--ctr == 0)
1173                                 ctr_ok = 1;
1174
1175                         cond_ok = !(cr & (1 << (31 - bi)));
1176                         break;
1177
1178                 case 2:                         /* 001zy */
1179                         ctr_ok = 1;
1180                         cond_ok = !(cr & (1 << (31 - bi)));
1181                         break;
1182
1183                 case 4:                         /* 0100y */
1184                         if (--ctr != 0)
1185                                 ctr_ok = 1;
1186
1187                         cond_ok = cr & (1 << (31 - bi));
1188                         break;
1189
1190                 case 5:                         /* 0101y */
1191                         if (--ctr == 0)
1192                                 ctr_ok = 1;
1193
1194                         cond_ok = cr & (1 << (31 - bi));
1195                         break;
1196
1197                 case 6:                         /* 011zy */
1198                         ctr_ok = 1;
1199                         cond_ok = cr & (1 << (31 - bi));
1200                         break;
1201
1202                 case 8:                         /* 1z00y */
1203                         if (--ctr != 0)
1204                                 ctr_ok = cond_ok = 1;
1205                         break;
1206
1207                 case 9:                         /* 1z01y */
1208                         if (--ctr == 0)
1209                                 ctr_ok = cond_ok = 1;
1210                         break;
1211
1212                 case 10:                                /* 1z1zz */
1213                         ctr_ok = cond_ok = 1;
1214                         break;
1215                 }
1216         }
1217
1218         if (branch && (!conditional || (ctr_ok && cond_ok))) {
1219                 if (aa)
1220                         step = addr;
1221                 else
1222                         step = addr + pc;
1223
1224                 if (lk)
1225                         next = pc + 4;
1226                 else
1227                         next = step;
1228         } else {
1229                 step = next = pc + 4;
1230         }
1231
1232         if (step_over == TRUE)
1233                 *(unsigned long *) nextaddr = next;
1234         else
1235                 *(unsigned long *) nextaddr = step;
1236
1237         return TRUE;
1238 }                                                               /* find_next_address */
1239
1240
1241 /*
1242  * Copyright (c) 2000 William L. Pitts and W. Gerald Hicks
1243  * All rights reserved.
1244  *
1245  * Redistribution and use in source and binary forms are freely
1246  * permitted provided that the above copyright notice and this
1247  * paragraph and the following disclaimer are duplicated in all
1248  * such forms.
1249  *
1250  * This software is provided "AS IS" and without any express or
1251  * implied warranties, including, without limitation, the implied
1252  * warranties of merchantability and fitness for a particular
1253  * purpose.
1254  */
1255
1256 #endif  /* CONFIG_COMMANDS & CFG_CMD_BEDBUG */