+Sun Mar 1 17:41:09 1992 Per Bothner (bothner@cygnus.com)
+
+ * breakpoint.c (breakpoint_re_set): Removed (at least for now)
+ printing of blank line, since it cases printing of an
+ extra blank line. Is this intended? It does mess up
+ gdb test suite.
+ * defs.h: Put back declarations of malloc and realloc,
+ but protected by #ifndef MALLOC_INCOMPATIBLE.
+ * objfiles.c: Undo previous change: Use malloc/realloc
+ for objfile malloc/realloc fields (but add a cast).
+ * xcoffexec.c: Suppress an error message (for now).
+
+Sat Feb 29 14:43:02 1992 Per Bothner (bothner@cygnus.com)
+
+ Changes from metin@ibmpa.awdpa.ibm.com (Metin G. Ozisik)
+ [Mail dated Fri, 21 Feb 92 13:14:54 -0800]
+ * buildsym.c: Use smash_to_pointer_type() to handle forward type
+ references.
+ * xcoffread.c: Modifications to C_DECL storage class handling, and
+ introduction of an old smash_to_pointer_type() routine.
+
+ Changes from metin@ibmpa.awdpa.ibm.com (Metin G. Ozisik)
+ [Mail dated Thu, 20 Feb 92 13:57:16 -0800]
+ * rs6000-xdep.c, rs6000-tdep.c, tm-rs6000.h: function_frame_info()
+ parameters have been modified.
+
+ Changes from metin@ibmpa.awdpa.ibm.com (Metin G. Ozisik)
+ [Mail dated Thu, 20 Feb 92 10:10:05 -0800]
+ * rs6000-tdep.c: Before Feb 5 92, register_valid[] array was not used,
+ and fetch_inferior_registers() always fetched all the registers
+ resulting valid register values at hand all the time. Pushing a dummy
+ frame did not require validating all register values first. After
+ putting the above mechanism into action, we didn't have valid registers
+ values always ready. Thus, all registers need to be fetched before
+ pushing a dummy frame now.
+
+ Changes from metin@ibmpa.awdpa.ibm.com (Metin G. Ozisik)
+ [Mail dated Thu, 13 Feb 92 16:22:44 -0800]
+ * rs6000-xdep.c: frame_initial_stack_address() function to calculate
+ the starting address (actual frame address) of a frame.
+ * rs6000-tdep.c: modifications to function_frame_info() to see if
+ function reserves a frame pointer register (alloca register)
+ * tm-rs6000.h: EXTRA_FRAME_INFO, FRAME_ARGS_ADDRESS and
+ FRAME_LOCALS_ADDRESS has been updated to support debugging of
+ functions with alloca() calls.
+
Sun Mar 1 13:13:39 1992 Fred Fish (fnf@cygnus.com)
* xm-sysv4.h: Provide definitions/prototypes for host environment
struct symbol *sym = find_symbol_in_list (symbols, name, pp-name);
if (!sym)
{
+#ifndef IBM6000
printf ("ERROR! stab symbol not found!\n"); /* FIXME */
+#endif
}
else
{
{
objfile = (struct objfile *) xmalloc (sizeof (struct objfile));
(void) memset (objfile, 0, sizeof (struct objfile));
- objfile -> malloc = xmalloc;
- objfile -> realloc = xrealloc;
+ objfile -> malloc = (PTR (*) PARAMS ((long))) malloc;
+ objfile -> realloc = (PTR (*) PARAMS ((PTR, long))) realloc;
objfile -> xmalloc = xmalloc;
objfile -> xrealloc = xrealloc;
objfile -> free = free;
CORE_ADDR text_start;
CORE_ADDR text_end;
-
/*************************************************************************
Support for creating pushind a dummy frame into the stack, and popping
frames, etc.
int sp, pc; /* stack pointer and link register */
int ii;
+ fetch_inferior_registers (-1);
+
if (dummy_frame_count >= dummy_frame_size) {
dummy_frame_size += DUMMY_FRAME_ADDR_SIZE;
if (dummy_frame_addr)
dummy_frame_addr [dummy_frame_count++] = sp;
/* Be careful! If the stack pointer is not decremented first, then kernel
- thinks he is free to use the sapce underneath it. And kernel actually
+ thinks he is free to use the space underneath it. And kernel actually
uses that area for IPC purposes when executing ptrace(2) calls. So
before writing register values into the new frame, decrement and update
%sp first in order to secure your frame. */
/* save program counter in link register's space. */
write_memory (sp+8, &pc, 4);
- /* save full floating point registers here. They will be from F14..F31
- for know. I am not sure if we need to save everything here! */
+ /* save all floating point and general purpose registers here. */
/* fpr's, f0..f31 */
for (ii = 0; ii < 32; ++ii)
pop_frame ()
{
int pc, lr, sp, prev_sp; /* %pc, %lr, %sp */
+ struct aix_framedata fdata;
FRAME fr = get_current_frame ();
- int offset = 0;
- int frameless = 0; /* TRUE if function is frameless */
int addr, ii;
- int saved_gpr, saved_fpr; /* # of saved gpr's and fpr's */
pc = read_pc ();
sp = FRAME_FP (fr);
saved %pc value in the previous frame. */
addr = get_pc_function_start (fr->pc) + FUNCTION_START_OFFSET;
- function_frame_info (addr, &frameless, &offset, &saved_gpr, &saved_fpr);
+ function_frame_info (addr, &fdata);
read_memory (sp, &prev_sp, 4);
- if (frameless)
+ if (fdata.frameless)
lr = read_register (LR_REGNUM);
else
read_memory (prev_sp+8, &lr, 4);
write_register (PC_REGNUM, lr);
/* reset register values if any was saved earlier. */
- addr = prev_sp - offset;
+ addr = prev_sp - fdata.offset;
- if (saved_gpr != -1)
- for (ii=saved_gpr; ii <= 31; ++ii) {
+ if (fdata.saved_gpr != -1)
+ for (ii=fdata.saved_gpr; ii <= 31; ++ii) {
read_memory (addr, ®isters [REGISTER_BYTE (ii)], 4);
addr += sizeof (int);
}
- if (saved_fpr != -1)
- for (ii=saved_fpr; ii <= 31; ++ii) {
+ if (fdata.saved_fpr != -1)
+ for (ii=fdata.saved_fpr; ii <= 31; ++ii) {
read_memory (addr, ®isters [REGISTER_BYTE (ii+FP0_REGNUM)], 8);
addr += 8;
}
/* return information about a function frame.
+ in struct aix_frameinfo fdata:
- frameless is TRUE, if function does not save %pc value in its frame.
- offset is the number of bytes used in the frame to save registers.
- saved_gpr is the number of the first saved gpr.
- saved_fpr is the number of the first saved fpr.
+ - alloca_reg is the number of the register used for alloca() handling.
+ Otherwise -1.
*/
-function_frame_info (pc, frameless, offset, saved_gpr, saved_fpr)
+function_frame_info (pc, fdata)
int pc;
- int *frameless, *offset, *saved_gpr, *saved_fpr;
+ struct aix_framedata *fdata;
{
unsigned int tmp;
register unsigned int op;
- *offset = 0;
- *saved_gpr = *saved_fpr = -1;
+ fdata->offset = 0;
+ fdata->saved_gpr = fdata->saved_fpr = fdata->alloca_reg = -1;
op = read_memory_integer (pc, 4);
if (op == 0x7c0802a6) { /* mflr r0 */
pc += 4;
op = read_memory_integer (pc, 4);
- *frameless = 0;
+ fdata->frameless = 0;
}
else /* else, this is a frameless invocation */
- *frameless = 1;
+ fdata->frameless = 1;
if ((op & 0xfc00003e) == 0x7c000026) { /* mfcr Rx */
if ((op & 0xfc1f0000) == 0xbc010000) { /* stm Rx, NUM(r1) */
int tmp2;
- *saved_gpr = (op >> 21) & 0x1f;
+ fdata->saved_gpr = (op >> 21) & 0x1f;
tmp2 = op & 0xffff;
if (tmp2 > 0x7fff)
tmp2 = 0xffff0000 | tmp2;
if (tmp2 < 0) {
tmp2 = tmp2 * -1;
- *saved_fpr = (tmp2 - ((32 - *saved_gpr) * 4)) / 8;
- if ( *saved_fpr > 0)
- *saved_fpr = 32 - *saved_fpr;
+ fdata->saved_fpr = (tmp2 - ((32 - fdata->saved_gpr) * 4)) / 8;
+ if ( fdata->saved_fpr > 0)
+ fdata->saved_fpr = 32 - fdata->saved_fpr;
else
- *saved_fpr = -1;
+ fdata->saved_fpr = -1;
}
- *offset = tmp2;
+ fdata->offset = tmp2;
+ pc += 4;
+ op = read_memory_integer (pc, 4);
}
+
+ while (((tmp = op >> 16) == 0x9001) || /* st r0, NUM(r1) */
+ (tmp == 0x9421) || /* stu r1, NUM(r1) */
+ (op == 0x93e1fffc)) /* st r31,-4(r1) */
+ {
+ /* gcc takes a short cut and uses this instruction to save r31 only. */
+
+ if (op == 0x93e1fffc) {
+ if (fdata->offset)
+/* fatal ("Unrecognized prolog."); */
+ printf ("Unrecognized prolog!\n");
+
+ fdata->saved_gpr = 31;
+ fdata->offset = 4;
+ }
+ pc += 4;
+ op = read_memory_integer (pc, 4);
+ }
+
+ while ((tmp = (op >> 22)) == 0x20f) { /* l r31, ... or */
+ pc += 4; /* l r30, ... */
+ op = read_memory_integer (pc, 4);
+ }
+
+ /* store parameters into stack */
+ while(
+ (op & 0xfc1f0000) == 0xd8010000 || /* stfd Rx,NUM(r1) */
+ (op & 0xfc1f0000) == 0x90010000 || /* st r?, NUM(r1) */
+ (op & 0xfc000000) == 0xfc000000 || /* frsp, fp?, .. */
+ (op & 0xd0000000) == 0xd0000000) /* stfs, fp?, .. */
+ {
+ pc += 4; /* store fpr double */
+ op = read_memory_integer (pc, 4);
+ }
+
+ if (op == 0x603f0000) /* oril r31, r1, 0x0 */
+ fdata->alloca_reg = 31;
}
write_register (SP_REGNUM, sp);
-#if 0
- pc = read_pc ();
- flush_cached_frames ();
- set_current_frame (create_new_frame (sp, pc));
-#endif
-
/* if the last argument copied into the registers didn't fit there
completely, push the rest of it into stack. */
ii += ((len + 3) & -4) / 4;
}
}
- else {
-
+ else
/* Secure stack areas first, before doing anything else. */
write_register (SP_REGNUM, sp);
-#if 0
- pc = read_pc ();
- flush_cached_frames ();
- set_current_frame (create_new_frame (sp, pc));
-#endif
- }
-
saved_sp = dummy_frame_addr [dummy_frame_count - 1];
read_memory (saved_sp, tmp_buffer, 24);
write_memory (sp, tmp_buffer, 24);
struct frame_info *fi;
{
CORE_ADDR func_start;
- int frameless, dummy;
+ struct aix_framedata fdata;
func_start = get_pc_function_start (fi->pc) + FUNCTION_START_OFFSET;
if (!func_start)
return 0;
- function_frame_info (func_start, &frameless, &dummy, &dummy, &dummy);
- return frameless;
+ function_frame_info (func_start, &fdata);
+ return fdata.frameless;
}
+/* Return the address of a frame. This is the inital %sp value when the frame
+ was first allocated. For functions calling alloca(), it might be saved in
+ an alloca register. */
+
+CORE_ADDR
+frame_initial_stack_address (fi)
+struct frame_info *fi;
+{
+ CORE_ADDR frame_addr, tmpaddr;
+ struct aix_framedata fdata;
+ struct frame_info *callee_fi;
+ int ii;
+
+ extern struct obstack frame_cache_obstack;
+
+ /* if the initial stack pointer (frame address) of this frame is known,
+ just return it. */
+
+ if (fi->initial_sp)
+ return fi->initial_sp;
+
+ /* find out if this function is using an alloca register.. */
+
+ tmpaddr = get_pc_function_start (fi->pc);
+ function_frame_info (tmpaddr, &fdata);
+
+ /* if saved registers of this frame are not known yet, read and cache them. */
+
+ if (!fi->cache_fsr) {
+ fi->cache_fsr = (struct frame_saved_regs *)
+ obstack_alloc (&frame_cache_obstack, sizeof (struct frame_saved_regs));
+ bzero (fi->cache_fsr, sizeof (struct frame_saved_regs));
+
+ if (fi->prev && fi->prev->frame)
+ frame_addr = fi->prev->frame;
+ else
+ frame_addr = read_memory_integer (fi->frame, 4);
+
+ /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr. All fpr's
+ from saved_fpr to fp31 are saved right underneath caller stack pointer,
+ starting from fp31 first. */
+
+ if (fdata.saved_fpr >= 0) {
+ for (ii=31; ii >= fdata.saved_fpr; --ii)
+ fi->cache_fsr->regs [FP0_REGNUM + ii] = frame_addr - ((32 - ii) * 8);
+ frame_addr -= (32 - fdata.saved_fpr) * 8;
+ }
+
+ /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr. All gpr's
+ from saved_gpr to gpr31 are saved right under saved fprs, starting
+ from r31 first. */
+
+ if (fdata.saved_gpr >= 0)
+ for (ii=31; ii >= fdata.saved_gpr; --ii)
+ fi->cache_fsr->regs [ii] = frame_addr - ((32 - ii) * 4);
+ }
+
+ /* If no alloca register used, then fi->frame is the value of the %sp for
+ this frame, and it is good enough. */
+
+ if (fdata.alloca_reg < 0) {
+ fi->initial_sp = fi->frame;
+ return fi->initial_sp;
+ }
+
+ /* This function has an alloca register. If this is the top-most frame
+ (with the lowest address), the value in alloca register is good. */
+
+ if (!fi->next)
+ return fi->initial_sp = read_register (fdata.alloca_reg);
+
+ /* Otherwise, this is a caller frame. Callee has already saved (???) its
+ registers. Find the address in which caller's alloca register is saved. */
+
+ for (callee_fi = fi->next; callee_fi; callee_fi = callee_fi->next) {
+
+ if (!callee_fi->cache_fsr)
+ fatal ("Callee has not saved caller's registers.");
+
+ /* this is the address in which alloca register is saved. */
+
+ tmpaddr = callee_fi->cache_fsr->regs [fdata.alloca_reg];
+ if (tmpaddr) {
+ fi->initial_sp = read_memory_integer (tmpaddr, 4);
+ return fi->initial_sp;
+ }
+
+ /* Go look into deeper levels of the frame chain to see if any one of
+ the callees has saved alloca register. */
+ }
+
+ /* If alloca register was not saved, by the callee (or any of its callees)
+ then the value in the register is still good. */
+
+ return fi->initial_sp = read_register (fdata.alloca_reg);
+}
+
+
+
/* aixcoff_relocate_symtab - hook for symbol table relocation.
also reads shared libraries.. */
/* We are missing register descriptions in the system header files. Sigh! */
struct regs {
- int gregs [32]; /* general purpose registers */
- int pc; /* program conter */
- int ps; /* processor status, or machine state */
+ int gregs [32]; /* general purpose registers */
+ int pc; /* program conter */
+ int ps; /* processor status, or machine state */
};
struct fp_status {
- double fpregs [32]; /* floating GP registers */
+ double fpregs [32]; /* floating GP registers */
};
+
+/* To be used by function_frame_info. */
+
+struct aix_framedata {
+ int offset; /* # of bytes in gpr's and fpr's are saved */
+ int saved_gpr; /* smallest # of saved gpr */
+ int saved_fpr; /* smallest # of saved fpr */
+ int alloca_reg; /* alloca register number (frame ptr) */
+ char frameless; /* true if frameless functions. */
+};
+
+
/* Define the byte order of the machine. */
#define TARGET_BYTE_ORDER BIG_ENDIAN
#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \
FRAMELESS = frameless_function_invocation (FI)
+/* Functions calling alloca() change the value of the stack pointer. We
+ need to use initial stack pointer (which is saved in r31 by gcc) in
+ such cases. If a compiler emits traceback table, then we should use the
+ alloca register specified in traceback table. FIXME. */
+/* Also, it is a good idea to cache information about frame's saved registers
+ in the frame structure to speed things up. See tm-m88k.h. FIXME. */
+
+#define EXTRA_FRAME_INFO \
+ CORE_ADDR initial_sp; /* initial stack pointer. */ \
+ struct frame_saved_regs *cache_fsr; /* saved registers */
+
/* Frameless function invocation in IBM RS/6000 is half-done. It perfectly
sets up a new frame, e.g. a new frame (in fact stack) pointer, etc, but it
doesn't save the %pc. In the following, even though it is considered a
frameless invocation, we still need to walk one frame up. */
#define INIT_EXTRA_FRAME_INFO(fromleaf, fi) \
+ fi->initial_sp = 0; \
+ fi->cache_fsr = 0; \
if (fromleaf) { \
int tmp = 0; \
read_memory ((fi)->frame, &tmp, sizeof (int)); \
#define FRAME_SAVED_PC(FRAME) \
read_memory_integer (read_memory_integer ((FRAME)->frame, 4)+8, 4)
-#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame)
+#define FRAME_ARGS_ADDRESS(FI) \
+ (((struct frame_info*)(FI))->initial_sp ? \
+ ((struct frame_info*)(FI))->initial_sp : \
+ frame_initial_stack_address (FI))
+
+#define FRAME_LOCALS_ADDRESS(FI) FRAME_ARGS_ADDRESS(FI)
-#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame)
/* Set VAL to the number of args passed to frame described by FI.
Can set VAL to -1, meaning no way to tell. */
#define FRAME_FIND_SAVED_REGS(FRAME_INFO, FRAME_SAVED_REGS) \
{ \
- int frameless, offset, saved_gpr, saved_fpr, ii, frame_addr, func_start; \
+ int ii, frame_addr, func_start; \
+ struct aix_framedata fdata; \
\
/* find the start of the function and collect info about its frame. */ \
\
func_start = get_pc_function_start ((FRAME_INFO)->pc) + FUNCTION_START_OFFSET;\
- function_frame_info (func_start, &frameless, &offset, &saved_gpr, &saved_fpr);\
+ function_frame_info (func_start, &fdata); \
bzero (&(FRAME_SAVED_REGS), sizeof (FRAME_SAVED_REGS)); \
\
/* if there were any saved registers, figure out parent's stack pointer. */ \
frame_addr = 0; \
- if (saved_fpr >= 0 || saved_gpr >= 0) { \
+ /* the following is true only if the frame doesn't have a call to alloca(), \
+ FIXME. */ \
+ if (fdata.saved_fpr >= 0 || fdata.saved_gpr >= 0) { \
if ((FRAME_INFO)->prev && (FRAME_INFO)->prev->frame) \
frame_addr = (FRAME_INFO)->prev->frame; \
else \
frame_addr = read_memory_integer ((FRAME_INFO)->frame, 4); \
} \
\
- /* if != -1, saved_fpr is the smallest number of saved_fpr. All fpr's \
+ /* if != -1, fdata.saved_fpr is the smallest number of saved_fpr. All fpr's \
from saved_fpr to fp31 are saved right underneath caller stack pointer, \
starting from fp31 first. */ \
\
- if (saved_fpr >= 0) { \
- for (ii=31; ii >= saved_fpr; --ii) \
+ if (fdata.saved_fpr >= 0) { \
+ for (ii=31; ii >= fdata.saved_fpr; --ii) \
(FRAME_SAVED_REGS).regs [FP0_REGNUM + ii] = frame_addr - ((32 - ii) * 8); \
- frame_addr -= (32 - saved_fpr) * 8; \
+ frame_addr -= (32 - fdata.saved_fpr) * 8; \
} \
\
- /* if != -1, saved_gpr is the smallest number of saved_gpr. All gpr's \
+ /* if != -1, fdata.saved_gpr is the smallest number of saved_gpr. All gpr's \
from saved_gpr to gpr31 are saved right under saved fprs, starting \
from r31 first. */ \
\
- if (saved_gpr >= 0) \
- for (ii=31; ii >= saved_gpr; --ii) \
+ if (fdata.saved_gpr >= 0) \
+ for (ii=31; ii >= fdata.saved_gpr; --ii) \
(FRAME_SAVED_REGS).regs [ii] = frame_addr - ((32 - ii) * 4); \
}
else {
obj_err:
bfd_close(bfd);
+#if 0
+/* FIXME -- bfd doesn't recognize /lib/libc.a as an archive */
/* FIXME -- should be error */
warning("\"%s\": not in executable format: %s."
, ldi->ldinfo_filename, bfd_errmsg(bfd_error));
+#endif
return;
}
}
record_include_begin (cs)
struct coff_symbol *cs;
{
- /* In aixcoff, we assume include files cannot be nested (not in .c file
+ /* In aixcoff, we assume include files cannot be nested (not in .c files
of course, but in corresponding .s files.) */
if (inclDepth)
parmvalue += sizeof (float);
}
}
- else { /* fixed parm */
- ADD_PARM_TO_PENDING
- (parm, parmvalue, builtin_type_int, local_symbols);
+ else { /* fixed parm, use (int*) for hex rep. */
+ ADD_PARM_TO_PENDING (parm, parmvalue,
+ lookup_pointer_type (builtin_type_int),
+ local_symbols);
parmvalue += sizeof (int);
}
mask = mask >> 1;
struct type *ttype;
char *name, *pp, *qq;
int struct_and_type_combined;
+ int nameless;
name = cs->c_name;
if (name[0] == '.')
case C_DECL: /* a type decleration?? */
qq = (char*) strchr (name, ':');
- /* skip if there is no ':' or a nameless construct */
if (!qq) /* skip if there is no ':' */
return NULL;
+ nameless = (qq == name);
+
struct_and_type_combined = (qq[1] == 'T' && qq[2] == 't');
pp = qq + (struct_and_type_combined ? 3 : 2);
read_type_number (&tmp_pp, typenums);
tmp_type = dbx_alloc_type (typenums);
- if (tmp_type && !TYPE_NAME (tmp_type))
+ if (tmp_type && !TYPE_NAME (tmp_type) && !nameless)
TYPE_NAME (tmp_type) = SYMBOL_NAME (sym) =
obsavestring (name, qq-name);
}
there is no need to keep it in symbol table. */
/* The above argument no longer valid. read_type() never returns NULL. */
- if (!ttype || name == qq)
+ if (!ttype)
return NULL;
- if (qq[1] == 'T')
- SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
- else if (qq[1] == 't')
- SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
- else {
- printf ("ERROR: Unrecognized stab string.\n");
- return NULL;
- }
+ /* if there is no name for this typedef, you don't have to keep its
+ symbol, since nobody could ask for it. Otherwise, build a symbol
+ and add it into symbol_list. */
+
+ if (!nameless) {
+ if (qq[1] == 'T')
+ SYMBOL_NAMESPACE (sym) = STRUCT_NAMESPACE;
+ else if (qq[1] == 't')
+ SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+ else {
+ printf ("ERROR: Unrecognized stab string.\n");
+ return NULL;
+ }
+
+ SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+ if (!SYMBOL_NAME (sym))
+ SYMBOL_NAME (sym) = obsavestring (name, qq-name,
+ &objfile->symbol_obstack);
+
+ SYMBOL_DUP (sym, sym2);
+ add_symbol_to_list
+ (sym2, within_function ? &local_symbols : &file_symbols);
+
+ /* For a combination of struct and type, add one more symbol
+ for the type. */
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
- if (!SYMBOL_NAME (sym))
- SYMBOL_NAME (sym) =
- obsavestring (name, qq-name, &objfile->symbol_obstack);
+ if (struct_and_type_combined) {
+ SYMBOL_DUP (sym, sym2);
+ SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
+ add_symbol_to_list
+ (sym2, within_function ? &local_symbols : &file_symbols);
+ }
+ }
- if (struct_and_type_combined)
- ;
- else if (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE)
+ /* assign a name to the type node. */
+
+ if (!nameless && (!TYPE_NAME (ttype) || *(TYPE_NAME (ttype)) == '\0')) {
+ if (struct_and_type_combined)
+ TYPE_NAME (ttype) = SYMBOL_NAME (sym);
+
+/* else if (SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE) */
+ else if (qq[1] == 'T') /* struct namespace */
TYPE_NAME (ttype) = concat (
TYPE_CODE (ttype) == TYPE_CODE_UNION ? "union " :
TYPE_CODE (ttype) == TYPE_CODE_STRUCT? "struct " : "enum ",
SYMBOL_NAME (sym), NULL);
-
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
-
- /* For a combination of struct and type, add one more symbol for the type. */
- if (struct_and_type_combined) {
- SYMBOL_DUP (sym, sym2);
- SYMBOL_NAMESPACE (sym2) = VAR_NAMESPACE;
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
}
+
break;
case C_GSYM:
{
add_symtab_fns(&aixcoff_sym_fns);
}
+
+
+/* In order to handle forward type references, we needed to have this old
+ routine. Try printing the type of member `p' in the following structure
+ in a dbx environment.
+
+ struct s {
+ ...
+ struct s *p;
+ };
+*/
+#if 0
+/* Smash TYPE to be a type of pointers to TO_TYPE.
+ If TO_TYPE is not permanent and has no pointer-type yet,
+ record TYPE as its pointer-type. */
+
+void
+smash_to_pointer_type (type, to_type)
+ struct type *type, *to_type;
+{
+ int type_permanent = (TYPE_FLAGS (type) & TYPE_FLAG_PERM);
+
+ bzero (type, sizeof (struct type));
+ TYPE_TARGET_TYPE (type) = to_type;
+ /* We assume the machine has only one representation for pointers! */
+ TYPE_LENGTH (type) = sizeof (char *);
+ TYPE_CODE (type) = TYPE_CODE_PTR;
+
+/* ??? TYPE_TARGET_TYPE and TYPE_MAIN_VARIANT are the same. You can't do
+ this. It will break the target type!!!
+ TYPE_MAIN_VARIANT (type) = type;
+*/
+
+ if (type_permanent)
+ TYPE_FLAGS (type) |= TYPE_FLAG_PERM;
+
+ if (TYPE_POINTER_TYPE (to_type) == 0
+ && (!(TYPE_FLAGS (to_type) & TYPE_FLAG_PERM)
+ || type_permanent))
+ {
+ TYPE_POINTER_TYPE (to_type) = type;
+ }
+}
+#endif
+
#else /* IBM6000 */
struct type *
builtin_type (pp)
#ifndef IBM6000
#define IBM6000
#endif
+
+/* /usr/include/stdlib.h always uses void* and void,
+ even when __STDC__ isn't defined. */
+#define MALLOC_INCOMPATIBLE
+extern void* malloc PARAMS (());
+extern void* realloc PARAMS (());
+extern void free PARAMS (());
+
projects / binutils-gdb.git / commitdiff