CbC/CbC_gcc: gcc/dbxout.c comparison

comparison gcc/dbxout.c @ 55:77e2b8dfacca gcc-4.4.5

update it from 4.4.3 to 4.5.0

author	ryoma <e075725@ie.u-ryukyu.ac.jp>
date	Fri, 12 Feb 2010 23:39:51 +0900
parents	855418dad1a3
children	f6334be47118

comparison

equal deleted inserted replaced

-:c156f1bd5cd9
+:77e2b8dfacca
 /* Output dbx-format symbol table information from GNU compiler.
 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
-1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
 Free Software Foundation, Inc.
 This file is part of GCC.
 GCC is free software; you can redistribute it and/or modify it under
 the definition of the type.  TYPE_XREF says we have
 output it as a cross-reference only.
 The file_number and type_number elements are used if DBX_USE_BINCL
 is defined.  */
-struct typeinfo GTY(())
+struct GTY(()) typeinfo {
-{
 enum typestatus status;
 int file_number;
 int type_number;
 };
 enum binclstatus bincl_status;  /* Keep track of lazy bincl.  */
 const char *pending_bincl_name; /* Name of bincl.  */
 struct dbx_file *prev;          /* Chain to traverse all pending bincls.  */
 };
 /* This is the top of the stack.
 This is not saved for PCH, because restoring a PCH should not change it.
 next_file_number does have to be saved, because the PCH may use some
 file numbers; however, just before restoring a PCH, next_file_number
 should always be 0 because we should not have needed any file numbers
 yet.  */
 #define FORCE_TEXT
 #endif
 #include "gstab.h"
-#define STAB_CODE_TYPE enum __stab_debug_code
 /* 1 if PARM is passed to this function in memory.  */
 #define PARM_PASSED_IN_MEMORY(PARM) \
 (MEM_P (DECL_INCOMING_RTL (PARM)))
 static void emit_pending_bincls         (void);
 #endif
 static inline void emit_pending_bincls_if_required (void);
 static void dbxout_init (const char *);
 static void dbxout_finish (const char *);
 static void dbxout_start_source_file (unsigned, const char *);
 static void dbxout_end_source_file (unsigned);
 static void dbxout_typedefs (tree);
 static void dbxout_type_index (tree);
 static void dbxout_args (tree);
 static void dbxout_type_fields (tree);
 static void dbxout_type_method_1 (tree);
 static void dbxout_type_methods (tree);
-static void dbxout_range_type (tree);
+static void dbxout_range_type (tree, tree, tree);
 static void dbxout_type (tree, int);
-static bool print_int_cst_bounds_in_octal_p (tree);
+static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
 static bool is_fortran (void);
 static void dbxout_type_name (tree);
 static void dbxout_class_name_qualifiers (tree);
 static int dbxout_symbol_location (tree, tree, const char *, rtx);
 static void dbxout_symbol_name (tree, const char *, int);
-static void dbxout_common_name (tree, const char *, STAB_CODE_TYPE);
+static void dbxout_common_name (tree, const char *, stab_code_type);
 static const char *dbxout_common_check (tree, int *);
 static void dbxout_global_decl (tree);
 static void dbxout_type_decl (tree, int);
 static void dbxout_handle_pch (unsigned);
 /* The debug hooks structure.  */
 #if defined (DBX_DEBUGGING_INFO)
-static void dbxout_source_line (unsigned int, const char *);
+static void dbxout_source_line (unsigned int, const char *, int, bool);
 static void dbxout_begin_prologue (unsigned int, const char *);
 static void dbxout_source_file (const char *);
 static void dbxout_function_end (tree);
 static void dbxout_begin_function (tree);
 static void dbxout_begin_block (unsigned, unsigned);
 debug_nothing_tree,		         /* outlining_inline_function */
 debug_nothing_rtx,		         /* label */
 dbxout_handle_pch,		         /* handle_pch */
 debug_nothing_rtx,		         /* var_location */
 debug_nothing_void,                    /* switch_text_section */
+debug_nothing_tree,		         /* direct_call */
+debug_nothing_tree_int,		 /* virtual_call_token */
+debug_nothing_rtx_rtx,	         /* copy_call_info */
+debug_nothing_uid,		         /* virtual_call */
+debug_nothing_tree_tree,		 /* set_name */
 0                                      /* start_end_main_source_file */
 };
 #endif /* DBX_DEBUGGING_INFO  */
 #if defined (XCOFF_DEBUGGING_INFO)
 debug_nothing_tree,		         /* outlining_inline_function */
 debug_nothing_rtx,		         /* label */
 dbxout_handle_pch,		         /* handle_pch */
 debug_nothing_rtx,		         /* var_location */
 debug_nothing_void,                    /* switch_text_section */
+debug_nothing_tree,		         /* direct_call */
+debug_nothing_tree_int,		 /* virtual_call_token */
+debug_nothing_rtx_rtx,	         /* copy_call_info */
+debug_nothing_uid,		         /* virtual_call */
+debug_nothing_tree_tree,	         /* set_name */
 0                                      /* start_end_main_source_file */
 };
 #endif /* XCOFF_DEBUGGING_INFO  */
 /* Numeric formatting helper macro.  Note that this does not handle
 DBX_CONTIN_LENGTH-sized chunks.
 SYM is the DECL of the symbol under consideration; it is used only
 for its DECL_SOURCE_LINE.  The other arguments are all passed directly
 to DBX_FINISH_STABS; see above for details.  */
 static void
-dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
+dbxout_finish_complex_stabs (tree sym, stab_code_type code,
 			     rtx addr, const char *label, int number)
 {
 int line ATTRIBUTE_UNUSED;
 char *str;
 size_t len;
 	 It is faster to augment the string with the close quote and
 	 comma than to do a two-character fputs.  */
 obstack_grow (&stabstr_ob, "\",", 2);
 len = obstack_object_size (&stabstr_ob);
 str = XOBFINISH (&stabstr_ob, char *);
 fwrite (str, 1, len, asm_out_file);
 DBX_FINISH_STABS (sym, code, line, addr, label, number);
 }
 obstack_free (&stabstr_ob, str);
 }
 #if defined (DBX_DEBUGGING_INFO)
 static void
-dbxout_function_end (tree decl)
+dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
 {
 char lscope_label_name[100];
 /* The Lscope label must be emitted even if we aren't doing anything
 else; dbxout_block needs it.  */
 switch_to_section (function_section (current_function_decl));
 /* Convert Lscope into the appropriate format for local labels in case
 the system doesn't insert underscores in front of user generated
 labels.  */
 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
 /* The N_FUN tag at the end of the function is a GNU extension,
 which may be undesirable, and is unnecessary if we do not have
 named sections.  */
 if (!use_gnu_debug_info_extensions
 || NO_DBX_FUNCTION_END
-|| !targetm.have_named_sections
+|| !targetm.have_named_sections)
-|| DECL_IGNORED_P (decl))
 return;
 /* By convention, GCC will mark the end of a function with an N_FUN
 symbol and an empty string.  */
 if (flag_reorder_blocks_and_partition)
 {
 dbxout_begin_empty_stabs (N_FUN);
 dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
 				    crtl->subsections.hot_section_label);
 dbxout_begin_empty_stabs (N_FUN);
 dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
 				    crtl->subsections.cold_section_label);
 }
 else
 {
 char begin_label[20];
 #ifdef DBX_USE_BINCL
 struct dbx_file *n = XNEW (struct dbx_file);
 n->next = current_file;
 n->next_type_number = 1;
 /* Do not assign file number now.
 Delay it until we actually emit BINCL.  */
 n->file_number = 0;
 n->prev = NULL;
 current_file->prev = n;
 n->bincl_status = BINCL_PENDING;
 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
 lastfile = filename;
 }
 }
 /* Output N_BNSYM, line number symbol entry, and local symbol at
 function scope  */
 static void
 dbxout_begin_prologue (unsigned int lineno, const char *filename)
 {
 dbxout_stabd (N_BNSYM, 0);
 /* pre-increment the scope counter */
 scope_labelno++;
-dbxout_source_line (lineno, filename);
+dbxout_source_line (lineno, filename, 0, true);
 /* Output function begin block at function scope, referenced
 by dbxout_block, dbxout_source_line and dbxout_function_end.  */
 emit_pending_bincls_if_required ();
 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
 }
 /* Output a line number symbol entry for source file FILENAME and line
 number LINENO.  */
 static void
-dbxout_source_line (unsigned int lineno, const char *filename)
+dbxout_source_line (unsigned int lineno, const char *filename,
+int discriminator ATTRIBUTE_UNUSED,
+bool is_stmt ATTRIBUTE_UNUSED)
 {
 dbxout_source_file (filename);
 #ifdef DBX_OUTPUT_SOURCE_LINE
 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
 if (DBX_LINES_FUNCTION_RELATIVE)
 {
 char begin_label[20];
 dbxout_begin_stabn_sline (lineno);
 /* Reference current function start using LFBB.  */
 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
 					     begin_label);
 }
 else
 dbxout_stabd (N_SLINE, lineno);
 }
 }
 /* Emit a "range" type specification, which has the form:
 "r<index type>;<lower bound>;<upper bound>;".
-TYPE is an INTEGER_TYPE.  */
+TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds.  */
 static void
-dbxout_range_type (tree type)
+dbxout_range_type (tree type, tree low, tree high)
 {
 stabstr_C ('r');
 if (TREE_TYPE (type))
 dbxout_type (TREE_TYPE (type), 0);
 else if (TREE_CODE (type) != INTEGER_TYPE)
 else
 	dbxout_type_index (integer_type_node);
 }
 stabstr_C (';');
-if (TYPE_MIN_VALUE (type) != 0
+if (low && host_integerp (low, 0))
-&& host_integerp (TYPE_MIN_VALUE (type), 0))
+{
-{
+if (print_int_cst_bounds_in_octal_p (type, low, high))
-if (print_int_cst_bounds_in_octal_p (type))
+stabstr_O (low);
-stabstr_O (TYPE_MIN_VALUE (type));
 else
-stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
+stabstr_D (tree_low_cst (low, 0));
 }
 else
 stabstr_C ('0');
 stabstr_C (';');
-if (TYPE_MAX_VALUE (type) != 0
+if (high && host_integerp (high, 0))
-&& host_integerp (TYPE_MAX_VALUE (type), 0))
+{
-{
+if (print_int_cst_bounds_in_octal_p (type, low, high))
-if (print_int_cst_bounds_in_octal_p (type))
+stabstr_O (high);
-stabstr_O (TYPE_MAX_VALUE (type));
 else
-stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
+stabstr_D (tree_low_cst (high, 0));
 stabstr_C (';');
 }
 else
 stabstr_S ("-1;");
 }
 using the number previously allocated.  */
 static void
 dbxout_type (tree type, int full)
 {
-tree tem;
-tree main_variant;
 static int anonymous_type_number = 0;
 bool vector_type = false;
+tree tem, main_variant, low, high;
 if (TREE_CODE (type) == VECTOR_TYPE)
 {
 /* The frontend feeds us a representation for the vector as a struct
 	 containing an array.  Pull out the array type.  */
 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
 vector_type = true;
+}
+if (TREE_CODE (type) == INTEGER_TYPE)
+{
+if (TREE_TYPE (type) == 0)
+	{
+	  low = TYPE_MIN_VALUE (type);
+	  high = TYPE_MAX_VALUE (type);
+	}
+else if (subrange_type_for_debug_p (type, &low, &high))
+	;
+/* If this is a subtype that should not be emitted as a subrange type,
+	 use the base type.  */
+else
+	{
+	  type = TREE_TYPE (type);
+	  low = TYPE_MIN_VALUE (type);
+	  high = TYPE_MAX_VALUE (type);
+	}
 }
 /* If there was an input error and we don't really have a type,
 avoid crashing and write something that is at least valid
 by assuming `int'.  */
 	      stabstr_S ("@s");
 	      stabstr_D (TYPE_PRECISION (type));
 	      stabstr_C (';');
 	    }
-	  dbxout_range_type (type);
+	  dbxout_range_type (type, low, high);
 	}
 else
 	{
 	  /* If the size is non-standard, say what it is if we can use
 	      stabstr_S ("@s");
 	      stabstr_D (TYPE_PRECISION (type));
 	      stabstr_C (';');
 	    }
-	  if (print_int_cst_bounds_in_octal_p (type))
+	  if (print_int_cst_bounds_in_octal_p (type, low, high))
 	    {
 	      stabstr_C ('r');
 /* If this type derives from another type, output type index of
 		 parent type. This is particularly important when parent type
 dbxout_type_index (TREE_TYPE (type));
 else
 dbxout_type_index (type);
 	      stabstr_C (';');
-	      stabstr_O (TYPE_MIN_VALUE (type));
+	      stabstr_O (low);
 	      stabstr_C (';');
-	      stabstr_O (TYPE_MAX_VALUE (type));
+	      stabstr_O (high);
 	      stabstr_C (';');
 	    }
 	  else
 	    /* Output other integer types as subranges of `int'.  */
-	    dbxout_range_type (type);
+	    dbxout_range_type (type, low, high);
 	}
 break;
 case REAL_TYPE:
 	  stabstr_S (";0;-1;");
 	}
 else
 	{
 	  stabstr_C ('a');
-	  dbxout_range_type (tem);
+	  dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
 	}
 dbxout_type (TREE_TYPE (type), 0);
 break;
 	if (binfo)
 	  {
 	    int i;
 	    tree child;
 	    VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
 	    if (use_gnu_debug_info_extensions)
 	      {
 		if (BINFO_N_BASE_BINFOS (binfo))
 		  {
 		    stabstr_C ('!');
 /* Return nonzero if the given type represents an integer whose bounds
 should be printed in octal format.  */
 static bool
-print_int_cst_bounds_in_octal_p (tree type)
+print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
 {
 /* If we can use GDB extensions and the size is wider than a long
 (the size used by GDB to read them) or we may have trouble writing
 the bounds the usual way, write them in octal.  Note the test is for
 the *target's* size of "long", not that of the host.  The host test
 For unsigned types, we use octal if they are the same size or larger.
 This is because we print the bounds as signed decimal, and hence they
 can't span same size unsigned types.  */
 if (use_gnu_debug_info_extensions
-&& TYPE_MIN_VALUE (type) != 0
+&& low && TREE_CODE (low) == INTEGER_CST
-&& TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
+&& high && TREE_CODE (high) == INTEGER_CST
-&& TYPE_MAX_VALUE (type) != 0
-&& TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
 	  || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
 	      && TYPE_UNSIGNED (type))
 	  || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
 	  || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
 static void
 dbxout_type_name (tree type)
 {
 tree t = TYPE_NAME (type);
 gcc_assert (t);
 switch (TREE_CODE (t))
 {
 case IDENTIFIER_NODE:
 break;
 decl_rtl = dbxout_expand_expr (decl);
 if (!decl_rtl)
 	DBXOUT_DECR_NESTING_AND_RETURN (0);
-decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX);
+decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
 #ifdef LEAF_REG_REMAP
 if (current_function_uses_only_leaf_regs)
 	leaf_renumber_regs_insn (decl_rtl);
 #endif
 static int
 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
 {
 int letter = 0;
-STAB_CODE_TYPE code;
+stab_code_type code;
 rtx addr = 0;
 int number = 0;
 int regno = -1;
 /* Don't mention a variable at all
 code = N_LSYM;
 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
 }
 else if (MEM_P (home)
 	   && GET_CODE (XEXP (home, 0)) == PLUS
-	   && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
+	   && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
 {
 code = N_LSYM;
 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
 	 We want the value of that CONST_INT.  */
 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
 static void
 dbxout_symbol_name (tree decl, const char *suffix, int letter)
 {
 tree name;
 if (DECL_CONTEXT (decl)
 && (TYPE_P (DECL_CONTEXT (decl))
 	  || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
 /* One slight hitch: if this is a VAR_DECL which is a class member
 or a namespace member, we must put out the mangled name instead of the
 DECL_NAME.  Note also that static member (variable) names DO NOT begin
 around each group of symbols in the same .comm area.  The N_GSYM stabs
 that are emitted only contain the offset in the common area.  This routine
 emits the N_BCOMM and N_ECOMM stabs.  */
 static void
-dbxout_common_name (tree decl, const char *name, STAB_CODE_TYPE op)
+dbxout_common_name (tree decl, const char *name, stab_code_type op)
 {
 dbxout_begin_complex_stabs ();
 stabstr_S (name);
 dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
 }
 dbxout_common_check (tree decl, int *value)
 {
 rtx home;
 rtx sym_addr;
 const char *name = NULL;
-/* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
+/* If the decl isn't a VAR_DECL, or if it isn't static, or if
 it does not have a value (the offset into the common area), or if it
 is thread local (as opposed to global) then it isn't common, and shouldn't
 be handled as such.
 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
 for thread-local symbols.  Can be handled via same mechanism as used
 in dwarf2out.c.  */
 if (TREE_CODE (decl) != VAR_DECL
-|| !TREE_PUBLIC(decl)
 || !TREE_STATIC(decl)
 || !DECL_HAS_VALUE_EXPR_P(decl)
 || DECL_THREAD_LOCAL_P (decl)
 || !is_fortran ())
 return NULL;
 home = DECL_RTL (decl);
 if (home == NULL_RTX || GET_CODE (home) != MEM)
 return NULL;
 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
 if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
 tree cdecl = NULL;
 switch (GET_CODE (sym_addr))
 {
 case PLUS:
-if (GET_CODE (XEXP (sym_addr, 0)) == CONST_INT)
+if (CONST_INT_P (XEXP (sym_addr, 0)))
 {
 name =
 targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0));
 *value = INTVAL (XEXP (sym_addr, 0));
 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
 	&& DECL_RTL_SET_P (parms)
 	&& DECL_INCOMING_RTL (parms))
 {
 	tree eff_type;
 	char letter;
-	STAB_CODE_TYPE code;
+	stab_code_type code;
 	int number;
 	/* Perform any necessary register eliminations on the parameter's rtl,
 	   so that the debugging output will be accurate.  */
 	DECL_INCOMING_RTL (parms)
-	  = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
+	  = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
-	SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
+	SET_DECL_RTL (parms,
+		      eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
 #ifdef LEAF_REG_REMAP
 	if (current_function_uses_only_leaf_regs)
 	  {
 	    leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
 	    leaf_renumber_regs_insn (DECL_RTL (parms));
 	    /* ??? Here we assume that the parm address is indexed
 	       off the frame pointer or arg pointer.
 	       If that is not true, we produce meaningless results,
 	       but do not crash.  */
 	    if (GET_CODE (inrtl) == PLUS
-		&& GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
+		&& CONST_INT_P (XEXP (inrtl, 1)))
 	      number = INTVAL (XEXP (inrtl, 1));
 	    else
 	      number = 0;
 	    code = N_PSYM;
 	       Output it as if it lived in that register.
 	       The debugger will know from the type
 	       that it was actually passed by invisible reference.  */
 	    code = DBX_REGPARM_STABS_CODE;
 	    /* GDB likes this marked with a special letter.  */
 	    letter = (use_gnu_debug_info_extensions
 		      ? 'a' : DBX_REGPARM_STABS_LETTER);
 	    eff_type = TREE_TYPE (parms);
 	else
 	  /* ??? We don't know how to represent this argument.  */
 	  continue;
 	dbxout_begin_complex_stabs ();
 	if (DECL_NAME (parms))
 	  {
 	    stabstr_I (DECL_NAME (parms));
 	    stabstr_C (':');
 	  }
 static void
 dbxout_begin_function (tree decl)
 {
 int saved_tree_used1;
-if (DECL_IGNORED_P (decl))
-return;
 saved_tree_used1 = TREE_USED (decl);
 TREE_USED (decl) = 1;
 if (DECL_NAME (DECL_RESULT (decl)) != 0)
 {
 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));

Mercurial > hg > CbC > CbC_gcc

comparison gcc/dbxout.c @ 55:77e2b8dfacca gcc-4.4.5