home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #31 / NN_1992_31.iso / spool / gnu / gdb / bug / 1330 < prev    next >
Encoding:
Text File  |  1992-12-22  |  15.8 KB  |  519 lines
  1. Newsgroups: gnu.gdb.bug
  2. Path: sparky!uunet!zaphod.mps.ohio-state.edu!cis.ohio-state.edu!eleceng.adelaide.EDU.AU!idall
  3. From: idall@eleceng.adelaide.EDU.AU
  4. Subject: gdb for ns32k.
  5. Message-ID: <9212211102.AA22423@life.ai.mit.edu>
  6. Sender: gnulists@ai.mit.edu
  7. Organization: GNUs Not Usenet
  8. Distribution: gnu
  9. Date: Mon, 21 Dec 1992 11:02:13 GMT
  10. Approved: bug-gdb@prep.ai.mit.edu
  11. Lines: 506
  12.  
  13. I tried to compile gdb 4.6 for the ns32k series (it is for a pc532
  14. running mach which isn't actually supported but this bug fix applies
  15. to any ns32k series machine). ns32k-pinsn.c would not compile because
  16. it couldn't find ns32k-opcode.h.
  17.  
  18. Sorry this bug report is not relative to gdb 4.7, but I don't
  19. think the problem has been fixed and I haven't got mach support
  20. in gdb 4.7.
  21.  
  22. There is some confusion over what include file has the opcode table to
  23. use (for ns32k-pinsn.c). There are two files include/opcode/ns32k.h
  24. and include/opcode/ns32k-options.h. The ns32k.h is essentially the
  25. same as the ns32k-opcode.h from gas.  Figuring that we don't want to
  26. maintain several multiple tables of opcodes, I modified ns32k-pinsn.c
  27. to use opcode/ns32k.h.  This required supporting a number of cases not
  28. previously supported.
  29.  
  30. Options (for string instructions, cinv etc) and register lists (for
  31. enter, exit, save and restore) are now interpreted properly and
  32. printed nicely in a format acceptable to gas. Also register names
  33. for the ns532 "processor" registers and  MMU registers are supported
  34. (these differ from earlier processors).
  35.  
  36. The diffs for the changes I made follow. There are some changes to
  37. ns32k.h but they arise from copying the ns32k.h from the gas
  38. distribution and are entirely in comments or ifdef'd out code.
  39.  
  40. Ian
  41.  
  42. *** ../dist/gdb/ns32k-pinsn.c    Sat Jun 13 15:38:03 1992
  43. --- gdb/ns32k-pinsn.c    Sun Dec 20 23:32:48 1992
  44. ***************
  45. *** 19,25 ****
  46.   
  47.   #include "defs.h"
  48.   #include "symtab.h"
  49. ! #include "ns32k-opcode.h"
  50.   #include "gdbcore.h"
  51.   
  52.   /* 32000 instructions are never longer than this.  */
  53. --- 19,25 ----
  54.   
  55.   #include "defs.h"
  56.   #include "symtab.h"
  57. ! #include "opcode/ns32k.h"
  58.   #include "gdbcore.h"
  59.   
  60.   /* 32000 instructions are never longer than this.  */
  61. ***************
  62. *** 26,32 ****
  63.   #define MAXLEN 62
  64.   
  65.   /* Number of elements in the opcode table.  */
  66. ! #define NOPCODES (sizeof notstrs / sizeof notstrs[0])
  67.   
  68.   #define NEXT_IS_ADDR    '|'
  69.   
  70. --- 26,32 ----
  71.   #define MAXLEN 62
  72.   
  73.   /* Number of elements in the opcode table.  */
  74. ! #define NOPCODES (sizeof ns32k_opcodes / sizeof ns32k_opcodes[0])
  75.   
  76.   #define NEXT_IS_ADDR    '|'
  77.   
  78. ***************
  79. *** 115,121 ****
  80.   /* Given a character C, does it represent a general addressing mode?  */
  81.   #define Is_gen(c) \
  82.     ((c) == 'F' || (c) == 'L' || (c) == 'B' \
  83. !    || (c) == 'W' || (c) == 'D' || (c) == 'A')
  84.   
  85.   /* Adressing modes.  */
  86.   #define Adrmod_index_byte 0x1c
  87. --- 115,121 ----
  88.   /* Given a character C, does it represent a general addressing mode?  */
  89.   #define Is_gen(c) \
  90.     ((c) == 'F' || (c) == 'L' || (c) == 'B' \
  91. !    || (c) == 'W' || (c) == 'D' || (c) == 'Q' || (c) == 'A')
  92.   
  93.   /* Adressing modes.  */
  94.   #define Adrmod_index_byte 0x1c
  95. ***************
  96. *** 155,162 ****
  97.   
  98.     first_word = *(unsigned short *) buffer;
  99.     for (i = 0; i < NOPCODES; i++)
  100. !     if ((first_word & ((1 << notstrs[i].detail.obits) - 1))
  101. !     == notstrs[i].detail.code)
  102.         break;
  103.   
  104.     /* Handle undefined instructions.  */
  105. --- 155,162 ----
  106.   
  107.     first_word = *(unsigned short *) buffer;
  108.     for (i = 0; i < NOPCODES; i++)
  109. !     if ((first_word & ((1 << ns32k_opcodes[i].opcode_id_size) - 1))
  110. !     == ns32k_opcodes[i].opcode_seed)
  111.         break;
  112.   
  113.     /* Handle undefined instructions.  */
  114. ***************
  115. *** 166,176 ****
  116.         return 1;
  117.       }
  118.   
  119. !   fprintf (stream, "%s", notstrs[i].name);
  120.   
  121. !   ioffset = notstrs[i].detail.ibits;
  122. !   aoffset = notstrs[i].detail.ibits;
  123. !   d = notstrs[i].detail.args;
  124.   
  125.     if (*d)
  126.       {
  127. --- 166,176 ----
  128.         return 1;
  129.       }
  130.   
  131. !   fprintf (stream, "%s", ns32k_opcodes[i].name);
  132.   
  133. !   ioffset = ns32k_opcodes[i].opcode_size;
  134. !   aoffset = ns32k_opcodes[i].opcode_size;
  135. !   d = ns32k_opcodes[i].operands;
  136.   
  137.     if (*d)
  138.       {
  139. ***************
  140. *** 250,255 ****
  141. --- 250,276 ----
  142.     return aoffset / 8;
  143.   }
  144.   
  145. + void decode_options(char *result, int Ivalue, unsigned int bits, char *options, char prefix)
  146. + {
  147. +   if (Ivalue & ~((1 << bits) - 1))
  148. +     sprintf(result, "0x%x", Ivalue);
  149. +   else
  150. +     {
  151. +       int i, need_comma = 0;
  152. +       *result++ = '[';
  153. +       for (i = 0; i <= (bits - 1); i++)
  154. +     if (Ivalue & (1 << i))
  155. +       {
  156. +         if (need_comma)
  157. +           *result++ = ',';
  158. +         if (prefix)
  159. +           *result++ = prefix;
  160. +         *result++ = options[i];
  161. +         need_comma = 1;
  162. +       }
  163. +       sprintf(result, "]");
  164. +     }
  165. + }
  166.   /* Print an instruction operand of category given by d.  IOFFSET is
  167.      the bit position below which small (<1 byte) parts of the operand can
  168.      be found (usually in the basic instruction, but for indexed
  169. ***************
  170. *** 277,287 ****
  171. --- 298,312 ----
  172.   
  173.     switch (d)
  174.       {
  175. +     case 'f':
  176. +       /* a "gen" operand but 5 bits from the end of instruction */
  177. +       ioffset -= 5;
  178.       case 'F':
  179.       case 'L':
  180.       case 'B':
  181.       case 'W':
  182.       case 'D':
  183. +     case 'Q':
  184.       case 'A':
  185.         addr_mode = bit_extract (buffer, ioffset-5, 5);
  186.         ioffset -= 5;
  187. ***************
  188. *** 289,294 ****
  189. --- 314,320 ----
  190.       {
  191.       case 0x0: case 0x1: case 0x2: case 0x3:
  192.       case 0x4: case 0x5: case 0x6: case 0x7:
  193. +       /* register mode R0 -- R7 */
  194.         switch (d)
  195.           {
  196.           case 'F':
  197. ***************
  198. *** 301,306 ****
  199. --- 327,333 ----
  200.         break;
  201.       case 0x8: case 0x9: case 0xa: case 0xb:
  202.       case 0xc: case 0xd: case 0xe: case 0xf:
  203. +       /* Register relative disp(R0 -- R7) */
  204.         disp1 = get_displacement (buffer, aoffsetp);
  205.         sprintf (result, "%d(r%d)", disp1, addr_mode & 7);
  206.         break;
  207. ***************
  208. *** 307,312 ****
  209. --- 334,340 ----
  210.       case 0x10:
  211.       case 0x11:
  212.       case 0x12:
  213. +       /* Memory relative disp2(disp1(FP, SP, SB)) */
  214.         disp1 = get_displacement (buffer, aoffsetp);
  215.         disp2 = get_displacement (buffer, aoffsetp);
  216.         sprintf (result, "%d(%d(%s))", disp2, disp1,
  217. ***************
  218. *** 313,321 ****
  219. --- 341,351 ----
  220.              addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb");
  221.         break;
  222.       case 0x13:
  223. +       /* reserved */
  224.         sprintf (result, "reserved");
  225.         break;
  226.       case 0x14:
  227. +       /* Immediate */
  228.         switch (d)
  229.           {
  230.           case 'B':
  231. ***************
  232. *** 355,387 ****
  233. --- 385,427 ----
  234.             *aoffsetp += 64;
  235.             sprintf (result, "$%g", Lvalue);
  236.             break;
  237. +         case 'Q':
  238. +           sprintf (result, "unimplimented");
  239. +           break;
  240.           }
  241.         break;
  242.       case 0x15:
  243. +       /* Absolute @disp */
  244.         disp1 = get_displacement (buffer, aoffsetp);
  245.         sprintf (result, "@|%d|", disp1);
  246.         break;
  247.       case 0x16:
  248. +       /* External EXT(disp1) + disp2 (Mod table stuff) */
  249.         disp1 = get_displacement (buffer, aoffsetp);
  250.         disp2 = get_displacement (buffer, aoffsetp);
  251.         sprintf (result, "EXT(%d) + %d", disp1, disp2);
  252.         break;
  253.       case 0x17:
  254. +       /* Top of stack tos */
  255.         sprintf (result, "tos");
  256.         break;
  257.       case 0x18:
  258. +       /* Memory space disp(FP) */
  259.         disp1 = get_displacement (buffer, aoffsetp);
  260.         sprintf (result, "%d(fp)", disp1);
  261.         break;
  262.       case 0x19:
  263. +       /* Memory space disp(SP) */
  264.         disp1 = get_displacement (buffer, aoffsetp);
  265.         sprintf (result, "%d(sp)", disp1);
  266.         break;
  267.       case 0x1a:
  268. +       /* Memory space disp(SB) */
  269.         disp1 = get_displacement (buffer, aoffsetp);
  270.         sprintf (result, "%d(sb)", disp1);
  271.         break;
  272.       case 0x1b:
  273. +       /* Memory space disp(PC) */
  274.         disp1 = get_displacement (buffer, aoffsetp);
  275.         sprintf (result, "|%d|", addr + disp1);
  276.         break;
  277. ***************
  278. *** 389,394 ****
  279. --- 429,435 ----
  280.       case 0x1d:
  281.       case 0x1e:
  282.       case 0x1f:
  283. +       /* Scaled index basemode[R0 -- R7:B,W,D,Q] */
  284.         index = bit_extract (buffer, index_offset - 8, 3);
  285.         print_insn_arg (d, index_offset, aoffsetp, buffer, addr,
  286.                 result, 0);
  287. ***************
  288. *** 403,408 ****
  289. --- 444,458 ----
  290.         break;
  291.       }
  292.         break;
  293. +     case 'd':
  294. +       sprintf (result, "%d", get_displacement (buffer, aoffsetp));
  295. +       break;
  296. +     case 'H':
  297. +     case 'p':
  298. +       sprintf (result, "%c%d%c", NEXT_IS_ADDR,
  299. +            addr + get_displacement (buffer, aoffsetp),
  300. +            NEXT_IS_ADDR);
  301. +       break;
  302.       case 'q':
  303.         Ivalue = bit_extract (buffer, ioffset-4, 4);
  304.         Ivalue = sign_extend (Ivalue, 4);
  305. ***************
  306. *** 409,431 ****
  307.         sprintf (result, "%d", Ivalue);
  308.         ioffset -= 4;
  309.         break;
  310.       case 'r':
  311.         Ivalue = bit_extract (buffer, ioffset-3, 3);
  312.         sprintf (result, "r%d", Ivalue&7);
  313.         ioffset -= 3;
  314.         break;
  315. !     case 'd':
  316. !       sprintf (result, "%d", get_displacement (buffer, aoffsetp));
  317.         break;
  318. !     case 'p':
  319. !       sprintf (result, "%c%d%c", NEXT_IS_ADDR,
  320. !            addr + get_displacement (buffer, aoffsetp),
  321. !            NEXT_IS_ADDR);
  322.         break;
  323. !     case 'i':
  324.         Ivalue = bit_extract (buffer, *aoffsetp, 8);
  325.         *aoffsetp += 8;
  326. !       sprintf (result, "0x%x", Ivalue);
  327.         break;
  328.       }
  329.     return ioffset;
  330. --- 459,541 ----
  331.         sprintf (result, "%d", Ivalue);
  332.         ioffset -= 4;
  333.         break;
  334. +     case 'i':
  335. +       Ivalue = bit_extract (buffer, *aoffsetp, 8);
  336. +       *aoffsetp += 8;
  337. +       sprintf (result, "0x%x", Ivalue);
  338. +       break;
  339.       case 'r':
  340.         Ivalue = bit_extract (buffer, ioffset-3, 3);
  341.         sprintf (result, "r%d", Ivalue&7);
  342.         ioffset -= 3;
  343.         break;
  344. !     case 'O':
  345. !       Ivalue = bit_extract (buffer, ioffset-9, 9);
  346. !       decode_options(result, Ivalue, 4, "ifmc", 0);
  347. !       ioffset -= 9;
  348.         break;
  349. !     case 'C':
  350. !       Ivalue = bit_extract (buffer, ioffset-4, 4);
  351. !       decode_options (result, Ivalue, 3, "dia", 0);
  352. !       ioffset -= 4;
  353.         break;
  354. !     case 'S':
  355. !       Ivalue = bit_extract (buffer, ioffset - 8, 8);
  356. !       decode_options(result, Ivalue, 3, "bwu", 0);
  357. !       ioffset -= 8;
  358. !       break;
  359. !     case 'U':
  360.         Ivalue = bit_extract (buffer, *aoffsetp, 8);
  361. +       decode_options(result, Ivalue, 8, "01234567", 'r');
  362.         *aoffsetp += 8;
  363. !       break;
  364. !     case 'u':
  365. !       Ivalue = bit_extract (buffer, *aoffsetp, 8);
  366. !       decode_options(result, Ivalue, 8, "76543210", 'r');
  367. !       *aoffsetp += 8;
  368. !       break;
  369. !     case 'M':
  370. !       {
  371. ! #ifdef NS32532_MMU_REGS    
  372. !     char *mreg[] = { "", "", "", "", "", "", "", "",
  373. !                "", "mcr", "msr", "tear", "ptb0", "ptb1", "ivar0", "ivar1"};
  374. ! #else
  375. !     char *mreg[] = {"bpr0", "bpr1", "", "", "pf0", "pf1", "", "",
  376. !               "sc", "", "msr", "bcnt", "ptb0", "ptb1", "", "eia"};
  377. ! #endif
  378. !     int nmreg = sizeof(mreg)/sizeof(mreg[0]);
  379. !     Ivalue =  bit_extract (buffer, ioffset-4, 4);
  380. !     sprintf(result, "%s", Ivalue > nmreg? "": mreg[Ivalue]);
  381. !     ioffset -= 4;
  382. !       }
  383. !       break;
  384. !     case 'P':
  385. !       {
  386. ! #ifdef NS32532_CPU_REGS
  387. !     char *creg[] = {"us", "dcr", "bpc", "dsr", "car", "", "", "",
  388. !               "fp", "sp", "sb", "usp", "cfg", "psr", "intbase", "mod"};
  389. ! #else
  390. !     char *creg[] = {"upsr", "", "", "", "", "", "", "",
  391. !               "fp", "sp", "sb", "", "", "psr", "intbase", "mod"};
  392. ! #endif
  393. !     int ncreg = sizeof(creg)/sizeof(creg[0]);
  394. !     Ivalue =  bit_extract (buffer, ioffset-4, 4);
  395. !     sprintf(result, "%s", Ivalue > ncreg? "": creg[Ivalue]);
  396. !     ioffset -= 4;
  397. !       }
  398. !       break;
  399. !     case 'g':
  400. !       Ivalue = bit_extract (buffer, *aoffsetp + 5, 3);
  401. !       sprintf(result, "%d", Ivalue);
  402. !       /* Don't increment aoffset, leave it to G */
  403. !       break;
  404. !     case 'G':
  405. !       Ivalue = bit_extract (buffer, *aoffsetp , 5);
  406. !       sprintf(result, "%d", Ivalue + 1);
  407. !       *aoffsetp += 8;
  408. !       break;
  409. !     default:
  410. !       sprintf(result, "<unsupported>");
  411.         break;
  412.       }
  413.     return ioffset;
  414. *** ../dist/gdb/depend    Wed Jul 15 12:21:47 1992
  415. --- gdb/depend    Thu Dec 17 01:50:24 1992
  416. ***************
  417. *** 211,217 ****
  418.   nindy-tdep.o : nindy-tdep.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  419.     tm.h config.status symtab.h ${srcdir}/../include/obstack.h frame.h 
  420.   ns32k-pinsn.o : ns32k-pinsn.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  421. !   tm.h config.status symtab.h ${srcdir}/../include/obstack.h ns32k-opcode.h gdbcore.h ${srcdir}/../include/bfd.h 
  422.   objfiles.o : objfiles.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  423.     tm.h config.status ${srcdir}/../include/bfd.h ${srcdir}/../include/obstack.h symtab.h symfile.h objfiles.h 
  424.   parse.o : parse.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  425. --- 211,217 ----
  426.   nindy-tdep.o : nindy-tdep.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  427.     tm.h config.status symtab.h ${srcdir}/../include/obstack.h frame.h 
  428.   ns32k-pinsn.o : ns32k-pinsn.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  429. !   tm.h config.status symtab.h ${srcdir}/../include/obstack.h ${srcdir}/../include/opcode/ns32k.h gdbcore.h ${srcdir}/../include/bfd.h 
  430.   objfiles.o : objfiles.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  431.     tm.h config.status ${srcdir}/../include/bfd.h ${srcdir}/../include/obstack.h symtab.h symfile.h objfiles.h 
  432.   parse.o : parse.c defs.h ${srcdir}/../include/ansidecl.h xm.h config.status ${srcdir}/../include/fopen-same.h \
  433. *** ../dist/include/opcode/ns32k.h    Sun Dec  1 12:52:40 1991
  434. --- include/opcode/ns32k.h    Sun Dec 20 16:41:01 1992
  435. ***************
  436. *** 46,52 ****
  437.       Q : quad-word            "
  438.       A : double-word        gen-address-form ie no regs allowed
  439.       d : displacement
  440. !     b : displacement - pc relative addressing  acb
  441.       p : displacement - pc relative addressing  br bcond bsr cxp
  442.       q : quick
  443.       i : immediate (8 bits)
  444. --- 46,52 ----
  445.       Q : quad-word            "
  446.       A : double-word        gen-address-form ie no regs allowed
  447.       d : displacement
  448. !     b : displacement - pc relative addressing  acb  (no longer used)
  449.       p : displacement - pc relative addressing  br bcond bsr cxp
  450.       q : quick
  451.       i : immediate (8 bits)
  452. ***************
  453. *** 91,153 ****
  454.                      is a plain constant */
  455.     char default_model;        /* is a plain label */
  456.   };
  457. - 
  458. - #ifdef comment
  459. - /* This section was from the gdb version of this file. */
  460. - 
  461. - #ifndef ns32k_opcodeT
  462. - #define ns32k_opcodeT int
  463. - #endif /* no ns32k_opcodeT */
  464. - 
  465. - struct not_wot            /* ns32k opcode table: wot to do with this */
  466. -                 /* particular opcode */
  467. - {
  468. -   int obits;        /* number of opcode bits */
  469. -   int ibits;        /* number of instruction bits */
  470. -   ns32k_opcodeT    code;    /* op-code (may be > 8 bits!) */
  471. -   char *args;        /* how to compile said opcode */
  472. - };
  473. - 
  474. - struct not            /* ns32k opcode text */
  475. - {
  476. -   char *            name;    /* opcode name: lowercase string  [key]  */
  477. -   struct not_wot    detail;    /* rest of opcode table          [datum] */
  478. - };
  479. - 
  480. - /* Instructions look like this:
  481. -     
  482. -    basic instruction--1, 2, or 3 bytes
  483. -    index byte for operand A, if operand A is indexed--1 byte
  484. -    index byte for operand B, if operand B is indexed--1 byte
  485. -    addressing extension for operand A
  486. -    addressing extension for operand B
  487. -    implied operands
  488. - 
  489. -    Operand A is the operand listed first in the following opcode table.
  490. -    Operand B is the operand listed second in the following opcode table.
  491. -    All instructions have at most 2 general operands, so this is enough.
  492. -    The implied operands are associated with operands other than A and B.
  493. - 
  494. -    Each operand has a digit and a letter.
  495. -    
  496. -    The digit gives the position in the assembly language.  The letter,
  497. -    one of the following, tells us what kind of operand it is.  */
  498. - 
  499. - /* F : 32 bit float
  500. -  * L : 64 bit float
  501. -  * B : byte
  502. -  * W : word
  503. -  * D : double-word
  504. -  * Q : quad-word
  505. -  * d : displacement
  506. -  * q : quick
  507. -  * i : immediate (8 bits)
  508. -  * r : register number (3 bits)
  509. -  * p : displacement - pc relative addressing
  510. - */
  511. - 
  512. - 
  513. - #endif /* comment */
  514.   
  515.   static const struct ns32k_opcode ns32k_opcodes[]=
  516.   {
  517. --- 91,96 ----
  518.  
  519.