![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to =rt-changes CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GNU Debugger] / gdb|
Return to =rt-changes CVS log | Up to [GNU Debugger] / gdb |
1.1 root 1: From: zs01#@andrew.cmu.edu (Zalman Stern)
2: Date: Sun, 24 May 87 03:20:57 edt
3: To: [email protected]
4: Subject: RT diffs for gdb version 2.1
5:
6: Here are the new files, followed by the diffs to old files. The first file below
7: is ITCMODS which is my attempt to document some of our changes. Unfortunately,
8: it has not been maintained particularly well and notably does not include info
9: about our changes to support the HIGH-C compiler. One big change we put in was
10: to use a number of initialize routines instead of the "linked list of object
11: modules" that is used on other machines. The RT object file format appears to
12: have a variable size header before the code, making it very difficult
13: (impossible?) to get the initialization stuff to work. If you have any
14: questions, don't hesitate to send me mail.
15:
16: -Z-
17:
18: Only in .: ITCMODS
19:
20: blockframe.c:
21: set_current_frame now takes an extra argument.
22: RT specific code for interpreting and caching of trace table entries.
23: Added initialize routine.
24:
25: breakpoint.c:
26: Added new_breakpoint_commands flag to prevent incorrect interpretation of command lists containing a continue statement.
27: Modified do_breakpoint_commands to know about new_breakpoint_commands.
28: Modified clear_breakpoint_commands to set new_breakpoint_commands.
29: Added initialize routine.
30:
31: core.c:
32: RT specific code to find the uarea.
33: RT specific code to indicate the start of the data segment.
34: set_current_frame now takes an extra argument.
35: Added initialize routine.
36:
37: dbxread.c:
38: Added support for the Camphor dynamic loading system. (All under #ifdef CAMPHOR).
39: Fix for multiple declarations of register variables (i.e. they are declared twice). The fix munges the incorrect declaration (i.e. the one which is not register).
40: set_rel_command to set relocation offset for camphor loaded files. (Under #ifdef CAMPHOR).
41: add_file_command to append a file's symbols to the current symbol table instead of replacing it. (Under #ifdef CAMPHOR).
42: RT specific code to deal with function names being _.foo instead of _foo.
43: Added initialize routine.
44:
45: Feb 8, 1987 Zalman Stern.
46: Added test in symbol_file_command to see if file was compiled with debugging. If not print an error message instead of dumping core.
47: Added same test in add_file_command and made it run through BZPATH, CLASSPATH, and PATH in that order (Under #ifdef CAMPHOR).
48:
49: environ.c:
50: Fixed error in calculating new size of a reallocated environment.
51:
52: eval.c:
53: Added initialize routine.
54:
55: expread.y:
56: Moved alloca call out of variable initializations.
57:
58: findvar.c:
59: Added initialize routine.
60:
61: firstfile.c:
62: Added main initialization driver routine.
63:
64: frame.h:
65: Added RT specific declarations to hold frame information, and to deal with trace table caching.
66:
67: ibm032-pinsn.c:
68: New file, contains RT disassembler.
69:
70: ibm032-opcode.h:
71: New file, contains RT opcode definitions.
72:
73: infcmd.c
74: Changed code to use csh instead of sh to avoid the anoyance of the environment bug.
75: Added initialize routine.
76:
77: inflow.c:
78: Added initialize routine.
79:
80: infrun.c:
81: set_current_frame now takes an extra argument.
82: Added some code to deal with stopping in the middle of a camphor link. (Under #ifdef CAMPHOR).
83: Added RT specific code to get the return values from the right registers. Replaces code that was there for RT.
84: RT specific code to do a "POP_DUMMY_FRAME." Dummy frames are to store more complete state than a normal frame. Makes calling a function in inferior more reliable. Perhaps this should be expanded to other machine types.
85: Added initialize routine.
86:
87: Feb 9, 1987 Zalman Stern.
88: Added call to select_frame after popping a stack dummy frame in normal_stop. This fixes the bug where you could not print variables without doing a "frame 0" after printing an expression with a function call in it.
89:
90: iniitialize.h:
91: Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
92:
93: m-ibm032.h:
94: New file, contains RT specific macros and variables.
95:
96: param.h:
97: Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
98:
99: pinsn.c:
100: Changed file to use #ifdef's for machine type. Allows one to use same sources for different machines.
101:
102: printcmd.c:
103: Moved alloca calls out of variable initialization.
104: Added initialize routine.
105:
106: source.c:
107: Added initialize routine.
108:
109: stack.c:
110: Added initialize routine.
111:
112: symmisc.c:
113: Added initialize routine.
114:
115: symtab.c:
116: RT specific code to deal with function names being _.foo instead of _foo.
117: Added initialize routine.
118:
119: utils.c:
120: Added comment.
121:
122: valarith.c:
123: Added initialize routine.
124:
125: valops.c:
126: Added initialize routine.
127:
128: valprint.c:
129: Added initialize routine.
130:
131: values.c:
132: Added initialize routine.
133:
134: Only in .: ibm032-opcode.h
135:
136: /* The opcode table consists of a 256 element array containing an
137: * instruction mnemonic and an instruction type field. This can be
138: * indexed directly by the first eight bits of an RT instruction.
139: * The instruction type consists of a type field and some flags.
140: * In addition to this, there is an ifdef'd out "instruction" table
141: * at the end of the file. This is an alphabetical listing of the instructions
142: * containing mnemonic, opcode, and type. This is useful for modification
143: * purposes. There is also some code in the ifdef to convert the
144: * instruction table into an opcode table.
145: */
146:
147: /* Various useful bit masks. */
148: #define ibm032_typeMask 0x0f /* Mask to get actual type info out of instruction type. */
149: #define LOW4 0x0f
150: #define HIGH4 0xf0
151: #define LOW16 0x0000ffff
152: #define HIGH16 0xffff0000
153: #define LOW20 0x000fffff
154: #define LOW24 0x00ffffff
155:
156: /* Instruction types consist of a type id in the low 4 bits and flags above that. */
157:
158: /* Flags. */
159: #define ibm032_conditional 0x10
160: #define ibm032_negative 0x20
161:
162: /* Format types. */
163: #define ibm032_JI 0x0 /* Jump immediate. */
164: #define ibm032_X 0x1 /* ??? */
165:
166: /* These next ones are in a special bit position. Do not change their defines. */
167: #define ibm032_DS0 0x2 /* Data short with no shift for immediate value. */
168: #define ibm032_DS1 0x3 /* Data short with 1 bit shift for immediate value. */
169: #define ibm032_DS2 0x4 /* Data short with 2 bit shift for immediate value */
170: #define ibm032_DSShiftOffset ibm032_DS0 /* Offset to get shift value from ibm032_DS? types. */
171:
172: #define ibm032_RR 0x5 /* R format where second argument is a register */
173: #define ibm032_RI 0x6 /* R format where second argument is 4 bit immediate. */
174: #define ibm032_BI 0x7 /* Branch immediate. */
175: #define ibm032_BA 0x8 /* Branch absolute. */
176: #define ibm032_D 0x9 /* Data. */
177:
178: /* What an instruction looks like. */
179: struct ibm032_opcode {
180: char *mnemonic; /* the name. NULL indicates illegal instruction. */
181: int type; /* See above. */
182: };
183:
184: #define MAXOPCODES 256 /* Pretty well hardwired. */
185:
186: #ifndef BUILDTABLE
187: /* The actual data. */
188: struct ibm032_opcode ibm032_opcodes[] = {
189: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
190: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
191: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
192: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
193: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
194: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
195: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
196: {"j%s", ibm032_JI | ibm032_conditional | ibm032_negative},
197: {"j%s", ibm032_JI | ibm032_conditional},
198: {"j%s", ibm032_JI | ibm032_conditional},
199: {"j%s", ibm032_JI | ibm032_conditional},
200: {"j%s", ibm032_JI | ibm032_conditional},
201: {"j%s", ibm032_JI | ibm032_conditional},
202: {"j%s", ibm032_JI | ibm032_conditional},
203: {"j%s", ibm032_JI | ibm032_conditional},
204: {"j%s", ibm032_JI | ibm032_conditional},
205: {"stcs", ibm032_DS0},
206: {"stcs", ibm032_DS0},
207: {"stcs", ibm032_DS0},
208: {"stcs", ibm032_DS0},
209: {"stcs", ibm032_DS0},
210: {"stcs", ibm032_DS0},
211: {"stcs", ibm032_DS0},
212: {"stcs", ibm032_DS0},
213: {"stcs", ibm032_DS0},
214: {"stcs", ibm032_DS0},
215: {"stcs", ibm032_DS0},
216: {"stcs", ibm032_DS0},
217: {"stcs", ibm032_DS0},
218: {"stcs", ibm032_DS0},
219: {"stcs", ibm032_DS0},
220: {"stcs", ibm032_DS0},
221: {"sths", ibm032_DS1},
222: {"sths", ibm032_DS1},
223: {"sths", ibm032_DS1},
224: {"sths", ibm032_DS1},
225: {"sths", ibm032_DS1},
226: {"sths", ibm032_DS1},
227: {"sths", ibm032_DS1},
228: {"sths", ibm032_DS1},
229: {"sths", ibm032_DS1},
230: {"sths", ibm032_DS1},
231: {"sths", ibm032_DS1},
232: {"sths", ibm032_DS1},
233: {"sths", ibm032_DS1},
234: {"sths", ibm032_DS1},
235: {"sths", ibm032_DS1},
236: {"sths", ibm032_DS1},
237: {"sts", ibm032_DS2},
238: {"sts", ibm032_DS2},
239: {"sts", ibm032_DS2},
240: {"sts", ibm032_DS2},
241: {"sts", ibm032_DS2},
242: {"sts", ibm032_DS2},
243: {"sts", ibm032_DS2},
244: {"sts", ibm032_DS2},
245: {"sts", ibm032_DS2},
246: {"sts", ibm032_DS2},
247: {"sts", ibm032_DS2},
248: {"sts", ibm032_DS2},
249: {"sts", ibm032_DS2},
250: {"sts", ibm032_DS2},
251: {"sts", ibm032_DS2},
252: {"sts", ibm032_DS2},
253: {"lcs", ibm032_DS0},
254: {"lcs", ibm032_DS0},
255: {"lcs", ibm032_DS0},
256: {"lcs", ibm032_DS0},
257: {"lcs", ibm032_DS0},
258: {"lcs", ibm032_DS0},
259: {"lcs", ibm032_DS0},
260: {"lcs", ibm032_DS0},
261: {"lcs", ibm032_DS0},
262: {"lcs", ibm032_DS0},
263: {"lcs", ibm032_DS0},
264: {"lcs", ibm032_DS0},
265: {"lcs", ibm032_DS0},
266: {"lcs", ibm032_DS0},
267: {"lcs", ibm032_DS0},
268: {"lcs", ibm032_DS0},
269: {"lhas", ibm032_DS1},
270: {"lhas", ibm032_DS1},
271: {"lhas", ibm032_DS1},
272: {"lhas", ibm032_DS1},
273: {"lhas", ibm032_DS1},
274: {"lhas", ibm032_DS1},
275: {"lhas", ibm032_DS1},
276: {"lhas", ibm032_DS1},
277: {"lhas", ibm032_DS1},
278: {"lhas", ibm032_DS1},
279: {"lhas", ibm032_DS1},
280: {"lhas", ibm032_DS1},
281: {"lhas", ibm032_DS1},
282: {"lhas", ibm032_DS1},
283: {"lhas", ibm032_DS1},
284: {"lhas", ibm032_DS1},
285: {"cas", ibm032_X},
286: {"cas", ibm032_X},
287: {"cas", ibm032_X},
288: {"cas", ibm032_X},
289: {"cas", ibm032_X},
290: {"cas", ibm032_X},
291: {"cas", ibm032_X},
292: {"cas", ibm032_X},
293: {"cas", ibm032_X},
294: {"cas", ibm032_X},
295: {"cas", ibm032_X},
296: {"cas", ibm032_X},
297: {"cas", ibm032_X},
298: {"cas", ibm032_X},
299: {"cas", ibm032_X},
300: {"cas", ibm032_X},
301: {"ls", ibm032_DS2},
302: {"ls", ibm032_DS2},
303: {"ls", ibm032_DS2},
304: {"ls", ibm032_DS2},
305: {"ls", ibm032_DS2},
306: {"ls", ibm032_DS2},
307: {"ls", ibm032_DS2},
308: {"ls", ibm032_DS2},
309: {"ls", ibm032_DS2},
310: {"ls", ibm032_DS2},
311: {"ls", ibm032_DS2},
312: {"ls", ibm032_DS2},
313: {"ls", ibm032_DS2},
314: {"ls", ibm032_DS2},
315: {"ls", ibm032_DS2},
316: {"ls", ibm032_DS2},
317: {0, 0},
318: {0, 0},
319: {0, 0},
320: {0, 0},
321: {0, 0},
322: {0, 0},
323: {0, 0},
324: {0, 0},
325: {"b%s", ibm032_BI | ibm032_conditional | ibm032_negative},
326: {"b%sx", ibm032_BI | ibm032_conditional | ibm032_negative},
327: {"bala", ibm032_BA},
328: {"balax", ibm032_BA},
329: {"bali", ibm032_BI},
330: {"balix", ibm032_BI},
331: {"b%s", ibm032_BI | ibm032_conditional},
332: {"b%sx", ibm032_BI | ibm032_conditional},
333: {"ais", ibm032_RI},
334: {"inc", ibm032_RI},
335: {"sis", ibm032_RI},
336: {"dec", ibm032_RI},
337: {"cis", ibm032_RI},
338: {"clrsb", ibm032_RI},
339: {"mfs", ibm032_RR},
340: {"setsb", ibm032_RI},
341: {"clrbu", ibm032_RI},
342: {"clrbl", ibm032_RI},
343: {"setbu", ibm032_RI},
344: {"setbl", ibm032_RI},
345: {"mftbiu", ibm032_RI},
346: {"mftbil", ibm032_RI},
347: {"mttbiu", ibm032_RI},
348: {"mttbil", ibm032_RI},
349: {"sari", ibm032_RI},
350: {"sari16", ibm032_RI},
351: {0, 0},
352: {0, 0},
353: {"lis", ibm032_RI},
354: {0, 0},
355: {0, 0},
356: {0, 0},
357: {"sri", ibm032_RI},
358: {"sri16", ibm032_RI},
359: {"sli", ibm032_RI},
360: {"sli16", ibm032_RI},
361: {"srpi", ibm032_RI},
362: {"srpi16", ibm032_RI},
363: {"slpi", ibm032_RI},
364: {"slpi16", ibm032_RI},
365: {"sar", ibm032_RR},
366: {"exts", ibm032_RR},
367: {"sf", ibm032_RR},
368: {"cl", ibm032_RR},
369: {"c", ibm032_RR},
370: {"mts", ibm032_RR},
371: {"d", ibm032_RR},
372: {0, 0},
373: {"sr", ibm032_RR},
374: {"srp", ibm032_RR},
375: {"sl", ibm032_RR},
376: {"slp", ibm032_RR},
377: {"mftb", ibm032_RR},
378: {"tgte", ibm032_RR},
379: {"tlt", ibm032_RR},
380: {"mttb", ibm032_RR},
381: {"svc", ibm032_D},
382: {"ai", ibm032_D},
383: {"cal16", ibm032_D},
384: {"oiu", ibm032_D},
385: {"oil", ibm032_D},
386: {"nilz", ibm032_D},
387: {"nilo", ibm032_D},
388: {"xil", ibm032_D},
389: {"cal", ibm032_D},
390: {"lm", ibm032_D},
391: {"lha", ibm032_D},
392: {"ior", ibm032_D},
393: {"ti", ibm032_D},
394: {"l", ibm032_D},
395: {"lc", ibm032_D},
396: {"tsh", ibm032_D},
397: {"lps", ibm032_D},
398: {"aei", ibm032_D},
399: {"sfi", ibm032_D},
400: {"cli", ibm032_D},
401: {"ci", ibm032_D},
402: {"niuz", ibm032_D},
403: {"niuo", ibm032_D},
404: {"xiu", ibm032_D},
405: {"cau", ibm032_D},
406: {"stm", ibm032_D},
407: {"lh", ibm032_D},
408: {"iow", ibm032_D},
409: {"sth", ibm032_D},
410: {"st", ibm032_D},
411: {"stc", ibm032_D},
412: {0, 0},
413: {"abs", ibm032_RR},
414: {"a", ibm032_RR},
415: {"s", ibm032_RR},
416: {"o", ibm032_RR},
417: {"twoc", ibm032_RR},
418: {"n", ibm032_RR},
419: {"m", ibm032_RR},
420: {"x", ibm032_RR},
421: {"b%sr", ibm032_RR | ibm032_conditional | ibm032_negative},
422: {"b%srx", ibm032_RR | ibm032_conditional | ibm032_negative},
423: {0, 0},
424: {"lhs", ibm032_RR},
425: {"balr", ibm032_RR},
426: {"balrx", ibm032_RR},
427: {"b%sr", ibm032_RR | ibm032_conditional},
428: {"b%srx", ibm032_RR | ibm032_conditional},
429: {"wait", ibm032_RR},
430: {"ae", ibm032_RR},
431: {"se", ibm032_RR},
432: {"ca16", ibm032_RR},
433: {"onec", ibm032_RR},
434: {"clz", ibm032_RR},
435: {0, 0},
436: {0, 0},
437: {0, 0},
438: {"mc03", ibm032_RR},
439: {"mc13", ibm032_RR},
440: {"mc23", ibm032_RR},
441: {"mc33", ibm032_RR},
442: {"mc30", ibm032_RR},
443: {"mc31", ibm032_RR},
444: {"mc32", ibm032_RR},
445: };
446:
447: #else
448: struct ibm032_opcode ibm032_opcodes[MAXOPCODES];
449:
450: struct ibm032_instruction {
451: char *mnemonic; /* Mnemonic for this instruction */
452: char opcode; /* Numerical value of opcode. */
453: int type; /* This instructions format. */
454: };
455:
456: struct ibm032_instruction ibm032_instructions[] =
457: {
458: {"a", 0xe1, ibm032_RR},
459: {"abs", 0xe0, ibm032_RR},
460: {"ae", 0xf1, ibm032_RR},
461: {"aei", 0xd1, ibm032_D},
462: {"ai", 0xc1, ibm032_D},
463: {"ais", 0x90, ibm032_RI},
464: {"bala", 0x8a, ibm032_BA},
465: {"balax", 0x8b, ibm032_BA},
466: {"bali", 0x8c, ibm032_BI},
467: {"balix", 0x8d, ibm032_BI},
468: {"balr", 0xec, ibm032_RR},
469: {"balrx", 0xed, ibm032_RR},
470: {"b%s", 0x8e, ibm032_BI | ibm032_conditional},
471: {"b%sr", 0xee, ibm032_RR | ibm032_conditional},
472: {"b%srx", 0xef, ibm032_RR | ibm032_conditional},
473: {"b%sx", 0x8f, ibm032_BI | ibm032_conditional},
474: {"b%s", 0x88, ibm032_BI | ibm032_conditional | ibm032_negative},
475: {"b%sr", 0xe8, ibm032_RR | ibm032_conditional | ibm032_negative},
476: {"b%srx", 0xe9, ibm032_RR | ibm032_conditional | ibm032_negative},
477: {"b%sx", 0x89, ibm032_BI | ibm032_conditional | ibm032_negative},
478: {"c", 0xb4, ibm032_RR},
479: {"cal", 0xc8, ibm032_D},
480: {"cal16", 0xc2, ibm032_D},
481: {"cas", 0x60, ibm032_X},
482: {"cau", 0xd8, ibm032_D},
483: {"ca16", 0xf3, ibm032_RR},
484: {"ci", 0xd4, ibm032_D},
485: {"cis", 0x94, ibm032_RI},
486: {"cl", 0xb3, ibm032_RR},
487: {"cli", 0xd3, ibm032_D},
488: {"clrbl", 0x99, ibm032_RI},
489: {"clrbu", 0x98, ibm032_RI},
490: {"clrsb", 0x95, ibm032_RI},
491: {"clz", 0xf5, ibm032_RR},
492: {"d", 0xb6, ibm032_RR},
493: {"dec", 0x93, ibm032_RI},
494: {"exts", 0xb1, ibm032_RR},
495: {"inc", 0x91, ibm032_RI},
496: {"ior", 0xcb, ibm032_D},
497: {"iow", 0xdb, ibm032_D},
498:
499: {"j%s", 0x08, ibm032_JI | ibm032_conditional},
500: {"j%s", 0x00, ibm032_JI | ibm032_conditional | ibm032_negative},
501:
502: {"l", 0xcd, ibm032_D},
503: {"lc", 0xce, ibm032_D},
504: {"lcs", 0x40, ibm032_DS0},
505: {"lh", 0xda, ibm032_D},
506: {"lha", 0xca, ibm032_D},
507: {"lhas", 0x50, ibm032_DS1},
508: {"lhs", 0xeb, ibm032_RR},
509: {"lis", 0xa4, ibm032_RI},
510: {"lm", 0xc9, ibm032_D},
511: {"lps", 0xd0, ibm032_D},
512: {"ls", 0x70, ibm032_DS2},
513: {"m", 0xe6, ibm032_RR},
514: {"mc03", 0xf9, ibm032_RR},
515: {"mc13", 0xfa, ibm032_RR},
516: {"mc23", 0xfb, ibm032_RR},
517: {"mc33", 0xfc, ibm032_RR},
518: {"mc30", 0xfd, ibm032_RR},
519: {"mc31", 0xfe, ibm032_RR},
520: {"mc32", 0xff, ibm032_RR},
521: {"mfs", 0x96, ibm032_RR},
522: {"mftb", 0xbc, ibm032_RR},
523: {"mftbil", 0x9d, ibm032_RI},
524: {"mftbiu", 0x9c, ibm032_RI},
525: {"mts", 0xb5, ibm032_RR},
526: {"mttb", 0xbf, ibm032_RR},
527: {"mttbil", 0x9f, ibm032_RI},
528: {"mttbiu", 0x9e, ibm032_RI},
529: {"n", 0xe5, ibm032_RR},
530:
531: {"nilo", 0xc6, ibm032_D},
532: {"nilz", 0xc5, ibm032_D},
533: {"niuo", 0xd6, ibm032_D},
534: {"niuz", 0xd5, ibm032_D},
535: {"o", 0xe3, ibm032_RR},
536: {"oil", 0xc4, ibm032_D},
537: {"oiu", 0xc3, ibm032_D},
538: {"onec", 0xf4, ibm032_RR},
539: {"s", 0xe2, ibm032_RR},
540: {"sar", 0xb0, ibm032_RR},
541: {"sari", 0xa0, ibm032_RI},
542: {"sari16", 0xa1, ibm032_RI},
543: {"se", 0xf2, ibm032_RR},
544: {"setbl", 0x9b, ibm032_RI},
545: {"setbu", 0x9a, ibm032_RI},
546: {"setsb", 0x97, ibm032_RI},
547: {"sf", 0xb2, ibm032_RR},
548:
549: {"sfi", 0xd2, ibm032_D},
550:
551: {"sis", 0x92, ibm032_RI},
552: {"sl", 0xba, ibm032_RR},
553: {"sli", 0xaa, ibm032_RI},
554: {"sli16", 0xab, ibm032_RI},
555: {"slp", 0xbb, ibm032_RR},
556: {"slpi", 0xae, ibm032_RI},
557: {"slpi16", 0xaf, ibm032_RI},
558: {"sr", 0xb8, ibm032_RR},
559: {"sri", 0xa8, ibm032_RI},
560: {"sri16", 0xa9, ibm032_RI},
561: {"srp", 0xb9, ibm032_RR},
562: {"srpi", 0xac, ibm032_RI},
563: {"srpi16", 0xad, ibm032_RI},
564:
565: {"st", 0xdd, ibm032_D},
566:
567: {"stc", 0xde, ibm032_D},
568: {"stcs", 0x10, ibm032_DS0},
569: {"sth", 0xdc, ibm032_D},
570: {"sths", 0x20, ibm032_DS1},
571: {"stm", 0xd9, ibm032_D},
572: {"sts", 0x30, ibm032_DS2},
573: {"svc", 0xc0, ibm032_D},
574: {"tgte", 0xbd, ibm032_RR},
575: {"ti", 0xcc, ibm032_D},
576: {"tlt", 0xbe, ibm032_RR},
577: {"tsh", 0xcf, ibm032_D},
578: {"twoc", 0xe4, ibm032_RR},
579: {"wait", 0xf0, ibm032_RR},
580: {"x", 0xe7, ibm032_RR},
581: {"xil", 0xc7, ibm032_D},
582: {"xiu", 0xd7, ibm032_D}
583: };
584:
585: /* Code to generate the packed opcode table from the instructions table. */
586:
587: #include <stdio.h>
588:
589: char *typeNames[] = {
590: "ibm032_JI",
591: "ibm032_X",
592: "ibm032_DS0",
593: "ibm032_DS1",
594: "ibm032_DS2",
595: "ibm032_RR",
596: "ibm032_RI",
597: "ibm032_BI",
598: "ibm032_BA",
599: "ibm032_D"
600: };
601:
602: main()
603: {
604:
605: int i, j, opcode, type;
606:
607: for (j = (sizeof(ibm032_instructions) / sizeof(struct ibm032_instruction)); j >= 0; j--) {
608: opcode = ibm032_instructions[j].opcode;
609: switch (ibm032_instructions[j].type & ibm032_typeMask) {
610: case ibm032_JI:
611: i = 7;
612: break;
613: case ibm032_X:
614: case ibm032_DS0:
615: case ibm032_DS1:
616: case ibm032_DS2:
617: i = 15;
618: break;
619: case ibm032_RR:
620: case ibm032_RI:
621: default:
622: i = 0;
623: break;
624: }
625: for (;i >= 0; i--) {
626: ibm032_opcodes[opcode + i].mnemonic = ibm032_instructions[j].mnemonic;
627: ibm032_opcodes[opcode + i].type = ibm032_instructions[j].type;
628: }
629: }
630:
631: printf("struct ibm032_opcode ibm032_opcodes[] = {\n");
632: for ( j = 0; j < 256; j++) {
633: type = ibm032_opcodes[j].type;
634: if (ibm032_opcodes[j].mnemonic != NULL)
635: printf(" {\"%s\",\t\t%s%s%s},\n", ibm032_opcodes[j].mnemonic,
636: typeNames[type & ibm032_typeMask],
637: (type & ibm032_conditional) ? " | ibm032_conditional" : "",
638: (type & ibm032_negative) ? " | ibm032_negative" : "");
639: else
640: printf(" {0,\t\t\t0},\n");
641: }
642: printf("};\n");
643: }
644: #endif /* BUILDTABLE */
645:
646: Only in .: ibm032-pinsn.c
647:
648: /* Print ibm032 instructions for GDB, the GNU debugger.
649: Copyright (C) 1986 Free Software Foundation, Inc.
650:
651: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
652: WARRANTY. No author or distributor accepts responsibility to anyone
653: for the consequences of using it or for whether it serves any
654: particular purpose or works at all, unless he says so in writing.
655: Refer to the GDB General Public License for full details.
656:
657: Everyone is granted permission to copy, modify and redistribute GDB,
658: but only under the conditions described in the GDB General Public
659: License. A copy of this license is supposed to have been given to you
660: along with GDB so you can know your rights and responsibilities. It
661: should be in a file named COPYING. Among other things, the copyright
662: notice and this notice must be preserved on all copies.
663:
664: In other words, go ahead and share GDB, but don't try to stop
665: anyone else from sharing it farther. Help stamp out software hoarding!
666: */
667:
668: #include <stdio.h>
669:
670: #include "defs.h"
671: #include "param.h"
672: #include "symtab.h"
673: #include "ibm032-opcode.h"
674:
675: /* ibm032 instructions are never longer than this many bytes. */
676: #define MAXLEN 4
677:
678: extern char *reg_names[];
679:
680: static char *mapCondition();
681:
682:
683: /* Print the ibm032 instruction at address MEMADDR in debugged memory,
684: on STREAM. Returns length of the instruction, in bytes. */
685:
686: int
687: print_insn (memaddr, stream)
688: CORE_ADDR memaddr;
689: FILE *stream;
690: {
691: unsigned char buffer[MAXLEN];
692: int opcodeIndex, instructionBits, type;
693: char *mnemonic;
694:
695: read_memory (memaddr, buffer, MAXLEN);
696: instructionBits = (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3]; /* Get it into an int for easy use. */
697:
698: if ((mnemonic = ibm032_opcodes[opcodeIndex = buffer[0]].mnemonic) == NULL)
699: {
700: fprintf (stream, "0%o", (instructionBits & HIGH16) >> 16);
701: return 2;
702: }
703: type = ibm032_opcodes[opcodeIndex].type;
704: if (!(type & ibm032_conditional)) {
705: fprintf (stream, "%s", mnemonic);
706:
707: switch (type) {
708:
709: int displacement; /* Used for sign extensions. */
710: char *sign;
711:
712: case ibm032_X:
713: fprintf(stream, "\t%s, %s(%s)", reg_names[buffer[0] & LOW4], (buffer[1] & HIGH4) ? (reg_names[(buffer[1] & HIGH4) >> 4]) : "", reg_names[buffer[1] & LOW4]);
714: return 2;
715: case ibm032_DS0:
716: case ibm032_DS1:
717: case ibm032_DS2:
718: fprintf(stream, "\t%s, %x", reg_names[(buffer[1] & HIGH4) >> 4], (buffer[0] & LOW4) << (ibm032_opcodes[opcodeIndex].type - ibm032_DSShiftOffset)); /* Hacked to shift imediate field. */
719: if (buffer[1] & LOW4)
720: fprintf(stream, "(%s)", reg_names[buffer[1] & LOW4]);
721: return 2;
722: case ibm032_RR:
723: fprintf(stream, "\t%s, %s", reg_names[(buffer[1] & HIGH4) >> 4], reg_names[buffer[1] & 0x0f]);
724: return 2;
725: case ibm032_RI:
726: fprintf(stream, "\t%s, %x", reg_names[(buffer[1] & HIGH4) >> 4], buffer[1] & LOW4);
727: return 2;
728: case ibm032_BI:
729: fprintf(stream, "\t%s, ", reg_names[(buffer[1] & HIGH4) >> 4]);
730: displacement = (instructionBits & LOW20);
731: if ((displacement & (1 << 19)) != 0) /* Cover sign extension. */
732: displacement |= 0xfff00000;
733: print_address(memaddr + (displacement * 2), stream); /* Need sign extension. */
734: return 4;
735: case ibm032_BA:
736: print_address((instructionBits & LOW24) & ~1, stream);
737: return 4;
738: case ibm032_D:
739: displacement = (instructionBits & LOW16);
740: if ((displacement & (1 << 15)) != 0) { /* Cover sign extension. */
741: displacement = - (displacement | 0xffff0000);
742: sign = "-";
743: }
744: else
745: sign = "";
746: fprintf(stream, "\t%s, %s, %s%x", reg_names[(buffer[1] & HIGH4) >> 4], reg_names[buffer[1] & LOW4], sign, displacement);
747: return 4;
748: }
749: }
750: else { /* Conditional branches are hacked. */
751: switch (type & 0x0f) {
752:
753: int displacement;
754:
755: case ibm032_JI:
756: fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, buffer[0] & LOW4));
757: putc('\t', stream);
758: print_address((buffer[1] << 1) + memaddr, stream);
759: return 2;
760: case ibm032_BI:
761: fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[1] & HIGH4) >> 4));
762: putc('\t', stream);
763: displacement = (instructionBits & LOW20);
764: if ((displacement & (1 << 19)) != 0) /* Cover sign extension. */
765: displacement |= 0xfff00000;
766: print_address((displacement * 2) + memaddr, stream);
767: return 4;
768: case ibm032_RR:
769: fprintf(stream, ibm032_opcodes[opcodeIndex].mnemonic, mapCondition(type & ibm032_negative, (buffer[1] & HIGH4) >> 4));
770: fprintf(stream, "\t%s", reg_names[buffer[1] & LOW4]);
771: return 2;
772: }
773: }
774: }
775:
776: /* Converts a 4 bit "conditional specifier" into a semi-meaningful name. */
777: static char *mapCondition(negative, conditionBits)
778: int conditionBits;
779: {
780:
781: char *condition;
782:
783: if (negative)
784: switch (conditionBits) {
785: case 0x8:
786: condition = "";
787: break;
788: case 0x9:
789: condition = "ge";
790: break;
791: case 0xa:
792: condition = "ne";
793: break;
794: case 0xb:
795: condition = "le";
796: break;
797: case 0xc:
798: condition = "nc";
799: break;
800: case 0xd: /* Reserved. */
801: condition = "notbogus";
802: break;
803: case 0xe:
804: condition = "no";
805: break;
806: case 0xf:
807: condition = "ntb";
808: break;
809: default:
810: condition = "notbogus";
811: break;
812: }
813: else
814: switch (conditionBits) {
815: case 0x8:
816: condition = "nop";
817: break;
818: case 0x9:
819: condition = "lt";
820: break;
821: case 0xa:
822: condition = "eq";
823: break;
824: case 0xb:
825: condition = "gt";
826: break;
827: case 0xc:
828: condition = "c";
829: break;
830: case 0xd: /* Reserved. */
831: condition = "bogus";
832: break;
833: case 0xe:
834: condition = "o";
835: break;
836: case 0xf:
837: condition = "tb";
838: break;
839: default:
840: condition = "bogus";
841: break;
842: }
843: return condition;
844: }
845:
846: Only in .: m-ibm032.h
847:
848: /* Parameters for execution on an IBM RT, for GDB, the GNU debugger.
849: Copyright (C) 1986 Free Software Foundation, Inc.
850:
851: GDB is distributed in the hope that it will be useful, but WITHOUT ANY
852: WARRANTY. No author or distributor accepts responsibility to anyone
853: for the consequences of using it or for whether it serves any
854: particular purpose or works at all, unless he says so in writing.
855: Refer to the GDB General Public License for full details.
856:
857: Everyone is granted permission to copy, modify and redistribute GDB,
858: but only under the conditions described in the GDB General Public
859: License. A copy of this license is supposed to have been given to you
860: along with GDB so you can know your rights and responsibilities. It
861: should be in a file named COPYING. Among other things, the copyright
862: notice and this notice must be preserved on all copies.
863:
864: In other words, go ahead and share GDB, but don't try to stop
865: anyone else from sharing it farther. Help stamp out software hoarding!
866: */
867:
868: /* Define this if the C compiler puts an underscore at the front
869: of external names before giving them to the linker. */
870:
871: #define NAMES_HAVE_UNDERSCORE
872:
873: /* Offset from address of function to start of its code.
874: Zero on most machines. */
875:
876: #define FUNCTION_START_OFFSET 0
877:
878: /* Advance PC across any function entry prologue instructions
879: to reach some "real" code. */
880:
881: #define SKIP_PROLOGUE(pc) \
882: { register int op = read_memory_integer (pc, 1) & 0x00ff; \
883: if (op == 0xd9) { \
884: pc += 4; \
885: op = read_memory_integer (pc, 2); \
886: if ((op & 0xff00) == 0xc100) { /* pcc prolog add r1, number */ \
887: pc += 4; \
888: op = read_memory_integer (pc, 1) & 0x00ff; \
889: if (op == 0x6e) { /* cas r14, 0 */ \
890: pc += 2; \
891: op = read_memory_integer (pc, 2) & 0xffff; \
892: if (op == 0xc8d1) pc += 4; /* cal r13, junk(r1) */ \
893: } \
894: } \
895: else if ((op & 0xffff) == 0x6e00) { /* hc prolog cas r14, 0 */ \
896: pc += 4; \
897: op = read_memory_integer(pc, 1) & 0xff; \
898: if (op == 0x6d) { /* cas r13 junk, probably */ \
899: pc += 2; \
900: op = read_memory_integer(pc, 2) & 0xffff; \
901: if (op == 0xc811) pc += 4; /* cal r1, foo(r1) */ \
902: } \
903: } \
904: } \
905: while (1) { \
906: /* now watch for st, sth, stc, and short versions thereof, cas instructions and exts */ \
907: /* which are all used to store the parameters from r2-r5 onto the stack or into reg vars */ \
908: op = read_memory_integer (pc, 2); \
909: if ((op & 0xff00) == 0x3000 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
910: else if ((op & 0xff00) == 0x2300 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
911: else if ((op & 0xff00) == 0x1b00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
912: else if ((op & 0xff00) == 0x6c00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 2; \
913: else if ((op & 0xff00) == 0xb100) pc += 2; /* extend sign */ \
914: else if ((op & 0xff00) == 0xdd00 && (op & 0xf0) >= 0x20 && (op & 0xf0) <= 0x50) pc += 4; \
915: else break; \
916: } \
917: }
918:
919: /* Immediately after a function call, return the saved pc.
920: Can't go through the frames for this because on some machines
921: the new frame is not set up until the new function executes
922: some instructions. */
923:
924: #define SAVED_PC_AFTER_CALL(frame) \
925: read_register (15)
926:
927: /* This is the amount to subtract from u.u_ar0
928: to get the offset in the core file of the register values. */
929:
930: #define KERNEL_U_ADDR (0x20000000 - NBPG * (UPAGES))
931:
932: /* Address of end of stack space. */
933:
934: /* extra page is for the "red zone" */
935: #define STACK_END_ADDR (0x20000000 - NBPG * (UPAGES+1))
936:
937: /* Stack grows downward. */
938:
939: #define INNER_THAN <
940:
941: /* Sequence of bytes for breakpoint instruction. */
942:
943: #define BREAKPOINT {0xbd, 0x00}
944:
945: /* Amount PC must be decremented by after a breakpoint.
946: This is often the number of bytes in BREAKPOINT
947: but not always. */
948:
949: #define DECR_PC_AFTER_BREAK 0
950:
951: /* Nonzero if instruction at PC is a return instruction. */
952:
953: #define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) & 0x00ff == 0xc9)
954:
955: /* Return 1 if P points to an invalid floating point value. */
956:
957: #define INVALID_FLOAT(p) 0 /* Just a first guess; not checked */
958:
959: /* Say how long (ordinary) registers are. */
960:
961: #define REGISTER_TYPE long
962:
963: /* Number of machine registers */
964:
965: #define NUM_REGS 18
966:
967: /* Initializer for an array of names of registers.
968: There should be NUM_REGS strings in this initializer. */
969:
970: #define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15", "iar", "mq"}
971:
972: /* Register numbers of various important registers.
973: Note that some of these values are "real" register numbers,
974: and correspond to the general registers of the machine,
975: and some are "phony" register numbers which are too large
976: to be actual register numbers as far as the user is concerned
977: but do serve to get the desired values when passed to read_register. */
978:
979: #define FP_REGNUM 13 /* Contains address of executing stack frame */
980: #define SP_REGNUM 1 /* Contains address of top of stack */
981: #define PS_REGNUM 17 /* Contains processor status */
982: #define PC_REGNUM 16 /* Contains program counter */
983:
984: #define REGISTER_U_ADDR(addr, blockend, regno) \
985: { addr = blockend + regno * 4; }
986:
987: /* Total amount of space needed to store our copies of the machine's
988: register state, the array `registers'. */
989: #define REGISTER_BYTES (NUM_REGS*4)
990:
991: /* Index within `registers' of the first byte of the space for
992: register N. */
993:
994: #define REGISTER_BYTE(N) ((N) * 4)
995:
996: /* Number of bytes of storage in the actual machine representation
997: for register N. On the vax, all regs are 4 bytes. */
998:
999: #define REGISTER_RAW_SIZE(N) 4
1000:
1001: /* Number of bytes of storage in the program's representation
1002: for register N. On the vax, all regs are 4 bytes. */
1003:
1004: #define REGISTER_VIRTUAL_SIZE(N) 4
1005:
1006: /* Largest value REGISTER_RAW_SIZE can have. */
1007:
1008: #define MAX_REGISTER_RAW_SIZE 4
1009:
1010: /* Largest value REGISTER_VIRTUAL_SIZE can have. */
1011:
1012: #define MAX_REGISTER_VIRTUAL_SIZE 4
1013:
1014: /* Nonzero if register N requires conversion
1015: from raw format to virtual format. */
1016:
1017: #define REGISTER_CONVERTIBLE(N) 0
1018:
1019: /* Convert data from raw format for register REGNUM
1020: to virtual format for register REGNUM. */
1021:
1022: #define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \
1023: bcopy ((FROM), (TO), 4);
1024:
1025: /* Convert data from virtual format for register REGNUM
1026: to raw format for register REGNUM. */
1027:
1028: #define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \
1029: bcopy ((FROM), (TO), 4);
1030:
1031: /* Return the GDB type object for the "standard" data type
1032: of data in register N. */
1033:
1034: #define REGISTER_VIRTUAL_TYPE(N) builtin_type_int
1035:
1036: /* Describe the pointer in each stack frame to the previous stack frame
1037: (its caller). */
1038:
1039: /* FRAME_CHAIN takes a frame's nominal address
1040: and produces the frame's chain-pointer.
1041:
1042: FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address
1043: and produces the nominal address of the caller frame.
1044:
1045: However, if FRAME_CHAIN_VALID returns zero,
1046: it means the given frame is the outermost one and has no caller.
1047: In that case, FRAME_CHAIN_COMBINE is not used. */
1048:
1049: /* In the case of the Sun, the frame's nominal address
1050: is the address of a 4-byte word containing the calling frame's address. */
1051:
1052: #define FRAME_CHAIN(thisframe) (rt_prev_frame(thisframe))
1053:
1054: #define FRAME_CHAIN_VALID(chain, thisframe) \
1055: (chain >= 0x10000000 && chain < 0x20000000)
1056:
1057: #define FRAME_CHAIN_COMBINE(chain, thisframe) (chain)
1058:
1059: /* Define other aspects of the stack frame. */
1060:
1061: #define FRAME_SAVED_PC(frame) (rt_frame_reg(frame, 15))
1062:
1063: #define FRAME_ARGS_ADDRESS(fi) (rt_frame_args(fi.frame))
1064:
1065: #define FRAME_LOCALS_ADDRESS(fi) (fi.frame)
1066:
1067: /* Return number of args passed to a frame.
1068: Can return -1, meaning no way to tell. */
1069:
1070: #define FRAME_NUM_ARGS(val, fi) \
1071: {register struct rt_frame *tf; \
1072: tf = get_cached_frame(fi.frame); \
1073: val = -1; \
1074: if (tf) val = tf->nParms;\
1075: }
1076:
1077: /* Return number of bytes at start of arglist that are not really args. */
1078:
1079: #define FRAME_ARGS_SKIP 0
1080:
1081: /* Put here the code to store, into a struct frame_saved_regs,
1082: the addresses of the saved registers of frame described by FRAME_INFO.
1083: This includes special registers such as pc and fp saved in special
1084: ways in the stack frame. sp is even more special:
1085: the address we return for it IS the sp for the next frame. */
1086:
1087: #define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \
1088: { register int regnum; \
1089: register struct rt_frame *tf; \
1090: register CORE_ADDR next_addr; \
1091: bzero (&(frame_saved_regs), sizeof (frame_saved_regs)); \
1092: tf = get_cached_frame((frame_info).frame); \
1093: if (tf) { \
1094: for(regnum = tf->firstReg; regnum < 16; regnum++) { \
1095: (frame_saved_regs).regs[regnum] = tf->firstRLoc+ 4*(regnum - tf->firstReg); \
1096: } \
1097: } \
1098: }
1099:
1100:
1101: /* Things needed for making the inferior call functions. */
1102:
1103: /* Push an empty stack frame, to record the current PC, etc. */
1104:
1105: #define PUSH_DUMMY_FRAME \
1106: { register CORE_ADDR sp = read_register (SP_REGNUM);\
1107: register int regnum; \
1108: sp = push_word (sp, read_register (PC_REGNUM)); \
1109: for (regnum = 15; regnum >= 0; regnum--) \
1110: sp = push_word (sp, read_register (regnum)); \
1111: write_register (FP_REGNUM, sp+64); \
1112: write_register (SP_REGNUM, sp); }
1113:
1114: /* discard special frame pushed by PUSH_DUMMY_FRAME */
1115: #define POP_DUMMY_FRAME \
1116: {register CORE_ADDR sp; \
1117: register int regnum; \
1118: sp = read_register(FP_REGNUM)-64; \
1119: for(regnum = 0; regnum < 16;regnum++) { \
1120: write_register(regnum, read_memory_integer(sp, 4)); \
1121: sp += 4; \
1122: } \
1123: /* now get the pc */ \
1124: write_register(PC_REGNUM, read_memory_integer(sp, 4)); \
1125: sp += 4; \
1126: }
1127:
1128: /* Discard from the stack the innermost frame, restoring all registers. */
1129: /* THIS ROUTINE DOES NOT SET R1 (SP_REGNUM) CORRECTLY */
1130: /* REALLY MUST CONSULT TRACE TBL TO FIND OUT FRAME SIZE */
1131: #define POP_FRAME \
1132: { register CORE_ADDR fp = read_register (FP_REGNUM); \
1133: register int regnum; \
1134: register struct rt_frame *tf; \
1135: tf = (struct rt_frame *) get_cached_frame(fp); \
1136: if (tf) { \
1137: for(regnum = tf->firstReg; regnum < 16; regnum++) { \
1138: write_register(regnum, \
1139: read_memory_integer (tf->firstRLoc + 4*(regnum-tf->firstReg), 4) \
1140: ); \
1141: } \
1142: write_register(PC_REGNUM, read_register(15)); \
1143: write_register(SP_REGNUM, tf->firstRLoc + 4*(16-tf->firstReg) + 36); \
1144: } \
1145: }
1146:
1147: /* This sequence of words is the instructions
1148: ls r2,0(r1) 2 bytes pick up args
1149: ls r3,4(r1) 2 bytes pick up args
1150: ls r4,8(r1) 2 bytes pick up args
1151: ls r5,c(r1) 2 bytes pick up args
1152: cal r1,16(r1) 4 bytes fix up ap (==sp)
1153: cal16 r15,<low> 4 bytes do call
1154: oiu r15,<high>(r15) 4
1155: lr r0,r15 2
1156: ls r15,0(r15) 2
1157: balr r15 2
1158: bpt 2 get back to gdb
1159: <4 byte trace table> 4
1160:
1161: This is 16 bytes.
1162: */
1163:
1164: #define CALL_DUMMY {0x70217131, 0x72417351, 0xc8110010, 0xc2f06969, \
1165: 0xc3ff6969, 0x60f070ff, 0xecffbd00, 0xdf7fdf00}
1166:
1167: #define CALL_DUMMY_LENGTH 32
1168:
1169: #define CALL_DUMMY_START_OFFSET 0
1170:
1171: /* Insert the specified number of args and function address
1172: into a call sequence of the above form stored at DUMMYNAME. */
1173:
1174: #define FIX_CALL_DUMMY(dummyname, fun, nargs) \
1175: { *((short *)(((char *)dummyname)+14)) = fun&0xffff; \
1176: *((short *)(((char *)dummyname)+18)) = (fun>>16)&0xffff; \
1177: }
1178:
1179: /* Interface definitions for kernel debugger KDB. */
1180:
1181: /* Map machine fault codes into signal numbers.
1182: First subtract 0, divide by 4, then index in a table.
1183: Faults for which the entry in this table is 0
1184: are not handled by KDB; the program's own trap handler
1185: gets to handle then. */
1186:
1187: #define FAULT_CODE_ORIGIN 0
1188: #define FAULT_CODE_UNITS 4
1189: #define FAULT_TABLE \
1190: { 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \
1191: 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \
1192: 0, 0, 0, 0, 0, 0, 0, 0, \
1193: SIGILL }
1194:
1195: /* Start running with a stack stretching from BEG to END.
1196: BEG and END should be symbols meaningful to the assembler.
1197: This is used only for kdb, which we do not support. */
1198:
1199: #define INIT_STACK(beg, end) \
1200: { }
1201:
1202: /* Push the frame pointer register on the stack. */
1203: #define PUSH_FRAME_PTR \
1204: { }
1205:
1206: /* Copy the top-of-stack to the frame pointer register. */
1207: #define POP_FRAME_PTR \
1208: { }
1209:
1210: /* After KDB is entered by a fault, push all registers
1211: that GDB thinks about (all NUM_REGS of them),
1212: so that they appear in order of ascending GDB register number.
1213: The fault code will be on the stack beyond the last register. */
1214:
1215: #define PUSH_REGISTERS \
1216: { }
1217:
1218: /* Assuming the registers (including processor status) have been
1219: pushed on the stack in order of ascending GDB register number,
1220: restore them and return to the address in the saved PC register. */
1221:
1222: #define POP_REGISTERS \
1223: { }
1224:
1225: Only in .: m-ibm032init.h
1226:
1227: /* This is how the size of an individual .o file's text segment
1228: is rounded on a sun. */
1229:
1230: #define FILEADDR_ROUND(addr) ((addr + 3) & -4)
1231:
1232: diff -c ../../gnu/gdb/blockframe.c ./blockframe.c
1233: *** ../../gnu/gdb/blockframe.c Sat Apr 4 22:06:18 1987
1234: --- ./blockframe.c Mon Apr 27 01:06:06 1987
1235: ***************
1236: *** 53,62 ****
1237: }
1238:
1239: void
1240: ! set_current_frame (frame)
1241: FRAME frame;
1242: {
1243: current_frame = frame;
1244: }
1245:
1246: /* Return the frame that called FRAME.
1247: --- 53,67 ----
1248: }
1249:
1250: void
1251: ! set_current_frame (frame, validp)
1252: FRAME frame;
1253: + int validp;
1254: {
1255: current_frame = frame;
1256: + #ifdef ibm032
1257: + if (validp)
1258: + recache_frames();
1259: + #endif
1260: }
1261:
1262: /* Return the frame that called FRAME.
1263: ***************
1264: *** 291,301 ****
1265: CORE_ADDR pc;
1266: {
1267: register int i;
1268:
1269: /* Note that the last thing in the vector is always _etext. */
1270: for (i = 0; i < misc_function_count; i++)
1271: {
1272: ! if (pc < misc_function_vector[i].address)
1273: return i - 1;
1274: }
1275: return -1;
1276: --- 296,309 ----
1277: CORE_ADDR pc;
1278: {
1279: register int i;
1280: + register long j;
1281:
1282: /* Note that the last thing in the vector is always _etext. */
1283: for (i = 0; i < misc_function_count; i++)
1284: {
1285: ! if ((j = misc_function_vector[i].address) < 0)
1286: ! continue;
1287: ! if (pc < j)
1288: return i - 1;
1289: }
1290: return -1;
1291: ***************
1292: *** 325,333 ****
1293: --- 333,610 ----
1294: }
1295: }
1296:
1297: + #ifdef ibm032
1298: + /* RT frame format:
1299: + arg 3 these are not really here, but are in regs
1300: + arg 2
1301: + arg 1
1302: + arg 0
1303: + resvd 20 bytes
1304: + rn to r15 saved regs
1305: + floating regs (at first assume 0 bytes, fix later)
1306: + locals
1307: +
1308: + N.B. r13 points 64 bytes below the end of the locals.
1309: + */
1310: +
1311: + /*
1312: + * Routine for ibm032 stack trace. Called after a new frame has been set. Do an entire stack
1313: + * trace, and squirrel away the information. We need to do this since the ibm032 (rt) does
1314: + * not have enough info in a known place off of the frame ptr (r13) to do anything useful.
1315: + * Instead, one also requires the pc, and can then perform various operations to find
1316: + * out how that procedure built its frame, and thus, to decode it. However, since this is
1317: + * fairly slow, we only do it after a set_current_frame operation has been performed.
1318: + */
1319: +
1320: + #define rtTTSize 50
1321: + static struct rtTTCache {
1322: + CORE_ADDR lbound; /* lowest address so far known as using this trace table */
1323: + CORE_ADDR ttaddr; /* address of the last '0xdf' in the trace table */
1324: + char ttype; /* type of the trace table -- 0 == unused */
1325: + } ttcache[rtTTSize];
1326: + short ttptr = 0;
1327: +
1328: + #define rtSize 50
1329: + static struct rt_frame rtFrames[rtSize];
1330: + static int rtCount;
1331: + static CORE_ADDR rt_next_frame, rt_next_pc;
1332: +
1333: + static struct rtTTCache *ttfind (addr)
1334: + CORE_ADDR addr; {
1335: + register int i;
1336: + register struct rtTTCache *tp;
1337: + for(i=0,tp=ttcache;i<rtTTSize;i++,tp++) {
1338: + if (addr >= tp->lbound && addr <= tp->ttaddr) return tp;
1339: + }
1340: + return 0;
1341: + }
1342: +
1343: + static ttadd(lowaddr, ttaddr, type)
1344: + register CORE_ADDR lowaddr, ttaddr;
1345: + char type; {
1346: + register struct rtTTCache *tp;
1347: + if (tp = ttfind(ttaddr)) {
1348: + /* possibly increase the bound on this cache element */
1349: + if (lowaddr < tp->lbound) tp->lbound = lowaddr;
1350: + }
1351: + else {
1352: + /* add a new element */
1353: + tp = &ttcache[ttptr++];
1354: + tp->lbound = lowaddr;
1355: + tp->ttaddr = ttaddr;
1356: + tp->ttype = type;
1357: + if (ttptr >= rtTTSize) ttptr = 0; /* keep it in bounds */
1358: + }
1359: + }
1360: +
1361: + /* this routine scans for a trace table, and returns 4 bytes: 0 0 <n params> <first saved reg> */
1362: + rt_num_regs (pc, tf)
1363: + register struct rt_frame *tf;
1364: + CORE_ADDR pc; {
1365: + register state = 0;
1366: + register long newpc = pc;
1367: + register int tc;
1368: + short nparms, firstreg;
1369: + short ttype;
1370: + short optx;
1371: + long offset;
1372: + char offtype;
1373: + struct rtTTCache *tp;
1374: + CORE_ADDR frame;
1375: +
1376: + frame = tf->frame;
1377: + /* first see if it is in our ttcache */
1378: + if (tp = ttfind(pc)) {
1379: + state = 3;
1380: + ttype = tp->ttype;
1381: + newpc = tp->ttaddr;
1382: + }
1383: + else {
1384: + /* state machine to look for 'df' 'xx' 'df' */
1385: + while (1) {
1386: + tc = read_memory_integer(newpc, 2);
1387: + if (state == 0 && (tc&0xff00) == 0xdf00) {
1388: + state = 1;
1389: + ttype = tc & 0xff;
1390: + }
1391: + else if (state == 1 && (tc & 0xff00) == 0xdf00) {
1392: + state = 3;
1393: + break;
1394: + }
1395: + else state = 0;
1396: + if (newpc - pc > 20000) break;
1397: + newpc += 2;
1398: + }
1399: + if (state == 3) ttadd(pc, newpc, ttype); /* add to cache */
1400: + }
1401: + if (state != 3) {
1402: + printf("No trace table for pc %x, making one up.\n", pc);
1403: + tf->nParms = 0;
1404: + tf->firstReg = 12;
1405: + tf->firstRLoc = frame+64;
1406: + rt_next_pc = read_memory_integer(frame+64+12, 4);
1407: + rt_next_frame = read_memory_integer(frame+64+4, 4);
1408: + return 0;
1409: + }
1410: + /* otherwise newpc is pointing at the last 'df' in the trace table */
1411: + else if (ttype == 3) {
1412: + /* funny trace table found by OBSERVATION (not doc) to be in program prolog */
1413: + return -1; /* special value checked by recache_frames */
1414: + }
1415: + else if (ttype == 2) {
1416: + /* assembly: no registers were saved */
1417: + tf->nParms = 0;
1418: + tf->firstReg = 16;
1419: + tf->firstRLoc = 0;
1420: + rt_next_pc = read_register(15); /* where we go back to */
1421: + rt_next_frame = frame;
1422: + tf->frame -= 100; /* hack to eliminate duplicate tags */
1423: + return 0;
1424: + }
1425: + else if (ttype == 0x7f) {
1426: + /* special machine state frame saved by STACK_DUMMY */
1427: + tf->nParms = 0;
1428: + tf->firstReg = 16;
1429: + tf->firstRLoc = 0;
1430: + rt_next_pc = read_memory_integer(frame + 64 - 64, 4);
1431: + rt_next_frame = read_memory_integer(frame -64 + 13*4, 4);
1432: + return 0;
1433: + }
1434: + else {
1435: + /* C program, I hope */
1436: + nparms = (read_memory_integer(newpc+2, 1) >> 4) & 0x0f;
1437: + firstreg = ((tc=read_memory_integer(newpc+1, 1)) >> 4) & 0x0f;
1438: + optx = ((tc&4)? 1 : 0); /* flags says if floating registers described */
1439: + offtype = read_memory_integer(newpc+optx+3, 1) & 0xff;
1440: + if ((offtype & 0xc0) == 0) {
1441: + /* 6 bits of local offset */
1442: + offset = offtype & 0x3f;
1443: + }
1444: + else if ((offtype & 0xc0) == 0x40) {
1445: + /* 14 bits of local offset */
1446: + offset = (offtype & 0x3f) << 8;
1447: + offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
1448: + }
1449: + else if ((offtype & 0xc0) == 0x80) {
1450: + /* 22 bits of local offset */
1451: + offset = (offtype & 0x3f) << 8;
1452: + offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
1453: + offset <<= 8;
1454: + offset += (read_memory_integer(newpc+optx+5, 1) & 0xff);
1455: + }
1456: + else if ((offtype & 0xc0) == 0xc0) {
1457: + /* 30 bits of local offset */
1458: + offset = (offtype & 0x3f) << 8;
1459: + offset += (read_memory_integer(newpc+optx+4, 1) & 0xff);
1460: + offset <<= 8;
1461: + offset += (read_memory_integer(newpc+optx+5, 1) & 0xff);
1462: + offset <<= 8;
1463: + offset += (read_memory_integer(newpc+optx+6, 1) & 0xff);
1464: + }
1465: + offset <<= 2;
1466: + tf->nParms = nparms;
1467: + tf->firstReg = firstreg;
1468: + tf->firstRLoc = frame /* initial frame location */
1469: + + offset /* to top of frame */
1470: + - 36 /* pascal static link, incomings args and linkage */
1471: + - (4*(16-firstreg)); /* space used by general regs */
1472: + rt_next_pc = read_memory_integer(tf->firstRLoc + 4*(15-firstreg), 4);
1473: + rt_next_frame = read_memory_integer(tf->firstRLoc + 4*(13-firstreg), 4);
1474: + return 0;
1475: + }
1476: + }
1477: +
1478: + recache_frames() {
1479: + register long i, j;
1480: + long pc;
1481: + CORE_ADDR curfp;
1482: + struct rt_frame *tf;
1483: +
1484: + pc = read_pc();
1485: + curfp = current_frame;
1486: + rtCount = 0;
1487: + /* these next special cases can only occur with frame #0; others can't make calls
1488: + in these intermediate states.
1489: + */
1490: + /* if pc points at br or brx, we're doing a return, so set the pc to the target */
1491: + i=read_memory_integer(pc, 2);
1492: + if ((i & 0xfe00) == 0xe800) {
1493: + /* we're looking at a br or brx instruction */
1494: + pc = read_register(i&0x0f);
1495: + }
1496: + /* also, if pc points at d9xx or c111 we're in the middle of a frame push, and should
1497: + use r15 for the pc.
1498: + */
1499: + if ((i & 0xff00) == 0xd900 || (i & 0xffff) == 0xc111) {
1500: + pc = read_register(15);
1501: + }
1502: + while (1) {
1503: + if (curfp <= 0x10000000 || curfp >= 0x20000000) break;
1504: + if (pc > 0x20000000) break;
1505: + /* otherwise try to add a new frame structure */
1506: + if (rtCount >= rtTTSize) break;
1507: + tf = &rtFrames[rtCount++];
1508: + tf->frame = curfp;
1509: + tf->pc = pc;
1510: + i = rt_num_regs(pc, tf);
1511: + if (i<0) { /* exceptional values */
1512: + rtCount--; /* last frame was bogus */
1513: + break;
1514: + }
1515: + /* now setup for next iteration */
1516: + pc = rt_next_pc;
1517: + curfp = rt_next_frame;
1518: + }
1519: + }
1520: +
1521: + struct rt_frame *get_cached_frame(aframe)
1522: + CORE_ADDR aframe; {
1523: + register int i;
1524: + for(i=0;i<rtCount;i++) {
1525: + if (rtFrames[i].frame == aframe) return &rtFrames[i];
1526: + }
1527: + return 0;
1528: + }
1529: +
1530: + long rt_prev_frame(frame)
1531: + register CORE_ADDR frame; {
1532: + register int i;
1533: + for(i=0;i<rtCount-1;i++) {
1534: + if (rtFrames[i].frame == frame) return rtFrames[i+1].frame;
1535: + }
1536: + return 0;
1537: + }
1538: +
1539: + long rt_frame_reg(frame, reg)
1540: + CORE_ADDR frame;
1541: + register long reg; {
1542: + register struct rt_frame *tf;
1543: + tf = get_cached_frame(frame);
1544: + if (tf == 0) return 0;
1545: + if (tf->firstReg > reg) return 0; /* didn't save this one! */
1546: + return read_memory_integer(tf->firstRLoc + 4 * (reg - tf->firstReg), 4);
1547: + }
1548: +
1549: + long rt_frame_args(frame)
1550: + CORE_ADDR frame; {
1551: + register struct rt_frame *tf;
1552: + tf = get_cached_frame(frame);
1553: + if (!tf) return 0;
1554: + return tf->firstRLoc + 20 + 4*(16 - tf->firstReg);
1555: + }
1556: + #endif
1557: +
1558: + blockinitialize() {initialize();}
1559: +
1560: static
1561: initialize ()
1562: {
1563: + #ifdef ibm032
1564: + #ifdef CAMPHOR
1565: + add_com ("recache-frames", class_stack, recache_frames,
1566: + "Tell debugger to recompute PC/RT stack frame cache\n");
1567: + #endif
1568: + #endif
1569: }
1570:
1571: END_FILE
1572: diff -c ../../gnu/gdb/breakpoint.c ./breakpoint.c
1573: *** ../../gnu/gdb/breakpoint.c Sat Apr 4 22:22:44 1987
1574: --- ./breakpoint.c Sun Apr 26 23:02:20 1987
1575: ***************
1576: *** 94,99 ****
1577: --- 94,100 ----
1578: of last breakpoint hit. */
1579:
1580: struct command_line *breakpoint_commands;
1581: + char new_breakpoint_commands = 0; /* Zalman Stern, ITC 1/12/1987 */
1582:
1583: START_FILE
1584:
1585: ***************
1586: *** 203,210 ****
1587: {
1588: execute_command (breakpoint_commands->line, 0);
1589: /* If command was "cont", breakpoint_commands is 0 now. */
1590: ! if (breakpoint_commands)
1591: breakpoint_commands = breakpoint_commands->next;
1592: }
1593: clear_momentary_breakpoints ();
1594: }
1595: --- 204,213 ----
1596: {
1597: execute_command (breakpoint_commands->line, 0);
1598: /* If command was "cont", breakpoint_commands is 0 now. */
1599: ! if (breakpoint_commands && !new_breakpoint_commands) /* Zalman Stern, ITC 1/12/1987 */
1600: breakpoint_commands = breakpoint_commands->next;
1601: + else /* Zalman Stern, ITC 1/12/1987 */
1602: + new_breakpoint_commands = 0; /* Zalman Stern, ITC 1/12/1987 */
1603: }
1604: clear_momentary_breakpoints ();
1605: }
1606: ***************
1607: *** 215,220 ****
1608: --- 218,225 ----
1609: void
1610: clear_breakpoint_commands ()
1611: {
1612: + if (breakpoint_commands != 0) /* Zalman Stern, ITC 1/12/1987 */
1613: + new_breakpoint_commands = 1; /* Zalman Stern, ITC 1/12/1987 */
1614: breakpoint_commands = 0;
1615: breakpoint_auto_delete (0);
1616: }
1617: ***************
1618: *** 921,926 ****
1619: --- 926,933 ----
1620: struct cmd_list_element *enablelist;
1621:
1622: extern struct cmd_list_element *cmdlist;
1623: +
1624: + breakinitialize() {initialize();}
1625:
1626: static
1627: initialize ()
1628: diff -c ../../gnu/gdb/command.c ./command.c
1629: *** ../../gnu/gdb/command.c Sat Apr 4 22:24:07 1987
1630: --- ./command.c Sat Apr 25 17:18:15 1987
1631: ***************
1632: *** 94,100 ****
1633: You are forbidden to forbid anyone else to use, share and improve
1634: what you give them. Help stamp out software-hoarding! */
1635:
1636: -
1637: #include "command.h"
1638: #include <stdio.h>
1639:
1640: --- 94,99 ----
1641: ***************
1642: *** 388,394 ****
1643: {
1644: if (nfound > 1 && allow_unknown >= 0)
1645: {
1646: ! *p = 0;
1647: ambbuf[0] = 0;
1648: for (c = list; c; c = c->next)
1649: if (!strncmp (*line, c->name, p - *line))
1650: --- 387,393 ----
1651: {
1652: if (nfound > 1 && allow_unknown >= 0)
1653: {
1654: ! *p = 0;
1655: ambbuf[0] = 0;
1656: for (c = list; c; c = c->next)
1657: if (!strncmp (*line, c->name, p - *line))
1658: diff -c ../../gnu/gdb/core.c ./core.c
1659: *** ../../gnu/gdb/core.c Sat Apr 4 22:27:23 1987
1660: --- ./core.c Mon Apr 27 13:20:47 1987
1661: ***************
1662: *** 163,172 ****
1663: int reg_offset;
1664:
1665: /* 4.2bsd-style core dump */
1666: val = myread (corechan, &u, sizeof u);
1667: if (val < 0)
1668: ! perror_with_name (filename);
1669: data_start = exec_data_start;
1670: data_end = data_start + NBPG * u.u_dsize;
1671: stack_start = stack_end - NBPG * u.u_ssize;
1672: data_offset = NBPG * UPAGES;
1673: --- 163,180 ----
1674: int reg_offset;
1675:
1676: /* 4.2bsd-style core dump */
1677: + #ifdef ibm032
1678: + /* on ibm032, uarea is at the far end of the u pages */
1679: + lseek(corechan, UPAGES*NBPG - sizeof(u), 0);
1680: + #endif
1681: val = myread (corechan, &u, sizeof u);
1682: if (val < 0)
1683: ! perror_with_name (execfile);
1684: ! #ifdef ibm032
1685: ! data_start = 0x10000000;
1686: ! #else
1687: data_start = exec_data_start;
1688: + #endif
1689: data_end = data_start + NBPG * u.u_dsize;
1690: stack_start = stack_end - NBPG * u.u_ssize;
1691: data_offset = NBPG * UPAGES;
1692: ***************
1693: *** 208,214 ****
1694: corefile = concat (dirname, "/", filename);
1695: }
1696:
1697: ! set_current_frame (read_register (FP_REGNUM));
1698: select_frame (get_current_frame (), 0);
1699: validate_files ();
1700: }
1701: --- 216,222 ----
1702: corefile = concat (dirname, "/", filename);
1703: }
1704:
1705: ! set_current_frame (read_register (FP_REGNUM), 1);
1706: select_frame (get_current_frame (), 0);
1707: validate_files ();
1708: }
1709: ***************
1710: *** 523,528 ****
1711: --- 531,539 ----
1712:
1713: #endif /* not NEW_SUN_CORE */
1714:
1715: +
1716: + coreinitialize() {initialize();}
1717: +
1718: static
1719: initialize ()
1720: {
1721: diff -c ../../gnu/gdb/dbxread.c ./dbxread.c
1722: *** ../../gnu/gdb/dbxread.c Sat Apr 4 22:29:54 1987
1723: --- ./dbxread.c Fri May 15 15:52:24 1987
1724: ***************
1725: *** 28,33 ****
1726: --- 28,36 ----
1727: #include "initialize.h"
1728: #include "symtab.h"
1729: #include "param.h"
1730: + #ifdef CAMPHOR
1731: + #include "value.h"
1732: + #endif
1733:
1734: static void add_symbol_to_list ();
1735: static void read_dbx_symtab ();
1736: ***************
1737: *** 89,94 ****
1738: --- 92,109 ----
1739: int prev_line_number;
1740: };
1741:
1742: + /* When dealing with dynamically loaded objects, the symbol table in the sym file
1743: + does not match where we actually load the files. Thus, gdb has to relocate those
1744: + symbols during dbxread. This is only used by the camphor support code, and
1745: + probably should be under an ifdef camphor. */
1746: +
1747: + struct dlreloc
1748: + {
1749: + long text;
1750: + long data;
1751: + long bss;
1752: + } dlreloc;
1753: +
1754: static struct subfile *subfiles;
1755:
1756: static struct subfile *current_subfile;
1757: ***************
1758: *** 1015,1020 ****
1759: --- 1030,1037 ----
1760: register int i, nbl;
1761: register struct blockvector *bv;
1762: register struct block *b;
1763: + int j;
1764: + struct symbol *ts1, *ts2;
1765:
1766: for (s = symtab_list; s; s = s->next)
1767: {
1768: ***************
1769: *** 1025,1034 ****
1770: --- 1042,1238 ----
1771: b = BLOCKVECTOR_BLOCK (bv, i);
1772: qsort (&BLOCK_SYM (b, 0), BLOCK_NSYMS (b),
1773: sizeof (struct symbol *), compare_symbols);
1774: + /* Register parms have two decls, but the register one is the only one of interest */
1775: + /* So, trash the name of the bad one, since binary srch could get either. Yucko. */
1776: + /* doing name this way enables symbol freeing code to keep working */
1777: + for(j=1;j<BLOCK_NSYMS(b);j++)
1778: + {
1779: + ts1 = BLOCK_SYM(b,j-1);
1780: + ts2 = BLOCK_SYM(b, j);
1781: + if (SYMBOL_NAMESPACE(ts1) == VAR_NAMESPACE
1782: + && SYMBOL_NAMESPACE(ts2) == VAR_NAMESPACE
1783: + && strcmp(SYMBOL_NAME(ts1), SYMBOL_NAME(ts2)) == 0)
1784: + {if (SYMBOL_CLASS(ts1) == LOC_REGISTER)
1785: + {SYMBOL_CLASS(ts2) = LOC_REGISTER;
1786: + SYMBOL_TYPE(ts2) = SYMBOL_TYPE(ts1);
1787: + SYMBOL_VALUE(ts2) = SYMBOL_VALUE(ts1);
1788: + }
1789: + else if (SYMBOL_CLASS(ts2) == LOC_REGISTER )
1790: + {SYMBOL_CLASS(ts1) = LOC_REGISTER;
1791: + SYMBOL_TYPE(ts1) = SYMBOL_TYPE(ts2);
1792: + SYMBOL_VALUE(ts1) = SYMBOL_VALUE(ts2);
1793: + }
1794: + #ifdef notdef
1795: + else printf("Check out def of symbol %s\n", SYMBOL_NAME(ts1));
1796: + #endif
1797: + }
1798: + }
1799: }
1800: }
1801: }
1802:
1803: +
1804: + #ifdef CAMPHOR
1805: + set_rel_command(exp)
1806: + char *exp;
1807: + {
1808: + struct expression *expr = (struct expression *) parse_c_expression (exp);
1809: + register value val;
1810: + register long temp;
1811: + register struct cleanup *old_chain
1812: + = make_cleanup (free_current_contents, &expr);
1813: + val = evaluate_expression (expr);
1814: + temp = value_as_long (val);
1815: + dlreloc.text = dlreloc.data = dlreloc.bss = temp;
1816: + printf("Relocation for all segs set to %x.\n", temp);
1817: + do_cleanups (old_chain);
1818: + }
1819: +
1820: + void
1821: + add_file_command (name)
1822: + char *name;
1823: + {
1824: + register int desc;
1825: + struct exec hdr;
1826: + struct nlist *nlist;
1827: + char *stringtab;
1828: + long buffer;
1829: + register int val;
1830: + extern void close ();
1831: + struct cleanup *old_chain;
1832: + int in_this_dir = 1;
1833: + struct symtab *symtab_temp;
1834: +
1835: + dont_repeat ();
1836: +
1837: + if (name == 0)
1838: + error_no_arg ("file to add symbols from");
1839: +
1840: + if (symtab_list && !query ("Add more symbols from \"%s\"? ", name))
1841: + error ("Not confirmed.");
1842: +
1843: + if (symfile)
1844: + free (symfile);
1845: + symfile = 0;
1846: +
1847: + desc = open (name, 0);
1848: + if (desc < 0)
1849: + {
1850: + if ((desc = openp (getenv ("BZPATH"), name, 0, 0)) < 0)
1851: + if ((desc = openp (getenv ("CLASSPATH"), name, 0, 0)) < 0)
1852: + desc = openp (getenv ("PATH"), name, 0, 0);
1853: +
1854: + in_this_dir = 0;
1855: + }
1856: + if (desc < 0)
1857: + perror_with_name (name);
1858: +
1859: + old_chain = make_cleanup (close, desc);
1860: +
1861: + val = myread (desc, &hdr, sizeof hdr);
1862: + if (val < 0)
1863: + perror_with_name (name);
1864: +
1865: + if (N_BADMAG (hdr))
1866: + error ("File \"%s\" not in executable format.", name);
1867: +
1868: + if (hdr.a_syms == 0)
1869: + {
1870: + free_all_symtabs (); /* check this */
1871: + return;
1872: + }
1873: +
1874: + /* Now read the string table, all at once. */
1875: + val = lseek (desc, N_SYMOFF (hdr) + hdr.a_syms, 0);
1876: + if (val < 0)
1877: + perror_with_name (name);
1878: + val = myread (desc, &buffer, sizeof buffer);
1879: + if (val < 0)
1880: + perror_with_name (name);
1881: + stringtab = (char *) alloca (buffer);
1882: + bcopy (&buffer, stringtab, sizeof buffer);
1883: + val = myread (desc, stringtab + sizeof buffer, buffer - sizeof buffer);
1884: + if (val < 0)
1885: + perror_with_name (name);
1886: +
1887: + #ifdef READ_GDB_SYMSEGS
1888: + /* That puts us at the symsegs. Read them. */
1889: + symseg_chain = read_symsegs (desc, name);
1890: + hash_symsegs ();
1891: + #else
1892: + /* Where people are using the 4.2 ld program, must not check for
1893: + symsegs, because that ld puts randonm garbage at the end of
1894: + the output file and that would trigger an error message. */
1895: + symseg_chain = 0;
1896: + #endif
1897: +
1898: + /* Position to read the symbol table. Do not read it all at once. */
1899: + val = lseek (desc, N_SYMOFF (hdr), 0);
1900: + if (val < 0)
1901: + perror_with_name (name);
1902: +
1903: + printf ("Reading symbol data from %s...", name);
1904: + fflush (stdout);
1905: +
1906: + init_misc_functions ();
1907: + make_cleanup (discard_misc_bunches, 0);
1908: + init_header_files ();
1909: + make_cleanup (free_header_files, 0);
1910: +
1911: + /* Remember symtab_list to check if the added file had any dbx info in it. */
1912: + symtab_temp = symtab_list;
1913: +
1914: + /* Now that the symbol table data of the executable file are all in core,
1915: + process them and define symbols accordingly. Closes desc. */
1916: +
1917: + read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
1918: +
1919: + if (symtab_list == symtab_temp) {
1920: + printf("\n%s not compiled with -g, debugging posibilities are limited.\n", name);
1921: + fflush(stdout);
1922: + }
1923: + else {
1924: +
1925: + /* Sort symbols alphabetically within each block. */
1926: +
1927: + sort_syms ();
1928: +
1929: + /* Go over the misc functions and install them in vector. */
1930: +
1931: + condense_misc_bunches ();
1932: +
1933: + /* Make a default for file to list. */
1934: +
1935: + select_source_symtab (symtab_list);
1936: + }
1937: +
1938: + do_cleanups (old_chain);
1939: +
1940: + /* Free the symtabs made by read_symsegs, but not their contents,
1941: + which have been copied into symtabs on symtab_list. */
1942: + while (symseg_chain)
1943: + {
1944: + register struct symtab *s = symseg_chain->next;
1945: + free (symseg_chain);
1946: + symseg_chain = s;
1947: + }
1948: +
1949: + if (in_this_dir && name[0] != '/')
1950: + {
1951: + char dirname[MAXPATHLEN];
1952: +
1953: + getwd (dirname);
1954: + symfile = concat (dirname, "/",
1955: + savestring (name, strlen (name)));
1956: + }
1957: + else
1958: + symfile = savestring (name, strlen (name));
1959: +
1960: + printf ("done.\n");
1961: + fflush (stdout);
1962: + }
1963: + #endif
1964: +
1965: /* This is the symbol-file command. Read the file, analyze its symbols,
1966: and add a struct symtab to symtab_list. */
1967:
1968: ***************
1969: *** 1047,1052 ****
1970: --- 1251,1263 ----
1971:
1972: dont_repeat ();
1973:
1974: + #ifdef CAMPHOR
1975: + /* this command does not deal with automatically relocated stuff */
1976: + dlreloc.text = 0;
1977: + dlreloc.data = 0;
1978: + dlreloc.bss = 0;
1979: + #endif
1980: +
1981: if (name == 0)
1982: error_no_arg ("file to read symbols from");
1983:
1984: ***************
1985: *** 1130,1151 ****
1986:
1987: read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
1988:
1989: /* Sort symbols alphabetically within each block. */
1990:
1991: ! sort_syms ();
1992:
1993: /* Go over the misc functions and install them in vector. */
1994:
1995: ! condense_misc_bunches ();
1996:
1997: /* Don't allow char * to have a typename (else would get caddr_t.) */
1998:
1999: ! TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
2000:
2001: /* Make a default for file to list. */
2002:
2003: ! select_source_symtab (symtab_list);
2004:
2005: symfile = savestring (name, strlen (name));
2006:
2007: do_cleanups (old_chain);
2008: --- 1341,1372 ----
2009:
2010: read_dbx_symtab (desc, stringtab, hdr.a_syms / sizeof (struct nlist));
2011:
2012: + /* Check to make sure file was compiled with -g. */
2013: +
2014: + if (symtab_list == NULL) {
2015: + printf("\n%s not compiled with -g, debugging posibilities are limited.\n", name);
2016: + fflush(stdout);
2017: + }
2018: + else {
2019: +
2020: /* Sort symbols alphabetically within each block. */
2021:
2022: ! sort_syms ();
2023:
2024: /* Go over the misc functions and install them in vector. */
2025:
2026: ! condense_misc_bunches ();
2027:
2028: /* Don't allow char * to have a typename (else would get caddr_t.) */
2029:
2030: ! TYPE_NAME (lookup_pointer_type (builtin_type_char)) = 0;
2031:
2032: /* Make a default for file to list. */
2033:
2034: ! select_source_symtab (symtab_list);
2035:
2036: + }
2037: +
2038: symfile = savestring (name, strlen (name));
2039:
2040: do_cleanups (old_chain);
2041: ***************
2042: *** 1204,1209 ****
2043: --- 1425,1440 ----
2044: {
2045: fread (&buf, sizeof buf, 1, stream);
2046: namestring = buf.n_un.n_strx ? buf.n_un.n_strx + stringtab : 0;
2047: + #ifdef CAMPHOR
2048: + if ((buf.n_type & N_TYPE) == N_UNDF) {
2049: + /* don't screw around with undefined symbols */
2050: + }
2051: + else {
2052: + if ((buf.n_type & N_TYPE) == N_TEXT) buf.n_value += dlreloc.text;
2053: + else if ((buf.n_type & N_TYPE) == N_DATA) buf.n_value += dlreloc.data;
2054: + else if ((buf.n_type & N_TYPE) == N_BSS) buf.n_value += dlreloc.bss;
2055: + }
2056: + #endif
2057: if (buf.n_type & N_STAB)
2058: process_one_symbol (buf.n_type, buf.n_desc,
2059: buf.n_value, namestring);
2060: ***************
2061: *** 1356,1361 ****
2062: --- 1587,1596 ----
2063: }
2064: }
2065:
2066: + #ifdef ibm032
2067: + static char hcState; /* two different, incompatible compilers for the RT */
2068: + #endif
2069: +
2070: static void
2071: process_one_symbol (type, desc, value, name)
2072: int type, desc;
2073: ***************
2074: *** 1363,1369 ****
2075: char *name;
2076: {
2077: register struct context_stack *new;
2078: !
2079: /* Something is wrong if we see real data before
2080: seeing a source file name. */
2081:
2082: --- 1598,1633 ----
2083: char *name;
2084: {
2085: register struct context_stack *new;
2086: ! char tname[256];
2087: ! /* Now, there are two compilers for the RT, and they are seriously incompatible.
2088: ! pcc is just like normal c compilers: stabs for a block occur before the LBRAC
2089: ! stab for that same block. Thus this code squirrels them away in the context
2090: ! and when the RBRAC is hit, restores local_symbols as of the time the LBRAC
2091: ! was encountered, and adds these symbosl to the block that just ended.
2092: !
2093: ! However, with the HC compiler, those symbols occur *after* the LBRAC symbol
2094: ! declaring the block's start. Totally incompatible, of course. One expects no
2095: ! less from IBM. For hc compiled programs, we use the symbols in local_symbols
2096: ! *before* the RBRAC command pops the context stack.
2097: !
2098: ! Amazingly enough, when we complained to IBM/Palo Alto about this incompatibility,
2099: ! they claimed that Mark Linton (original author of dbx) liked the new way better, and
2100: ! that he didn't even know that pcc used a different order. Sorta explains some things
2101: ! about dbx, n'est-ce pas? Furthermore, of course, IBM doesn't want to change
2102: ! either pcc or hc.
2103: !
2104: ! Anyway, hc and pcc compiled .o files often co-exist in programs. How do we
2105: ! tell which is which? Stupid heuristic which doesn't work with programs
2106: ! with no top-level locals or parameters: after seeing a function's start, if we see
2107: ! an LBRAC before seeing a variable, then we are using hc, otherwise it is pcc.
2108: ! Stupid heuristics are better than none, so we use it.
2109: !
2110: ! The variable hcState is used to keep track of this crap.
2111: ! 0 ==> saw function symbol
2112: ! 1 ==> saw lbrac in state 0, this is hc.
2113: ! 2 ==> saw symbol in state 0, this is pcc.
2114: ! */
2115: !
2116: /* Something is wrong if we see real data before
2117: seeing a source file name. */
2118:
2119: ***************
2120: *** 1384,1389 ****
2121: --- 1648,1656 ----
2122: also the end of the lexical context for the previous function. */
2123: new = context_stack;
2124: within_function = 1;
2125: + #ifdef ibm032
2126: + hcState = 0;
2127: + #endif
2128: if (new)
2129: {
2130: /* Make a block for the local symbols within. */
2131: ***************
2132: *** 1400,1406 ****
2133: --- 1667,1679 ----
2134: new->locals = 0;
2135: new->old_blocks = pending_blocks;
2136: new->start_addr = value;
2137: + #ifdef ibm032
2138: + strcpy(tname, ".");
2139: + strcat(tname, name);
2140: + new->name = define_symbol(value, tname);
2141: + #else
2142: new->name = define_symbol (value, name);
2143: + #endif
2144: local_symbols = 0;
2145: break;
2146:
2147: ***************
2148: *** 1407,1412 ****
2149: --- 1680,1688 ----
2150: case N_LBRAC:
2151: /* This "symbol" just indicates the start of an inner lexical
2152: context within a function. */
2153: + #ifdef ibm032
2154: + if (hcState == 0) hcState = 1;
2155: + #endif
2156: new = (struct context_stack *) xmalloc (sizeof (struct context_stack));
2157: new->depth = desc;
2158: new->next = context_stack;
2159: ***************
2160: *** 1422,1430 ****
2161: /* This "symbol" just indicates the end of an inner lexical
2162: context that was started with N_RBRAC. */
2163: new = context_stack;
2164: if (new == 0 || desc != new->depth)
2165: error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
2166: - local_symbols = new->locals;
2167: context_stack = new->next;
2168: /* If this is not the outermost LBRAC...RBRAC pair in the
2169: function, its local symbols preceded it, and are the ones
2170: --- 1698,1711 ----
2171: /* This "symbol" just indicates the end of an inner lexical
2172: context that was started with N_RBRAC. */
2173: new = context_stack;
2174: + #ifdef ibm032
2175: + if (hcState == 2) /* pcc */
2176: + local_symbols = new->locals;
2177: + #else
2178: + local_symbols = new->locals;
2179: + #endif
2180: if (new == 0 || desc != new->depth)
2181: error ("Invalid symbol data: N_LBRAC/N_RBRAC symbol mismatch, symtab pos %d.", symnum);
2182: context_stack = new->next;
2183: /* If this is not the outermost LBRAC...RBRAC pair in the
2184: function, its local symbols preceded it, and are the ones
2185: ***************
2186: *** 1443,1448 ****
2187: --- 1724,1733 ----
2188: new->start_addr + last_source_start_addr,
2189: value + last_source_start_addr);
2190: }
2191: + #ifdef ibm032
2192: + if (hcState == 1 && context_stack->next) /* hc */
2193: + local_symbols = new->locals; /* now we get them */
2194: + #endif
2195: free (new);
2196: break;
2197:
2198: ***************
2199: *** 1493,1498 ****
2200: --- 1778,1786 ----
2201: break;
2202:
2203: default:
2204: + #ifdef ibm032
2205: + if (hcState == 0) hcState = 2;
2206: + #endif
2207: if (name)
2208: define_symbol (value, name);
2209: }
2210: ***************
2211: *** 1553,1558 ****
2212: --- 1841,1849 ----
2213: Dbx data never actually contains 'l'. */
2214: case 'l':
2215: SYMBOL_CLASS (sym) = LOC_LOCAL;
2216: + #ifdef ibm032
2217: + if (hcState == 1) value += 1000000; /* temporary hack until rel 3 pcc matches hc */
2218: + #endif
2219: SYMBOL_VALUE (sym) = value;
2220: SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2221: add_symbol_to_list (sym, &local_symbols);
2222: ***************
2223: *** 1572,1577 ****
2224: --- 1863,1875 ----
2225: add_symbol_to_list (sym, &local_symbols);
2226: break;
2227:
2228: + case 'R':
2229: + SYMBOL_CLASS (sym) = LOC_REGISTER;
2230: + SYMBOL_VALUE (sym) = value;
2231: + SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2232: + add_symbol_to_list (sym, &local_symbols);
2233: + break;
2234: +
2235: case 'S':
2236: /* Static symbol at top level of file */
2237: SYMBOL_CLASS (sym) = LOC_STATIC;
2238: ***************
2239: *** 1616,1622 ****
2240: break;
2241:
2242: default:
2243: ! error ("Invalid symbol data: unknown symbol-type code `%c' at symtab pos %d.", deftype, symnum);
2244: }
2245: return sym;
2246: }
2247: --- 1914,1928 ----
2248: break;
2249:
2250: default:
2251: ! printf ("Unknown symbol-type code '%c' in dbx symbol table, assuming local.\n", deftype);
2252: ! SYMBOL_CLASS (sym) = LOC_LOCAL;
2253: ! #ifdef ibm032
2254: ! if (hcState == 1) value += 1000000; /* temporary hack until rel 3 pcc matches hc */
2255: ! #endif
2256: ! SYMBOL_VALUE (sym) = value;
2257: ! SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
2258: ! add_symbol_to_list (sym, &local_symbols);
2259: ! break;
2260: }
2261: return sym;
2262: }
2263: ***************
2264: *** 1741,1746 ****
2265: --- 2047,2056 ----
2266: (*pp) += 5;
2267: else if (!strncmp (*pp, "r(0,1);0;", 9))
2268: (*pp) += 9;
2269: + #if 1
2270: + else if ((**pp == 'r') && (!strncmp(*pp + 2, ";0;", 3)))
2271: + (*pp) += 5;
2272: + #endif
2273: else break;
2274:
2275: TYPE_CODE (type) = TYPE_CODE_ARRAY;
2276: ***************
2277: *** 1980,1986 ****
2278: rather than -128 which is what I would like.
2279: So use n1 != 0 to prevent char from being taken as unsigned. */
2280:
2281: ! else if (n2 == 0 && n1 == 1)
2282: {
2283: /* an unsigned type */
2284: if (n3 == (1 << (8 * sizeof (int))))
2285: --- 2290,2296 ----
2286: rather than -128 which is what I would like.
2287: So use n1 != 0 to prevent char from being taken as unsigned. */
2288:
2289: ! if (n2 == 0)
2290: {
2291: /* an unsigned type */
2292: if (n3 == (1 << (8 * sizeof (int))))
2293: ***************
2294: *** 1989,1994 ****
2295: --- 2299,2306 ----
2296: return builtin_type_unsigned_short;
2297: if (n3 == (1 << (8 * sizeof (char))))
2298: return builtin_type_unsigned_char;
2299: + if (n3 == (1 << (8 * sizeof (char) - 1)))
2300: + return builtin_type_char;
2301: }
2302: else
2303: {
2304: ***************
2305: *** 2002,2007 ****
2306: --- 2314,2321 ----
2307: if (n3 == (1 << (8 * sizeof (char) - 1)))
2308: return builtin_type_char;
2309: }
2310: + if (n2 == 0 && n3 == 1)
2311: + return builtin_type_void;
2312: error ("Invalid symbol data: range type spec %s at symtab pos %d.",
2313: errp - 1, symnum);
2314: }
2315: ***************
2316: *** 2033,2040 ****
2317: --- 2347,2364 ----
2318:
2319: /* Read the digits, as far as they go. */
2320:
2321: + #if 0 /* Yet another "Compiler sucks" fix. */
2322: while ((c = *p++) >= '0' && c <= '9')
2323: + #else
2324: + while (((c = *p++) >= '0' && c <= '9') || ((end != '\n') && (c == '\n')))
2325: + #endif
2326: {
2327: + #if 1
2328: + if (c == '\n') {
2329: + printf("Ignoring bogus newline in stabs entry. Your compiler should be fixed.\n");
2330: + continue;
2331: + }
2332: + #endif
2333: n *= 10;
2334: n += c - '0';
2335: }
2336: ***************
2337: *** 2050,2060 ****
2338: --- 2374,2392 ----
2339: return n * sign;
2340: }
2341:
2342: + dbxinitialize() {initialize();}
2343: +
2344: static
2345: initialize ()
2346: {
2347: symfile = 0;
2348:
2349: + #ifdef CAMPHOR
2350: + add_com ("add-file", class_files, add_file_command,
2351: + "Add a new symbol table (in dbx format) from file FILE.");
2352: + add_com("set-rel", class_files, set_rel_command,
2353: + "Set relocation for add-file command to NUMBER.");
2354: + #endif
2355: add_com ("symbol-file", class_files, symbol_file_command,
2356: "Load symbol table (in dbx format) from executable file FILE.");
2357: }
2358: diff -c ../../gnu/gdb/environ.c ./environ.c
2359: *** ../../gnu/gdb/environ.c Sat Apr 4 22:31:16 1987
2360: --- ./environ.c Sun Apr 26 23:48:05 1987
2361: ***************
2362: *** 129,135 ****
2363:
2364: if (e->allocated < i)
2365: {
2366: ! e->allocated = max (i, e->allocated + 10);
2367: e->vector = (char **) xrealloc (e->vector,
2368: (e->allocated + 1) * sizeof (char *));
2369: }
2370: --- 129,136 ----
2371:
2372: if (e->allocated < i)
2373: {
2374: ! e->allocated = i + 10;
2375: e->vector = (char **) xrealloc (e->vector,
2376: (e->allocated + 1) * sizeof (char *));
2377: }
2378: diff -c ../../gnu/gdb/eval.c ./eval.c
2379: *** ../../gnu/gdb/eval.c Sat Apr 4 22:32:36 1987
2380: --- ./eval.c Mon Apr 27 00:01:27 1987
2381: ***************
2382: *** 546,551 ****
2383: --- 546,553 ----
2384: }
2385: }
2386:
2387: + evalinitialize() {initialize();}
2388: +
2389: static
2390: initialize ()
2391: { }
2392: diff -c ../../gnu/gdb/expread.y ./expread.y
2393: *** ../../gnu/gdb/expread.y Sat Apr 4 22:35:27 1987
2394: --- ./expread.y Sun Apr 26 23:56:51 1987
2395: ***************
2396: *** 650,655 ****
2397: --- 650,656 ----
2398: ;
2399: else
2400: {
2401: + /*N.B. error does a longjmp, so we do not have to worry about storage */
2402: err_copy = (char *) alloca (olen + 1);
2403: bcopy (lexptr, err_copy, olen);
2404: err_copy[olen] = 0;
2405: ***************
2406: *** 945,953 ****
2407: {
2408: register int len = sizeof (struct expression) +
2409: expr->nelts * sizeof (union exp_element);
2410: ! register struct expression *temp
2411: ! = (struct expression *) alloca (len);
2412: register int inpos = expr->nelts, outpos = 0;
2413:
2414: /* Copy the original expression into temp. */
2415: bcopy (expr, temp, len);
2416: --- 946,955 ----
2417: {
2418: register int len = sizeof (struct expression) +
2419: expr->nelts * sizeof (union exp_element);
2420: ! register struct expression *temp;
2421: register int inpos = expr->nelts, outpos = 0;
2422: +
2423: + temp = (struct expression *) alloca(len);
2424:
2425: /* Copy the original expression into temp. */
2426: bcopy (expr, temp, len);
2427: diff -c ../../gnu/gdb/findvar.c ./findvar.c
2428: *** ../../gnu/gdb/findvar.c Sat Apr 4 22:36:38 1987
2429: --- ./findvar.c Mon Apr 27 00:01:44 1987
2430: ***************
2431: *** 359,364 ****
2432: --- 359,366 ----
2433: return value_cast (lookup_pointer_type (SYMBOL_TYPE (var)),
2434: value_from_long (builtin_type_long, addr));
2435: }
2436: +
2437: + findinitialize() {initialize();}
2438:
2439: static
2440: initialize ()
2441: diff -c ../../gnu/gdb/firstfile.c ./firstfile.c
2442: *** ../../gnu/gdb/firstfile.c Sat Apr 4 22:37:06 1987
2443: --- ./firstfile.c Mon Apr 27 00:02:06 1987
2444: ***************
2445: *** 125,130 ****
2446: --- 125,152 ----
2447: static initialize_dummy_1 ();
2448: static initialize_dummy_2 ();
2449:
2450: + initialize_all_files() {
2451: + blockinitialize();
2452: + breakinitialize();
2453: + coreinitialize();
2454: + dbxinitialize();
2455: + evalinitialize();
2456: + findinitialize();
2457: + infcmdinitialize();
2458: + inflowinitialize();
2459: + infruninitialize();
2460: + symmiscinitialize();
2461: + symtabinitialize();
2462: + valarithinitialize();
2463: + valopsinitialize();
2464: + valprintinitialize();
2465: + valuesinitialize();
2466: + printcmdinitialize();
2467: + sourceinitialize();
2468: + stackinitialize();
2469: + }
2470: +
2471: + #if 0
2472: initialize_all_files ()
2473: {
2474: initialize_next_file ((char *) initialize_dummy_2
2475: ***************
2476: *** 148,153 ****
2477: --- 170,176 ----
2478: initialize_dummy_2 ()
2479: {
2480: }
2481: + #endif
2482:
2483: /* This makes the function initialize_next_file. */
2484:
2485: diff -c ../../gnu/gdb/frame.h ./frame.h
2486: *** ../../gnu/gdb/frame.h Sat Apr 4 22:37:22 1987
2487: --- ./frame.h Mon Apr 27 00:02:14 1987
2488: ***************
2489: *** 20,25 ****
2490: --- 20,35 ----
2491:
2492: /* Note that frame.h requires param.h! */
2493:
2494: + #ifdef ibm032
2495: + struct rt_frame {
2496: + CORE_ADDR frame; /* frame address */
2497: + CORE_ADDR pc; /* pc we called from */
2498: + CORE_ADDR firstRLoc; /* loc'n of first saved general reg */
2499: + short nParms; /* number of parameters to this frame */
2500: + short firstReg; /* the reg stored at 64(fp) */
2501: + };
2502: + #endif
2503: +
2504: #define FRAME CORE_ADDR
2505:
2506: struct frame_info
2507: ***************
2508: *** 62,64 ****
2509: --- 72,77 ----
2510: extern struct block *get_selected_block ();
2511: extern struct symbol *get_frame_function ();
2512: extern struct symbol *get_pc_function ();
2513: + #ifdef ibm032
2514: + extern struct rt_frame *get_cached_frame();
2515: + #endif
2516: diff -c ../../gnu/gdb/infcmd.c ./infcmd.c
2517: *** ../../gnu/gdb/infcmd.c Sat Apr 4 22:47:22 1987
2518: --- ./infcmd.c Mon Apr 27 00:07:53 1987
2519: ***************
2520: *** 39,45 ****
2521: /* String containing arguments to give to the program,
2522: with a space added at the front. Just a space means no args. */
2523:
2524: ! static char *inferior_args;
2525:
2526: /* Pid of our debugged inferior, or 0 if no inferior now. */
2527:
2528: --- 39,45 ----
2529: /* String containing arguments to give to the program,
2530: with a space added at the front. Just a space means no args. */
2531:
2532: ! static char *inferior_args = NULL;
2533:
2534: /* Pid of our debugged inferior, or 0 if no inferior now. */
2535:
2536: ***************
2537: *** 112,119 ****
2538: set_args_command (args)
2539: char *args;
2540: {
2541: ! free (inferior_args);
2542: ! if (!args) args = "";
2543: inferior_args = concat (" ", args, "");
2544: }
2545:
2546: --- 112,121 ----
2547: set_args_command (args)
2548: char *args;
2549: {
2550: ! if (inferior_args != NULL)
2551: ! free (inferior_args);
2552: ! if (!args)
2553: ! args = "";
2554: inferior_args = concat (" ", args, "");
2555: }
2556:
2557: ***************
2558: *** 171,177 ****
2559: signal (SIGINT, SIG_DFL); */
2560:
2561: ptrace (0);
2562: ! execle ("/bin/sh", "sh", "-c", allargs, 0,
2563: environ_vector (inferior_environ));
2564:
2565: fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
2566: --- 173,180 ----
2567: signal (SIGINT, SIG_DFL); */
2568:
2569: ptrace (0);
2570: !
2571: ! execle ("/bin/csh", "csh", "-f", "-c", allargs, 0,
2572: environ_vector (inferior_environ));
2573:
2574: fprintf (stderr, "Cannot exec /bin/sh: %s.\n",
2575: ***************
2576: *** 473,478 ****
2577: --- 476,482 ----
2578:
2579: retbuf[0] = stop_r0;
2580: retbuf[1] = stop_r1;
2581: +
2582: val = value_being_returned (value_type, retbuf);
2583: printf ("Value returned is $%d = ", record_latest_value (val));
2584: value_print (val, stdout);
2585: ***************
2586: *** 705,710 ****
2587: --- 709,716 ----
2588: printf ("Contents are relative to selected stack frame.\n");
2589: }
2590:
2591: + infcmdinitialize() {initialize();}
2592: +
2593: static
2594: initialize ()
2595: {
2596: diff -c ../../gnu/gdb/inflow.c ./inflow.c
2597: *** ../../gnu/gdb/inflow.c Sat Apr 4 22:56:34 1987
2598: --- ./inflow.c Mon Apr 27 00:12:10 1987
2599: ***************
2600: *** 188,194 ****
2601: inferior_pid = 0;
2602: mark_breakpoints_out ();
2603: if (have_core_file_p ())
2604: ! set_current_frame (read_register (FP_REGNUM));
2605: }
2606:
2607: /* Resume execution of the inferior process.
2608: --- 188,194 ----
2609: inferior_pid = 0;
2610: mark_breakpoints_out ();
2611: if (have_core_file_p ())
2612: ! set_current_frame (read_register (FP_REGNUM), 1);
2613: }
2614:
2615: /* Resume execution of the inferior process.
2616: ***************
2617: *** 266,271 ****
2618: --- 266,274 ----
2619: char buf[MAX_REGISTER_RAW_SIZE];
2620: register int i;
2621:
2622: + #ifdef ibm032
2623: + offset += UPAGES*NBPG - sizeof(u); /* ibm032: ustruct at end of uarea */
2624: + #endif
2625: offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
2626: for (regno = 0; regno < NUM_REGS; regno++)
2627: {
2628: ***************
2629: *** 291,296 ****
2630: --- 294,303 ----
2631: register unsigned int regaddr;
2632: char buf[80];
2633:
2634: + #ifdef ibm032
2635: + offset += UPAGES*NBPG - sizeof(u); /* ibm032: ustruct at end of uarea */
2636: + #endif
2637: +
2638: offset = ptrace (3, inferior_pid, offset, 0) - KERNEL_U_ADDR;
2639:
2640: if (regno >= 0)
2641: ***************
2642: *** 340,347 ****
2643: register int count
2644: = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
2645: /* Allocate buffer of that many longwords. */
2646: ! register int *buffer = (int *) alloca (count * sizeof (int));
2647:
2648: /* Read all the longwords */
2649: for (i = 0; i < count; i++, addr += sizeof (int))
2650: buffer[i] = ptrace (1, inferior_pid, addr, 0);
2651: --- 347,355 ----
2652: register int count
2653: = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
2654: /* Allocate buffer of that many longwords. */
2655: ! register int *buffer;
2656:
2657: + buffer = (int *) alloca(count * sizeof(int));
2658: /* Read all the longwords */
2659: for (i = 0; i < count; i++, addr += sizeof (int))
2660: buffer[i] = ptrace (1, inferior_pid, addr, 0);
2661: ***************
2662: *** 367,377 ****
2663: register int count
2664: = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
2665: /* Allocate buffer of that many longwords. */
2666: ! register int *buffer = (int *) alloca (count * sizeof (int));
2667: extern int errno;
2668:
2669: /* Fill start and end extra bytes of buffer with existing memory data. */
2670:
2671: buffer[0] = ptrace (1, inferior_pid, addr, 0);
2672: if (count > 1)
2673: buffer[count - 1]
2674: --- 375,386 ----
2675: register int count
2676: = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
2677: /* Allocate buffer of that many longwords. */
2678: ! register int *buffer;
2679: extern int errno;
2680:
2681: /* Fill start and end extra bytes of buffer with existing memory data. */
2682:
2683: + buffer = (int *) alloca (count * sizeof (int));
2684: buffer[0] = ptrace (1, inferior_pid, addr, 0);
2685: if (count > 1)
2686: buffer[count - 1]
2687: ***************
2688: *** 388,397 ****
2689: {
2690: errno = 0;
2691: ptrace (4, inferior_pid, addr, buffer[i]);
2692: ! if (errno)
2693: return 1;
2694: }
2695: -
2696: return 0;
2697: }
2698:
2699: --- 397,406 ----
2700: {
2701: errno = 0;
2702: ptrace (4, inferior_pid, addr, buffer[i]);
2703: ! if (errno) {
2704: return 1;
2705: + }
2706: }
2707: return 0;
2708: }
2709:
2710: ***************
2711: *** 421,426 ****
2712: --- 430,437 ----
2713: }
2714: }
2715:
2716: + inflowinitialize() {initialize();}
2717: +
2718: static
2719: initialize ()
2720: {
2721: diff -c ../../gnu/gdb/infrun.c ./infrun.c
2722: *** ../../gnu/gdb/infrun.c Sat Apr 4 22:57:15 1987
2723: --- ./infrun.c Mon Apr 27 00:17:40 1987
2724: ***************
2725: *** 257,263 ****
2726: pc_changed = 0;
2727: fetch_inferior_registers ();
2728: stop_pc = read_pc ();
2729: ! set_current_frame (read_register (FP_REGNUM));
2730: stop_frame = get_current_frame ();
2731: stop_sp = read_register (SP_REGNUM);
2732: another_trap = 0;
2733: --- 257,271 ----
2734: pc_changed = 0;
2735: fetch_inferior_registers ();
2736: stop_pc = read_pc ();
2737: ! #ifdef CAMPHOR
2738: ! /* if we're not going to stop, don't bother with a stack trace */
2739: ! if (WIFSTOPPED(w) && !signal_stop[WSTOPSIG(w)])
2740: ! set_current_frame(read_register(FP_REGNUM), 0);
2741: ! else
2742: ! set_current_frame(read_register(FP_REGNUM), 1);
2743: ! #else
2744: ! set_current_frame (read_register (FP_REGNUM), 1);
2745: ! #endif
2746: stop_frame = get_current_frame ();
2747: stop_sp = read_register (SP_REGNUM);
2748: another_trap = 0;
2749: ***************
2750: *** 688,700 ****
2751:
2752: /* Save the function value return registers
2753: We might be about to restore their previous contents. */
2754: ! stop_r0 = read_register (0);
2755: ! stop_r1 = read_register (1);
2756:
2757: if (stop_stack_dummy)
2758: {
2759: /* Pop the empty frame that contains the stack dummy. */
2760: POP_FRAME;
2761: select_frame (read_register (FP_REGNUM), 0);
2762: }
2763: }
2764: --- 696,717 ----
2765:
2766: /* Save the function value return registers
2767: We might be about to restore their previous contents. */
2768: ! #ifdef ibm032
2769: ! stop_r0 = read_register (2);
2770: ! stop_r1 = read_register (3);
2771: ! #else
2772: ! stop_r0 = read_register (0);
2773: ! stop_r1 = read_register (1);
2774: ! #endif
2775:
2776: if (stop_stack_dummy)
2777: {
2778: /* Pop the empty frame that contains the stack dummy. */
2779: + #ifdef ibm032
2780: + POP_DUMMY_FRAME;
2781: + #else
2782: POP_FRAME;
2783: + #endif
2784: select_frame (read_register (FP_REGNUM), 0);
2785: }
2786: }
2787: ***************
2788: *** 841,846 ****
2789: --- 858,865 ----
2790: printf ("\nUse the \"handle\" command to change these tables.\n");
2791: }
2792:
2793: + infruninitialize() {initialize();}
2794: +
2795: static
2796: initialize ()
2797: {
2798: diff -c ../../gnu/gdb/initialize.h ./initialize.h
2799: *** ../../gnu/gdb/initialize.h Sat Apr 4 22:58:27 1987
2800: --- ./initialize.h Sun May 24 00:19:21 1987
2801: ***************
2802: *** 103,109 ****
2803: --- 103,120 ----
2804: of the end of one object file's text to the start of the next
2805: object file's text. */
2806:
2807: + /* Changed to use ifdefs on the machine type. David Nichols, 11/28/86 */
2808: + #ifdef ibm032
2809: + #include "m-ibm032init.h"
2810: + #endif
2811: +
2812: + #ifdef vax
2813: #include "m-vaxinit.h"
2814: + #endif
2815: +
2816: + #ifdef sun
2817: + #include "m-suninit.h"
2818: + #endif
2819:
2820: /* This is used to make a file's initialization function.
2821: It calls another function named `initialize', which must
2822: diff -c ../../gnu/gdb/main.c ./main.c
2823: *** ../../gnu/gdb/main.c Sat Apr 4 23:11:59 1987
2824: --- ./main.c Mon Apr 27 00:27:21 1987
2825: ***************
2826: *** 236,241 ****
2827: --- 236,243 ----
2828: if (*p)
2829: {
2830: c = lookup_cmd (&p, cmdlist, "", 0);
2831: + if (c->function == 0)
2832: + error ("That is not a command, just a help topic.");
2833: if (c->class == (int) class_user)
2834: {
2835: if (*p)
2836: ***************
2837: *** 457,463 ****
2838:
2839: /* Add an element to the list of commands. */
2840:
2841: ! void
2842: add_com (name, class, fun, doc)
2843: char *name;
2844: int class;
2845: --- 459,465 ----
2846:
2847: /* Add an element to the list of commands. */
2848:
2849: ! struct cmd_list_element *
2850: add_com (name, class, fun, doc)
2851: char *name;
2852: int class;
2853: ***************
2854: *** 464,470 ****
2855: void (*fun) ();
2856: char *doc;
2857: {
2858: ! add_cmd (name, class, fun, doc, &cmdlist);
2859: }
2860:
2861: /* Add an alias or abbreviation command to the list of commands. */
2862: --- 466,473 ----
2863: void (*fun) ();
2864: char *doc;
2865: {
2866: !
2867: ! return add_cmd (name, class, fun, doc, &cmdlist);
2868: }
2869:
2870: /* Add an alias or abbreviation command to the list of commands. */
2871: ***************
2872: *** 547,552 ****
2873: --- 550,556 ----
2874:
2875: if (c && c->class == (int) class_user)
2876: free_command_lines (&c->function);
2877: +
2878:
2879: add_com (comname, class_user, cmds,
2880: (c && c->class == (int) class_user)
2881: diff -c ../../gnu/gdb/param.h ./param.h
2882: *** ../../gnu/gdb/param.h Sat Apr 4 23:15:44 1987
2883: --- ./param.h Mon Apr 27 00:28:17 1987
2884: ***************
2885: *** 1 ****
2886: --- 1,19 ----
2887: + /* Changed to use ifdefs so we don't have to edit it all the time.
2888: + David Nichols
2889: + 28 November 1986 */
2890: +
2891: + #ifdef vax
2892: #include "m-vax.h"
2893: + #endif
2894: +
2895: + #ifdef ibm032
2896: + #include "m-ibm032.h"
2897: + #endif
2898: +
2899: + #ifdef sun
2900: + #ifdef mc68020
2901: + #include "m-sun3.h"
2902: + #else
2903: + #include "m-sun2.h"
2904: + #endif
2905: + #endif
2906: diff -c ../../gnu/gdb/pinsn.c ./pinsn.c
2907: *** ../../gnu/gdb/pinsn.c Sat Apr 4 23:15:58 1987
2908: --- ./pinsn.c Mon Apr 27 00:28:36 1987
2909: ***************
2910: *** 1 ****
2911: --- 1,15 ----
2912: + /* Changed to use ifdefs so we don't have to edit this.
2913: + David Nichols
2914: + 28 Nov 1986 */
2915: +
2916: + #ifdef ibm032
2917: + #include "ibm032-pinsn.c"
2918: + #endif
2919: +
2920: + #ifdef vax
2921: #include "vax-pinsn.c"
2922: + #endif
2923: +
2924: + #ifdef sun
2925: + #include "m68k-pinsn.c"
2926: + #endif
2927: diff -c ../../gnu/gdb/printcmd.c ./printcmd.c
2928: *** ../../gnu/gdb/printcmd.c Sat Apr 4 23:17:03 1987
2929: --- ./printcmd.c Mon Apr 27 00:30:52 1987
2930: ***************
2931: *** 797,804 ****
2932: CORE_ADDR frame;
2933: FILE *stream;
2934: {
2935: ! char *space = (char *) alloca (TYPE_LENGTH (SYMBOL_TYPE (var)));
2936: value val = read_var_value (var, frame);
2937: value_print (val, stream);
2938: }
2939:
2940: --- 797,805 ----
2941: CORE_ADDR frame;
2942: FILE *stream;
2943: {
2944: ! char *space;
2945: value val = read_var_value (var, frame);
2946: + space = (char *) alloca (TYPE_LENGTH (SYMBOL_TYPE (var)));
2947: value_print (val, stream);
2948: }
2949:
2950: ***************
2951: *** 883,888 ****
2952: --- 884,891 ----
2953: }
2954: }
2955:
2956: + printcmdinitialize() {initialize();}
2957: +
2958: static
2959: initialize ()
2960: {
2961: diff -c ../../gnu/gdb/source.c ./source.c
2962: *** ../../gnu/gdb/source.c Sat Apr 4 23:17:55 1987
2963: --- ./source.c Mon Apr 27 00:31:25 1987
2964: ***************
2965: *** 276,282 ****
2966: if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
2967: printf ("Source file is more recent than executable.\n");
2968:
2969: ! data = (char *) alloca (st.st_size);
2970: myread (desc, data, st.st_size, s->filename);
2971: end = data + st.st_size;
2972: p = data;
2973: --- 276,283 ----
2974: if (get_exec_file () != 0 && exec_mtime < st.st_mtime)
2975: printf ("Source file is more recent than executable.\n");
2976:
2977: ! data = (char *) alloca(st.st_size);
2978: !
2979: myread (desc, data, st.st_size, s->filename);
2980: end = data + st.st_size;
2981: p = data;
2982: ***************
2983: *** 530,535 ****
2984: --- 531,538 ----
2985: printf ("Line number %d is out of range for \"%s\".\n",
2986: sal.line, sal.symtab->filename);
2987: }
2988: +
2989: + sourceinitialize() {initialize();}
2990:
2991: static
2992: initialize ()
2993: diff -c ../../gnu/gdb/stack.c ./stack.c
2994: *** ../../gnu/gdb/stack.c Sun Apr 5 00:28:05 1987
2995: --- ./stack.c Mon Apr 27 00:31:50 1987
2996: ***************
2997: *** 511,516 ****
2998: --- 511,517 ----
2999:
3000: print_stack_frame (selected_frame, selected_frame_level, 1);
3001: }
3002: +
3003:
3004: static void
3005: return_command (retval_exp)
3006: ***************
3007: *** 538,543 ****
3008: --- 539,546 ----
3009: frame_command ("0", 1);
3010: }
3011:
3012: + stackinitialize() {initialize();}
3013: +
3014: static
3015: initialize ()
3016: {
3017: diff -c ../../gnu/gdb/symmisc.c ./symmisc.c
3018: *** ../../gnu/gdb/symmisc.c Sun Apr 5 00:33:16 1987
3019: --- ./symmisc.c Mon Apr 27 00:37:46 1987
3020: ***************
3021: *** 504,509 ****
3022: --- 504,511 ----
3023: return i;
3024: }
3025:
3026: + symmiscinitialize() {initialize();}
3027: +
3028: static
3029: initialize ()
3030: {
3031: diff -c ../../gnu/gdb/symtab.c ./symtab.c
3032: *** ../../gnu/gdb/symtab.c Sun Apr 5 00:35:45 1987
3033: --- ./symtab.c Mon Apr 27 00:38:19 1987
3034: ***************
3035: *** 71,78 ****
3036: strcpy (copy, name);
3037: strcat (copy, ".c");
3038: for (s = symtab_list; s; s = s->next)
3039: ! if (!strcmp (copy, s->filename))
3040: return s;
3041:
3042: return 0;
3043: }
3044: --- 71,79 ----
3045: strcpy (copy, name);
3046: strcat (copy, ".c");
3047: for (s = symtab_list; s; s = s->next)
3048: ! if (!strcmp (copy, s->filename)) {
3049: return s;
3050: + }
3051:
3052: return 0;
3053: }
3054: ***************
3055: *** 703,709 ****
3056: register struct symbol *sym;
3057: register CORE_ADDR pc;
3058: register int i;
3059: ! char *copy;
3060:
3061: /* Defaults have defaults. */
3062:
3063: --- 704,710 ----
3064: register struct symbol *sym;
3065: register CORE_ADDR pc;
3066: register int i;
3067: ! char *copy, *dotcopy;
3068:
3069: /* Defaults have defaults. */
3070:
3071: ***************
3072: *** 818,825 ****
3073: --- 819,847 ----
3074: /* Look up that token as a function.
3075: If file specified, use that file's per-file block to start with. */
3076:
3077: + #ifdef ibm032
3078: + /* RT has stupid dots in front of function names (_.foo), and worse, has bogus _foo
3079: + symbol to confuse us, too.
3080: + */
3081: + if (*copy != '.') {
3082: + dotcopy = (char *) alloca (strlen(copy)+2); /* one for the null and one for the dot */
3083: + dotcopy[0] = '.';
3084: + strcpy(dotcopy+1, copy);
3085: + sym = lookup_symbol (dotcopy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
3086: + VAR_NAMESPACE);
3087: + }
3088: + else {
3089: + sym = 0;
3090: + dotcopy = 0;
3091: + }
3092: + if (!sym || SYMBOL_CLASS(sym) != LOC_BLOCK) {
3093: + sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
3094: + VAR_NAMESPACE);
3095: + }
3096: + #else
3097: sym = lookup_symbol (copy, s ? BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), 1) : 0,
3098: VAR_NAMESPACE);
3099: + #endif
3100:
3101: if (sym && SYMBOL_CLASS (sym) == LOC_BLOCK)
3102: {
3103: ***************
3104: *** 835,840 ****
3105: --- 857,875 ----
3106: if (sym)
3107: error ("%s is not a function.", copy);
3108:
3109: + #ifdef ibm032
3110: + /* try the dot version first */
3111: + if (dotcopy) for (i = 0; i < misc_function_count; i++)
3112: + if (!strcmp (misc_function_vector[i].name, dotcopy))
3113: + {
3114: + value.symtab = 0;
3115: + value.line = 0;
3116: + value.pc = misc_function_vector[i].address + FUNCTION_START_OFFSET;
3117: + if (funfirstline)
3118: + SKIP_PROLOGUE (value.pc);
3119: + return value;
3120: + }
3121: + #endif
3122: for (i = 0; i < misc_function_count; i++)
3123: if (!strcmp (misc_function_vector[i].name, copy))
3124: {
3125: ***************
3126: *** 1027,1032 ****
3127: --- 1062,1069 ----
3128:
3129: return type;
3130: }
3131: +
3132: + symtabinitialize() {initialize();}
3133:
3134: static
3135: initialize ()
3136: diff -c ../../gnu/gdb/utils.c ./utils.c
3137: *** ../../gnu/gdb/utils.c Sun Apr 5 00:40:01 1987
3138: --- ./utils.c Mon Apr 27 00:40:01 1987
3139: ***************
3140: *** 151,156 ****
3141: --- 151,157 ----
3142: else
3143: err = "unknown error";
3144:
3145: + /* ibm032: no core leak or other problems 'cause we alway call error -> longjmps away */
3146: combined = (char *) alloca (strlen (err) + strlen (string) + 3);
3147: strcpy (combined, string);
3148: strcat (combined, ": ");
3149: diff -c ../../gnu/gdb/valarith.c ./valarith.c
3150: *** ../../gnu/gdb/valarith.c Sun Apr 5 00:40:44 1987
3151: --- ./valarith.c Fri May 22 20:18:46 1987
3152: ***************
3153: *** 239,245 ****
3154: COERCE_ARRAY (arg1);
3155:
3156: len = TYPE_LENGTH (VALUE_TYPE (arg1));
3157: ! p = VALUE_CONTENTS (arg1);
3158:
3159: while (--len >= 0)
3160: {
3161: --- 239,245 ----
3162: COERCE_ARRAY (arg1);
3163:
3164: len = TYPE_LENGTH (VALUE_TYPE (arg1));
3165: ! p = (char *) VALUE_CONTENTS (arg1);
3166:
3167: while (--len >= 0)
3168: {
3169: ***************
3170: *** 281,288 ****
3171: && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
3172: == TYPE_LENGTH (VALUE_TYPE (arg2))))
3173: {
3174: ! p1 = VALUE_CONTENTS (arg1);
3175: ! p2 = VALUE_CONTENTS (arg2);
3176: while (--len >= 0)
3177: {
3178: if (*p1++ != *p2++)
3179: --- 281,288 ----
3180: && ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
3181: == TYPE_LENGTH (VALUE_TYPE (arg2))))
3182: {
3183: ! p1 = (char *) VALUE_CONTENTS (arg1);
3184: ! p2 = (char *) VALUE_CONTENTS (arg2);
3185: while (--len >= 0)
3186: {
3187: if (*p1++ != *p2++)
3188: ***************
3189: *** 348,353 ****
3190: --- 348,355 ----
3191: return value_from_long (VALUE_TYPE (arg1), ~ value_as_long (arg1));
3192: }
3193:
3194: + valarithinitialize() {initialize();}
3195: +
3196: static
3197: initialize ()
3198: {
3199: diff -c ../../gnu/gdb/valops.c ./valops.c
3200: *** ../../gnu/gdb/valops.c Sun Apr 5 00:41:32 1987
3201: --- ./valops.c Fri May 22 20:13:02 1987
3202: ***************
3203: *** 174,180 ****
3204: /* Return a value just like TOVAL except with the contents of FROMVAL. */
3205:
3206: val = allocate_value (type);
3207: ! bcopy (toval, val, VALUE_CONTENTS (val) - (char *) val);
3208: bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
3209:
3210: return val;
3211: --- 174,180 ----
3212: /* Return a value just like TOVAL except with the contents of FROMVAL. */
3213:
3214: val = allocate_value (type);
3215: ! bcopy (toval, val, (char *) VALUE_CONTENTS (val) - (char *) val);
3216: bcopy (VALUE_CONTENTS (fromval), VALUE_CONTENTS (val), TYPE_LENGTH (type));
3217:
3218: return val;
3219: ***************
3220: *** 413,419 ****
3221: --- 413,427 ----
3222: }
3223: else if (code == TYPE_CODE_PTR)
3224: {
3225: + #ifdef ibm032
3226: + /* apparently '_a' pseudoprocedure has lval_memory as its lval type */
3227: + if (VALUE_LVAL(function) == lval_memory)
3228: + funaddr = VALUE_ADDRESS(function);
3229: + else
3230: + funaddr = value_as_long (function);
3231: + #else
3232: funaddr = value_as_long (function);
3233: + #endif
3234: if (TYPE_CODE (TYPE_TARGET_TYPE (ftype))
3235: == TYPE_CODE_FUNC)
3236: value_type = TYPE_TARGET_TYPE (TYPE_TARGET_TYPE (ftype));
3237: ***************
3238: *** 429,439 ****
3239: else
3240: /* Handle integer used as address of a function. */
3241: funaddr = value_as_long (function);
3242: -
3243: value_type = builtin_type_int;
3244: }
3245: ! else
3246: error ("Invalid data type for function to be called.");
3247:
3248: /* Create a call sequence customized for this function
3249: and the number of arguments for it. */
3250: --- 437,447 ----
3251: else
3252: /* Handle integer used as address of a function. */
3253: funaddr = value_as_long (function);
3254: value_type = builtin_type_int;
3255: }
3256: ! else {
3257: error ("Invalid data type for function to be called.");
3258: + }
3259:
3260: /* Create a call sequence customized for this function
3261: and the number of arguments for it. */
3262: ***************
3263: *** 590,595 ****
3264: --- 598,605 ----
3265: return value_field (arg1, i);
3266: }
3267:
3268: + valopsinitialize() {initialize();}
3269: +
3270: static
3271: initialize ()
3272: { }
3273: diff -c ../../gnu/gdb/valprint.c ./valprint.c
3274: *** ../../gnu/gdb/valprint.c Sun Apr 5 00:42:28 1987
3275: --- ./valprint.c Mon Apr 27 00:40:56 1987
3276: ***************
3277: *** 529,534 ****
3278: --- 529,536 ----
3279: print_max = atoi (arg);
3280: }
3281:
3282: + valprintinitialize() {initialize();}
3283: +
3284: static
3285: initialize ()
3286: {
3287: diff -c ../../gnu/gdb/value.h ./value.h
3288: *** ../../gnu/gdb/value.h Sun Apr 5 00:43:44 1987
3289: --- ./value.h Fri May 22 20:03:32 1987
3290: ***************
3291: *** 37,43 ****
3292: short repeated;
3293: short repetitions;
3294: short regno;
3295: ! char contents[1];
3296: };
3297:
3298: typedef struct value *value;
3299: --- 37,43 ----
3300: short repeated;
3301: short repetitions;
3302: short regno;
3303: ! long contents[1]; /* Forces alignment... */
3304: };
3305:
3306: typedef struct value *value;
3307: diff -c ../../gnu/gdb/values.c ./values.c
3308: *** ../../gnu/gdb/values.c Sun Apr 5 00:45:14 1987
3309: --- ./values.c Fri May 22 20:12:40 1987
3310: ***************
3311: *** 338,344 ****
3312: int offset, bitpos, bitsize;
3313: value newval;
3314: {
3315: ! register char *addr = VALUE_CONTENTS (var->value) + offset;
3316: if (bitsize)
3317: modify_field (addr, value_as_long (newval),
3318: bitpos, bitsize);
3319: --- 338,344 ----
3320: int offset, bitpos, bitsize;
3321: value newval;
3322: {
3323: ! register char *addr = (char *) VALUE_CONTENTS (var->value) + offset;
3324: if (bitsize)
3325: modify_field (addr, value_as_long (newval),
3326: bitpos, bitsize);
3327: ***************
3328: *** 733,738 ****
3329: --- 733,740 ----
3330: write_register (1, retbuf[1]);
3331: }
3332:
3333: + valuesinitialize() {initialize();}
3334: +
3335: static
3336: initialize ()
3337: {
3338:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.