#include "insn-config.h"
#include "reload.h"
#include "output.h"
+#include "dwarf2asm.h"
#include "toplev.h"
#include "tm_p.h"
#include "debug.h"
+#include "langhooks.h"
/* NOTE: In the comments in this file, many references are made to
so called "Debugging Information Entries". For the sake of brevity,
&& is_tagged_type (TREE_TYPE (decl)) \
&& decl == TYPE_STUB_DECL (TREE_TYPE (decl))))
-extern int flag_traditional;
-
/* Maximum size (in bytes) of an artificially generated label. */
#define MAX_ARTIFICIAL_LABEL_BYTES 30
static const char *primary_filename;
-/* Pointer to the most recent filename for which we produced some line info. */
-
-static const char *last_filename;
-
/* Counter to generate unique names for DIEs. */
static unsigned next_unused_dienum = 1;
static void generate_new_sfname_entry PARAMS ((void));
static unsigned lookup_filename PARAMS ((const char *));
static void generate_srcinfo_entry PARAMS ((unsigned, unsigned));
-static void generate_macinfo_entry PARAMS ((const char *, const char *));
+static void generate_macinfo_entry PARAMS ((unsigned int, rtx,
+ const char *));
static int is_pseudo_reg PARAMS ((rtx));
static tree type_main_variant PARAMS ((tree));
static int is_tagged_type PARAMS ((tree));
#ifndef ASM_OUTPUT_DWARF_DELTA2
#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
- do { fprintf ((FILE), "%s", UNALIGNED_SHORT_ASM_OP); \
- assemble_name (FILE, LABEL1); \
- fprintf (FILE, "-"); \
- assemble_name (FILE, LABEL2); \
- fprintf (FILE, "\n"); \
- } while (0)
+ dw2_asm_output_delta (2, LABEL1, LABEL2, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_DELTA4
#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
- do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
- assemble_name (FILE, LABEL1); \
- fprintf (FILE, "-"); \
- assemble_name (FILE, LABEL2); \
- fprintf (FILE, "\n"); \
- } while (0)
+ dw2_asm_output_delta (4, LABEL1, LABEL2, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_TAG
#define ASM_OUTPUT_DWARF_TAG(FILE,TAG) \
- do { \
- fprintf ((FILE), "%s0x%x", \
- UNALIGNED_SHORT_ASM_OP, (unsigned) TAG); \
- if (flag_debug_asm) \
- fprintf ((FILE), "\t%s %s", \
- ASM_COMMENT_START, dwarf_tag_name (TAG)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_data (2, TAG, "%s", dwarf_tag_name (TAG));
#endif
#ifndef ASM_OUTPUT_DWARF_ATTRIBUTE
#define ASM_OUTPUT_DWARF_ATTRIBUTE(FILE,ATTR) \
- do { \
- fprintf ((FILE), "%s0x%x", \
- UNALIGNED_SHORT_ASM_OP, (unsigned) ATTR); \
- if (flag_debug_asm) \
- fprintf ((FILE), "\t%s %s", \
- ASM_COMMENT_START, dwarf_attr_name (ATTR)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_data (2, ATTR, "%s", dwarf_attr_name (ATTR))
#endif
#ifndef ASM_OUTPUT_DWARF_STACK_OP
#define ASM_OUTPUT_DWARF_STACK_OP(FILE,OP) \
- do { \
- fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) OP); \
- if (flag_debug_asm) \
- fprintf ((FILE), "\t%s %s", \
- ASM_COMMENT_START, dwarf_stack_op_name (OP)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_data (1, OP, "%s", dwarf_stack_op_name (OP))
#endif
#ifndef ASM_OUTPUT_DWARF_FUND_TYPE
#define ASM_OUTPUT_DWARF_FUND_TYPE(FILE,FT) \
- do { \
- fprintf ((FILE), "%s0x%x", \
- UNALIGNED_SHORT_ASM_OP, (unsigned) FT); \
- if (flag_debug_asm) \
- fprintf ((FILE), "\t%s %s", \
- ASM_COMMENT_START, dwarf_fund_type_name (FT)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_data (2, FT, "%s", dwarf_fund_type_name (FT))
#endif
#ifndef ASM_OUTPUT_DWARF_FMT_BYTE
#define ASM_OUTPUT_DWARF_FMT_BYTE(FILE,FMT) \
- do { \
- fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) FMT); \
- if (flag_debug_asm) \
- fprintf ((FILE), "\t%s %s", \
- ASM_COMMENT_START, dwarf_fmt_byte_name (FMT)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_data (1, FMT, "%s", dwarf_fmt_byte_name (FMT));
#endif
#ifndef ASM_OUTPUT_DWARF_TYPE_MODIFIER
#define ASM_OUTPUT_DWARF_TYPE_MODIFIER(FILE,MOD) \
- do { \
- fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) MOD); \
- if (flag_debug_asm) \
- fprintf ((FILE), "\t%s %s", \
- ASM_COMMENT_START, dwarf_typemod_name (MOD)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_data (1, MOD, "%s", dwarf_typemod_name (MOD));
#endif
\f
#ifndef ASM_OUTPUT_DWARF_ADDR
#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
- do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
- assemble_name (FILE, LABEL); \
- fprintf (FILE, "\n"); \
- } while (0)
+ dw2_asm_output_addr (4, LABEL, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_ADDR_CONST
#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \
- do { \
- fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
- output_addr_const ((FILE), (RTX)); \
- fputc ('\n', (FILE)); \
- } while (0)
+ dw2_asm_output_addr_rtx (4, RTX, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_REF
#define ASM_OUTPUT_DWARF_REF(FILE,LABEL) \
- do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \
- assemble_name (FILE, LABEL); \
- fprintf (FILE, "\n"); \
- } while (0)
+ dw2_asm_output_addr (4, LABEL, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA1
#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
- fprintf ((FILE), "%s0x%x\n", ASM_BYTE_OP, VALUE)
+ dw2_asm_output_data (1, VALUE, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA2
#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
- fprintf ((FILE), "%s0x%x\n", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
+ dw2_asm_output_data (2, VALUE, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA4
#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
- fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
+ dw2_asm_output_data (4, VALUE, NULL)
#endif
#ifndef ASM_OUTPUT_DWARF_DATA8
#define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
- do { \
- if (WORDS_BIG_ENDIAN) \
- { \
- fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
- fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE); \
- } \
- else \
- { \
- fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE); \
- fprintf ((FILE), "%s0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
- } \
- } while (0)
+ dw2_asm_output_data (8, VALUE, NULL)
#endif
/* ASM_OUTPUT_DWARF_STRING is defined to output an ascii string, but to
NOT issue a trailing newline. We define ASM_OUTPUT_DWARF_STRING_NEWLINE
based on whether ASM_OUTPUT_DWARF_STRING is defined or not. If it is
defined, we call it, then issue the line feed. If not, we supply a
- default defintion of calling ASM_OUTPUT_ASCII */
+ default definition of calling ASM_OUTPUT_ASCII */
#ifndef ASM_OUTPUT_DWARF_STRING
#define ASM_OUTPUT_DWARF_STRING_NEWLINE(FILE,P) \
static inline int
is_pseudo_reg (rtl)
- register rtx rtl;
+ rtx rtl;
{
return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
|| ((GET_CODE (rtl) == SUBREG)
static inline tree
type_main_variant (type)
- register tree type;
+ tree type;
{
type = TYPE_MAIN_VARIANT (type);
static inline int
is_tagged_type (type)
- register tree type;
+ tree type;
{
- register enum tree_code code = TREE_CODE (type);
+ enum tree_code code = TREE_CODE (type);
return (code == RECORD_TYPE || code == UNION_TYPE
|| code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
static const char *
dwarf_tag_name (tag)
- register unsigned tag;
+ unsigned tag;
{
switch (tag)
{
static const char *
dwarf_attr_name (attr)
- register unsigned attr;
+ unsigned attr;
{
switch (attr)
{
static const char *
dwarf_stack_op_name (op)
- register unsigned op;
+ unsigned op;
{
switch (op)
{
static const char *
dwarf_typemod_name (mod)
- register unsigned mod;
+ unsigned mod;
{
switch (mod)
{
static const char *
dwarf_fmt_byte_name (fmt)
- register unsigned fmt;
+ unsigned fmt;
{
switch (fmt)
{
static const char *
dwarf_fund_type_name (ft)
- register unsigned ft;
+ unsigned ft;
{
switch (ft)
{
static tree
decl_ultimate_origin (decl)
- register tree decl;
+ tree decl;
{
#ifdef ENABLE_CHECKING
if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
static tree
block_ultimate_origin (block)
- register tree block;
+ tree block;
{
- register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
+ tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
if (immediate_origin == NULL)
return NULL;
else
{
- register tree ret_val;
- register tree lookahead = immediate_origin;
+ tree ret_val;
+ tree lookahead = immediate_origin;
do
{
#if 0
static void
output_unsigned_leb128 (value)
- register unsigned long value;
+ unsigned long value;
{
- register unsigned long orig_value = value;
+ unsigned long orig_value = value;
do
{
- register unsigned byte = (value & 0x7f);
+ unsigned byte = (value & 0x7f);
value >>= 7;
if (value != 0) /* more bytes to follow */
byte |= 0x80;
- fprintf (asm_out_file, "%s0x%x", ASM_BYTE_OP, (unsigned) byte);
- if (flag_debug_asm && value == 0)
- fprintf (asm_out_file, "\t%s ULEB128 number - value = %lu",
- ASM_COMMENT_START, orig_value);
- fputc ('\n', asm_out_file);
+ dw2_asm_output_data (1, byte, "\t%s ULEB128 number - value = %lu",
+ orig_value);
}
while (value != 0);
}
static void
output_signed_leb128 (value)
- register long value;
+ long value;
{
- register long orig_value = value;
- register int negative = (value < 0);
- register int more;
+ long orig_value = value;
+ int negative = (value < 0);
+ int more;
do
{
- register unsigned byte = (value & 0x7f);
+ unsigned byte = (value & 0x7f);
value >>= 7;
if (negative)
byte |= 0x80;
more = 1;
}
- fprintf (asm_out_file, "%s0x%x", ASM_BYTE_OP, (unsigned) byte);
- if (flag_debug_asm && more == 0)
- fprintf (asm_out_file, "\t%s SLEB128 number - value = %ld",
- ASM_COMMENT_START, orig_value);
- fputc ('\n', asm_out_file);
+ dw2_asm_output_data (1, byte, "\t%s SLEB128 number - value = %ld",
+ orig_value);
}
while (more);
}
struct s { my_type f; };
- Since we may be stuck here without enought information to do exactly
+ Since we may be stuck here without enough information to do exactly
what is called for in the Dwarf draft specification, we do the best
that we can under the circumstances and always use the "plain" integral
fundamental type codes for int, short, and long types. That's probably
static int
fundamental_type_code (type)
- register tree type;
+ tree type;
{
if (TREE_CODE (type) == ERROR_MARK)
return 0;
const char *const name =
IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
- /* Note that here we can run afowl of a serious bug in "classic"
+ /* Note that here we can run afoul of a serious bug in "classic"
svr4 SDB debuggers. They don't seem to understand the
FT_ext_prec_float type (even though they should). */
if (TYPE_PRECISION (type) == FLOAT_TYPE_SIZE)
return FT_float;
- /* Note that here we can run afowl of a serious bug in "classic"
+ /* Note that here we can run afoul of a serious bug in "classic"
svr4 SDB debuggers. They don't seem to understand the
FT_ext_prec_float type (even though they should). */
static tree
root_type_1 (type, count)
- register tree type;
- register int count;
+ tree type;
+ int count;
{
/* Give up after searching 1000 levels, in case this is a recursive
pointer type. Such types are possible in Ada, but it is not possible
static tree
root_type (type)
- register tree type;
+ tree type;
{
type = root_type_1 (type, 0);
if (type != error_mark_node)
static void
write_modifier_bytes_1 (type, decl_const, decl_volatile, count)
- register tree type;
- register int decl_const;
- register int decl_volatile;
- register int count;
+ tree type;
+ int decl_const;
+ int decl_volatile;
+ int count;
{
if (TREE_CODE (type) == ERROR_MARK)
return;
static void
write_modifier_bytes (type, decl_const, decl_volatile)
- register tree type;
- register int decl_const;
- register int decl_volatile;
+ tree type;
+ int decl_const;
+ int decl_volatile;
{
write_modifier_bytes_1 (type, decl_const, decl_volatile, 0);
}
static inline int
type_is_fundamental (type)
- register tree type;
+ tree type;
{
switch (TREE_CODE (type))
{
static void
equate_decl_number_to_die_number (decl)
- register tree decl;
+ tree decl;
{
/* In the case where we are generating a DIE for some ..._DECL node
which represents either some inline function declaration or some
static inline void
equate_type_number_to_die_number (type)
- register tree type;
+ tree type;
{
char type_label[MAX_ARTIFICIAL_LABEL_BYTES];
char die_label[MAX_ARTIFICIAL_LABEL_BYTES];
static void
output_reg_number (rtl)
- register rtx rtl;
+ rtx rtl;
{
- register unsigned regno = REGNO (rtl);
+ unsigned regno = REGNO (rtl);
if (regno >= DWARF_FRAME_REGISTERS)
{
regno);
regno = 0;
}
- fprintf (asm_out_file, "%s0x%x",
- UNALIGNED_INT_ASM_OP, DBX_REGISTER_NUMBER (regno));
+ dw2_assemble_integer (4, GEN_INT (DBX_REGISTER_NUMBER (regno)));
if (flag_debug_asm)
{
fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START);
static void
output_mem_loc_descriptor (rtl)
- register rtx rtl;
+ rtx rtl;
{
/* Note that for a dynamically sized array, the location we will
generate a description of here will be the lowest numbered location
static void
output_loc_descriptor (rtl)
- register rtx rtl;
+ rtx rtl;
{
switch (GET_CODE (rtl))
{
static void
output_bound_representation (bound, dim_num, u_or_l)
- register tree bound;
- register unsigned dim_num; /* For multi-dimensional arrays. */
- register char u_or_l; /* Designates upper or lower bound. */
+ tree bound;
+ unsigned dim_num; /* For multi-dimensional arrays. */
+ char u_or_l; /* Designates upper or lower bound. */
{
switch (TREE_CODE (bound))
{
static void
output_enumeral_list (link)
- register tree link;
+ tree link;
{
if (link)
{
static inline HOST_WIDE_INT
ceiling (value, boundary)
- register HOST_WIDE_INT value;
- register unsigned int boundary;
+ HOST_WIDE_INT value;
+ unsigned int boundary;
{
return (((value + boundary - 1) / boundary) * boundary);
}
static inline tree
field_type (decl)
- register tree decl;
+ tree decl;
{
- register tree type;
+ tree type;
if (TREE_CODE (decl) == ERROR_MARK)
return integer_type_node;
static inline unsigned int
simple_type_align_in_bits (type)
- register tree type;
+ tree type;
{
return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
}
static inline unsigned HOST_WIDE_INT
simple_type_size_in_bits (type)
- register tree type;
+ tree type;
{
tree type_size_tree;
static HOST_WIDE_INT
field_byte_offset (decl)
- register tree decl;
+ tree decl;
{
unsigned int type_align_in_bytes;
unsigned int type_align_in_bits;
static void
location_attribute (rtl)
- register rtx rtl;
+ rtx rtl;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static void
data_member_location_attribute (t)
- register tree t;
+ tree t;
{
- register unsigned object_offset_in_bytes;
+ unsigned object_offset_in_bytes;
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static void
const_value_attribute (rtl)
- register rtx rtl;
+ rtx rtl;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static void
location_or_const_value_attribute (decl)
- register tree decl;
+ tree decl;
{
- register rtx rtl;
+ rtx rtl;
if (TREE_CODE (decl) == ERROR_MARK)
return;
if (rtl == NULL_RTX || is_pseudo_reg (rtl))
{
/* This decl represents a formal parameter which was optimized out. */
- register tree declared_type = type_main_variant (TREE_TYPE (decl));
- register tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
+ tree declared_type = type_main_variant (TREE_TYPE (decl));
+ tree passed_type = type_main_variant (DECL_ARG_TYPE (decl));
/* Note that DECL_INCOMING_RTL may be NULL in here, but we handle
*all* cases where (rtl == NULL_RTX) just below. */
static inline void
name_attribute (name_string)
- register const char *name_string;
+ const char *name_string;
{
if (name_string && *name_string)
{
static inline void
fund_type_attribute (ft_code)
- register unsigned ft_code;
+ unsigned ft_code;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_fund_type);
ASM_OUTPUT_DWARF_FUND_TYPE (asm_out_file, ft_code);
static void
mod_fund_type_attribute (type, decl_const, decl_volatile)
- register tree type;
- register int decl_const;
- register int decl_volatile;
+ tree type;
+ int decl_const;
+ int decl_volatile;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static inline void
user_def_type_attribute (type)
- register tree type;
+ tree type;
{
char ud_type_name[MAX_ARTIFICIAL_LABEL_BYTES];
static void
mod_u_d_type_attribute (type, decl_const, decl_volatile)
- register tree type;
- register int decl_const;
- register int decl_volatile;
+ tree type;
+ int decl_const;
+ int decl_volatile;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
#ifdef USE_ORDERING_ATTRIBUTE
static inline void
ordering_attribute (ordering)
- register unsigned ordering;
+ unsigned ordering;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_ordering);
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, ordering);
static void
subscript_data_attribute (type)
- register tree type;
+ tree type;
{
- register unsigned dimension_number;
+ unsigned dimension_number;
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
TREE_CODE (type) == ARRAY_TYPE;
type = TREE_TYPE (type), dimension_number++)
{
- register tree domain = TYPE_DOMAIN (type);
+ tree domain = TYPE_DOMAIN (type);
/* Arrays come in three flavors. Unspecified bounds, fixed
bounds, and (in GNU C only) variable bounds. Handle all
{
/* We have an array type with specified bounds. */
- register tree lower = TYPE_MIN_VALUE (domain);
- register tree upper = TYPE_MAX_VALUE (domain);
+ tree lower = TYPE_MIN_VALUE (domain);
+ tree upper = TYPE_MAX_VALUE (domain);
/* Handle only fundamental types as index types for now. */
if (! type_is_fundamental (domain))
static void
byte_size_attribute (tree_node)
- register tree tree_node;
+ tree tree_node;
{
- register unsigned size;
+ unsigned size;
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_byte_size);
switch (TREE_CODE (tree_node))
static inline void
bit_offset_attribute (decl)
- register tree decl;
+ tree decl;
{
HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
tree type = DECL_BIT_FIELD_TYPE (decl);
static inline void
bit_size_attribute (decl)
- register tree decl;
+ tree decl;
{
/* Must be a field and a bit field. */
if (TREE_CODE (decl) != FIELD_DECL
static inline void
element_list_attribute (element)
- register tree element;
+ tree element;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static inline void
stmt_list_attribute (label)
- register const char *label;
+ const char *label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_stmt_list);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
low_pc_attribute (asm_low_label)
- register const char *asm_low_label;
+ const char *asm_low_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_low_pc);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_low_label);
static inline void
high_pc_attribute (asm_high_label)
- register const char *asm_high_label;
+ const char *asm_high_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_high_pc);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_high_label);
static inline void
body_begin_attribute (asm_begin_label)
- register const char *asm_begin_label;
+ const char *asm_begin_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_begin);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_begin_label);
static inline void
body_end_attribute (asm_end_label)
- register const char *asm_end_label;
+ const char *asm_end_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_body_end);
ASM_OUTPUT_DWARF_ADDR (asm_out_file, asm_end_label);
static inline void
language_attribute (language_code)
- register unsigned language_code;
+ unsigned language_code;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_language);
ASM_OUTPUT_DWARF_DATA4 (asm_out_file, language_code);
static inline void
member_attribute (context)
- register tree context;
+ tree context;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
#if 0
static inline void
string_length_attribute (upper_bound)
- register tree upper_bound;
+ tree upper_bound;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static inline void
comp_dir_attribute (dirname)
- register const char *dirname;
+ const char *dirname;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_comp_dir);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, dirname);
static inline void
sf_names_attribute (sf_names_start_label)
- register const char *sf_names_start_label;
+ const char *sf_names_start_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_sf_names);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
src_info_attribute (src_info_start_label)
- register const char *src_info_start_label;
+ const char *src_info_start_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_info);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
mac_info_attribute (mac_info_start_label)
- register const char *mac_info_start_label;
+ const char *mac_info_start_label;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_mac_info);
/* Don't use ASM_OUTPUT_DWARF_DATA4 here. */
static inline void
prototyped_attribute (func_type)
- register tree func_type;
+ tree func_type;
{
- if ((strcmp (language_string, "GNU C") == 0)
+ if ((strcmp (lang_hooks.name, "GNU C") == 0)
&& (TYPE_ARG_TYPES (func_type) != NULL))
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_prototyped);
static inline void
producer_attribute (producer)
- register const char *producer;
+ const char *producer;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_producer);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, producer);
static inline void
inline_attribute (decl)
- register tree decl;
+ tree decl;
{
if (DECL_INLINE (decl))
{
static inline void
containing_type_attribute (containing_type)
- register tree containing_type;
+ tree containing_type;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
static inline void
abstract_origin_attribute (origin)
- register tree origin;
+ tree origin;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
#ifdef DWARF_DECL_COORDINATES
static inline void
src_coords_attribute (src_fileno, src_lineno)
- register unsigned src_fileno;
- register unsigned src_lineno;
+ unsigned src_fileno;
+ unsigned src_lineno;
{
ASM_OUTPUT_DWARF_ATTRIBUTE (asm_out_file, AT_src_coords);
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, src_fileno);
static inline void
pure_or_virtual_attribute (func_decl)
- register tree func_decl;
+ tree func_decl;
{
if (DECL_VIRTUAL_P (func_decl))
{
static void
name_and_src_coords_attributes (decl)
- register tree decl;
+ tree decl;
{
- register tree decl_name = DECL_NAME (decl);
+ tree decl_name = DECL_NAME (decl);
if (decl_name && IDENTIFIER_POINTER (decl_name))
{
static void
type_attribute (type, decl_const, decl_volatile)
- register tree type;
- register int decl_const;
- register int decl_volatile;
+ tree type;
+ int decl_const;
+ int decl_volatile;
{
- register enum tree_code code = TREE_CODE (type);
- register int root_type_modified;
+ enum tree_code code = TREE_CODE (type);
+ int root_type_modified;
if (code == ERROR_MARK)
return;
static const char *
type_tag (type)
- register tree type;
+ tree type;
{
- register const char *name = 0;
+ const char *name = 0;
if (TYPE_NAME (type) != 0)
{
- register tree t = 0;
+ tree t = 0;
/* Find the IDENTIFIER_NODE for the type name. */
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
static inline tree
member_declared_type (member)
- register tree member;
+ tree member;
{
return (DECL_BIT_FIELD_TYPE (member))
? DECL_BIT_FIELD_TYPE (member)
static const char *
function_start_label (decl)
- register tree decl;
+ tree decl;
{
rtx x;
const char *fnname;
static void
output_array_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_array_type);
sibling_attribute ();
static void
output_set_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_set_type);
sibling_attribute ();
static void
output_entry_point_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_entry_point);
sibling_attribute ();
static void
output_inlined_enumeration_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
sibling_attribute ();
static void
output_inlined_structure_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
sibling_attribute ();
static void
output_inlined_union_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
sibling_attribute ();
static void
output_enumeration_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_enumeration_type);
sibling_attribute ();
static void
output_formal_parameter_die (arg)
- register void *arg;
+ void *arg;
{
- register tree node = arg;
+ tree node = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_formal_parameter);
sibling_attribute ();
static void
output_global_subroutine_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_subroutine);
sibling_attribute ();
abstract_origin_attribute (origin);
else
{
- register tree type = TREE_TYPE (decl);
+ tree type = TREE_TYPE (decl);
name_and_src_coords_attributes (decl);
inline_attribute (decl);
static void
output_global_variable_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_global_variable);
sibling_attribute ();
static void
output_label_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_label);
sibling_attribute ();
equate_decl_number_to_die_number (decl);
else
{
- register rtx insn = DECL_RTL (decl);
+ rtx insn = DECL_RTL (decl);
/* Deleted labels are programmer specified labels which have been
eliminated because of various optimisations. We still emit them
static void
output_lexical_block_die (arg)
- register void *arg;
+ void *arg;
{
- register tree stmt = arg;
+ tree stmt = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_lexical_block);
sibling_attribute ();
static void
output_inlined_subroutine_die (arg)
- register void *arg;
+ void *arg;
{
- register tree stmt = arg;
+ tree stmt = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inlined_subroutine);
sibling_attribute ();
static void
output_local_variable_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_local_variable);
sibling_attribute ();
static void
output_member_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
+ tree decl = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_member);
sibling_attribute ();
static void
output_pointer_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_pointer_type);
sibling_attribute ();
static void
output_reference_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_reference_type);
sibling_attribute ();
static void
output_ptr_to_mbr_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_ptr_to_member_type);
sibling_attribute ();
static void
output_compile_unit_die (arg)
- register void *arg;
+ void *arg;
{
- register const char *main_input_filename = arg;
+ const char *main_input_filename = arg;
+ const char *language_string = lang_hooks.name;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_compile_unit);
sibling_attribute ();
language_attribute (LANG_PASCAL83);
else if (strcmp (language_string, "GNU Java") == 0)
language_attribute (LANG_JAVA);
- else if (flag_traditional)
- language_attribute (LANG_C);
else
language_attribute (LANG_C89);
low_pc_attribute (TEXT_BEGIN_LABEL);
high_pc_attribute (TEXT_END_LABEL);
if (debug_info_level >= DINFO_LEVEL_NORMAL)
stmt_list_attribute (LINE_BEGIN_LABEL);
- last_filename = xstrdup (main_input_filename);
{
const char *wd = getpwd ();
static void
output_string_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_string_type);
sibling_attribute ();
static void
output_inheritance_die (arg)
- register void *arg;
+ void *arg;
{
- register tree binfo = arg;
+ tree binfo = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_inheritance);
sibling_attribute ();
static void
output_structure_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_structure_type);
sibling_attribute ();
static void
output_local_subroutine_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine);
sibling_attribute ();
abstract_origin_attribute (origin);
else
{
- register tree type = TREE_TYPE (decl);
+ tree type = TREE_TYPE (decl);
name_and_src_coords_attributes (decl);
inline_attribute (decl);
static void
output_subroutine_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
- register tree return_type = TREE_TYPE (type);
+ tree type = arg;
+ tree return_type = TREE_TYPE (type);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_subroutine_type);
sibling_attribute ();
static void
output_typedef_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl = arg;
- register tree origin = decl_ultimate_origin (decl);
+ tree decl = arg;
+ tree origin = decl_ultimate_origin (decl);
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_typedef);
sibling_attribute ();
static void
output_union_type_die (arg)
- register void *arg;
+ void *arg;
{
- register tree type = arg;
+ tree type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_union_type);
sibling_attribute ();
static void
output_unspecified_parameters_die (arg)
- register void *arg;
+ void *arg;
{
- register tree decl_or_type = arg;
+ tree decl_or_type = arg;
ASM_OUTPUT_DWARF_TAG (asm_out_file, TAG_unspecified_parameters);
sibling_attribute ();
static void
output_padded_null_die (arg)
- register void *arg ATTRIBUTE_UNUSED;
+ void *arg ATTRIBUTE_UNUSED;
{
ASM_OUTPUT_ALIGN (asm_out_file, 2); /* 2**2 == 4 */
}
static void
output_die (die_specific_output_function, param)
- register void (*die_specific_output_function) PARAMS ((void *));
- register void *param;
+ void (*die_specific_output_function) PARAMS ((void *));
+ void *param;
{
char begin_label[MAX_ARTIFICIAL_LABEL_BYTES];
char end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static void
output_formal_types (function_or_method_type)
- register tree function_or_method_type;
+ tree function_or_method_type;
{
- register tree link;
- register tree formal_type = NULL;
- register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
+ tree link;
+ tree formal_type = NULL;
+ tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
/* Set TREE_ASM_WRITTEN while processing the parameters, lest we
get bogus recursion when outputting tagged types local to a
static void
pend_type (type)
- register tree type;
+ tree type;
{
if (pending_types == pending_types_allocated)
{
static inline int
type_ok_for_scope (type, scope)
- register tree type;
- register tree scope;
+ tree type;
+ tree scope;
{
/* Tagged types (i.e. struct, union, and enum types) must always be
output only in the scopes where they actually belong (or else the
static void
output_pending_types_for_scope (containing_scope)
- register tree containing_scope;
+ tree containing_scope;
{
- register unsigned i;
+ unsigned i;
for (i = 0; i < pending_types; )
{
- register tree type = pending_types_list[i];
+ tree type = pending_types_list[i];
if (type_ok_for_scope (type, containing_scope))
{
- register tree *mover;
- register tree *limit;
+ tree *mover;
+ tree *limit;
pending_types--;
limit = &pending_types_list[pending_types];
static void
retry_incomplete_types ()
{
- register tree type;
+ tree type;
finalizing = 1;
while (incomplete_types)
static void
output_type (type, containing_scope)
- register tree type;
- register tree containing_scope;
+ tree type;
+ tree containing_scope;
{
if (type == 0 || type == error_mark_node)
return;
{
if (finalizing && AGGREGATE_TYPE_P (type))
{
- register tree member;
+ tree member;
/* Some of our nested types might not have been defined when we
were written out before; force them out now. */
}
else
{
- register tree element_type;
+ tree element_type;
element_type = TREE_TYPE (type);
while (TREE_CODE (element_type) == ARRAY_TYPE)
to output DIEs to represent the *types* of those members.
However the `output_type' function (above) will specifically
avoid generating type DIEs for member types *within* the list
- of member DIEs for this (containing) type execpt for those
+ of member DIEs for this (containing) type except for those
types (of members) which are explicitly marked as also being
members of this (containing) type themselves. The g++ front-
end can force any given type to be treated as a member of some
++in_class;
{
- register tree normal_member;
+ tree normal_member;
/* Now output info about the data members and type members. */
}
{
- register tree func_member;
+ tree func_member;
/* Now output info about the function members (if any). */
static void
output_tagged_type_instantiation (type)
- register tree type;
+ tree type;
{
if (type == 0 || type == error_mark_node)
return;
static void
output_block (stmt, depth)
- register tree stmt;
+ tree stmt;
int depth;
{
- register int must_output_die = 0;
- register tree origin;
- register enum tree_code origin_code;
+ int must_output_die = 0;
+ tree origin;
+ enum tree_code origin_code;
/* Ignore blocks never really used to make RTL. */
must_output_die = (BLOCK_VARS (stmt) != NULL);
else
{
- register tree decl;
+ tree decl;
/* We are in terse mode, so only local (nested) function
definitions count as "significant" local declarations. */
static void
output_decls_for_scope (stmt, depth)
- register tree stmt;
+ tree stmt;
int depth;
{
/* Ignore blocks never really used to make RTL. */
but not within any nested sub-blocks. */
{
- register tree decl;
+ tree decl;
for (decl = BLOCK_VARS (stmt); decl; decl = TREE_CHAIN (decl))
output_decl (decl, stmt);
therein) of this block. */
{
- register tree subblocks;
+ tree subblocks;
for (subblocks = BLOCK_SUBBLOCKS (stmt);
subblocks;
static inline int
is_redundant_typedef (decl)
- register tree decl;
+ tree decl;
{
if (TYPE_DECL_IS_STUB (decl))
return 1;
static void
output_decl (decl, containing_scope)
- register tree decl;
- register tree containing_scope;
+ tree decl;
+ tree containing_scope;
{
/* Make a note of the decl node we are going to be working on. We may
need to give the user the source coordinates of where it appeared in
{
/* Generate DIEs to represent all known formal parameters */
- register tree arg_decls = DECL_ARGUMENTS (decl);
- register tree parm;
+ tree arg_decls = DECL_ARGUMENTS (decl);
+ tree parm;
/* WARNING! Kludge zone ahead! Here we have a special
hack for svr4 SDB compatibility. Instead of passing the
*/
{
- register tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
+ tree fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
if (fn_arg_types)
{
function (if it has one - it may be just a declaration). */
{
- register tree outer_scope = DECL_INITIAL (decl);
+ tree outer_scope = DECL_INITIAL (decl);
if (outer_scope && TREE_CODE (outer_scope) != ERROR_MARK)
{
function. */
{
- register void (*func) PARAMS ((void *));
+ void (*func) PARAMS ((void *));
register tree origin = decl_ultimate_origin (decl);
if (origin != NULL && TREE_CODE (origin) == PARM_DECL)
case PARM_DECL:
/* Force out the type of this formal, if it was not forced out yet.
- Note that here we can run afowl of a bug in "classic" svr4 SDB.
+ Note that here we can run afoul of a bug in "classic" svr4 SDB.
It should be able to grok the presence of type DIEs within a list
of TAG_formal_parameter DIEs, but it doesn't. */
static void
dwarfout_file_scope_decl (decl, set_finalizing)
- register tree decl;
- register int set_finalizing;
+ tree decl;
+ int set_finalizing;
{
if (TREE_CODE (decl) == ERROR_MARK)
return;
future (i.e. later on within the current translation unit).
So here we just ignore all file-scope function declarations
which are not also definitions. If and when the debugger needs
- to know something about these functions, it wil have to hunt
+ to know something about these functions, it will have to hunt
around and find the DWARF information associated with the
*definition* of the function.
static void
shuffle_filename_entry (new_zeroth)
- register filename_entry *new_zeroth;
+ filename_entry *new_zeroth;
{
filename_entry temp_entry;
- register filename_entry *limit_p;
- register filename_entry *move_p;
+ filename_entry *limit_p;
+ filename_entry *move_p;
if (new_zeroth == &filename_table[0])
return;
lookup_filename (file_name)
const char *file_name;
{
- register filename_entry *search_p;
- register filename_entry *limit_p = &filename_table[ft_entries];
+ filename_entry *search_p;
+ filename_entry *limit_p = &filename_table[ft_entries];
for (search_p = filename_table; search_p < limit_p; search_p++)
if (!strcmp (file_name, search_p->name))
char label[MAX_ARTIFICIAL_LABEL_BYTES];
static unsigned last_line_entry_num = 0;
static unsigned prev_file_entry_num = (unsigned) -1;
- register unsigned this_file_entry_num;
+ unsigned this_file_entry_num;
function_section (current_function_decl);
sprintf (label, LINE_CODE_LABEL_FMT, ++last_line_entry_num);
}
{
- register const char *tail = strrchr (filename, '/');
+ const char *tail = strrchr (filename, '/');
if (tail != NULL)
filename = tail;
}
- fprintf (asm_out_file, "%s%u\t%s %s:%u\n",
- UNALIGNED_INT_ASM_OP, line, ASM_COMMENT_START,
- filename, line);
+ dw2_asm_output_data (4, line, "%s:%u", filename, line);
ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0xffff);
ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, label, TEXT_BEGIN_LABEL);
ASM_OUTPUT_POP_SECTION (asm_out_file);
/* Generate an entry in the .debug_macinfo section. */
static void
-generate_macinfo_entry (type_and_offset, string)
- register const char *type_and_offset;
- register const char *string;
+generate_macinfo_entry (type, offset, string)
+ unsigned int type;
+ rtx offset;
+ const char *string;
{
if (! use_gnu_debug_info_extensions)
return;
fputc ('\n', asm_out_file);
ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_MACINFO_SECTION);
- fprintf (asm_out_file, "%s%s\n", UNALIGNED_INT_ASM_OP, type_and_offset);
+ assemble_integer (gen_rtx_PLUS (SImode, GEN_INT (type << 24), offset),
+ 4, BITS_PER_UNIT, 1);
ASM_OUTPUT_DWARF_STRING_NEWLINE (asm_out_file, string);
ASM_OUTPUT_POP_SECTION (asm_out_file);
}
static void
dwarfout_start_source_file_check (line, filename)
unsigned int line;
- register const char *filename;
+ const char *filename;
{
if (debug_info_level == DINFO_LEVEL_VERBOSE)
dwarfout_start_source_file (line, filename);
static void
dwarfout_start_source_file (line, filename)
unsigned int line ATTRIBUTE_UNUSED;
- register const char *filename;
+ const char *filename;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
- char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*3];
+ const char *label1, *label2;
sprintf (label, SFNAMES_ENTRY_LABEL_FMT, lookup_filename (filename));
- sprintf (type_and_offset, "0x%08x+%s-%s",
- ((unsigned) MACINFO_start << 24),
- /* Hack: skip leading '*' . */
- (*label == '*') + label,
- (*SFNAMES_BEGIN_LABEL == '*') + SFNAMES_BEGIN_LABEL);
- generate_macinfo_entry (type_and_offset, "");
+ label1 = (*label == '*') + label;
+ label2 = (*SFNAMES_BEGIN_LABEL == '*') + SFNAMES_BEGIN_LABEL;
+ generate_macinfo_entry (MACINFO_start,
+ gen_rtx_MINUS (Pmode,
+ gen_rtx_SYMBOL_REF (Pmode, label1),
+ gen_rtx_SYMBOL_REF (Pmode, label2)),
+ "");
}
/* Wrapper for toplev.c callback to check debug info level. */
static void
dwarfout_end_source_file_check (lineno)
- register unsigned lineno;
+ unsigned lineno;
{
if (debug_info_level == DINFO_LEVEL_VERBOSE)
dwarfout_end_source_file (lineno);
static void
dwarfout_end_source_file (lineno)
- register unsigned lineno;
+ unsigned lineno;
{
- char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
-
- sprintf (type_and_offset, "0x%08x+%u",
- ((unsigned) MACINFO_resume << 24), lineno);
- generate_macinfo_entry (type_and_offset, "");
+ generate_macinfo_entry (MACINFO_resume, GEN_INT (lineno), "");
}
/* Called from check_newline in c-parse.y. The `buffer' parameter
static void
dwarfout_define (lineno, buffer)
- register unsigned lineno;
- register const char *buffer;
+ unsigned lineno;
+ const char *buffer;
{
static int initialized = 0;
- char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
if (!initialized)
{
dwarfout_start_source_file (0, primary_filename);
initialized = 1;
}
- sprintf (type_and_offset, "0x%08x+%u",
- ((unsigned) MACINFO_define << 24), lineno);
- generate_macinfo_entry (type_and_offset, buffer);
+ generate_macinfo_entry (MACINFO_define, GEN_INT (lineno), buffer);
}
/* Called from check_newline in c-parse.y. The `buffer' parameter
static void
dwarfout_undef (lineno, buffer)
- register unsigned lineno;
- register const char *buffer;
+ unsigned lineno;
+ const char *buffer;
{
- char type_and_offset[MAX_ARTIFICIAL_LABEL_BYTES*2];
-
- sprintf (type_and_offset, "0x%08x+%u",
- ((unsigned) MACINFO_undef << 24), lineno);
- generate_macinfo_entry (type_and_offset, buffer);
+ generate_macinfo_entry (MACINFO_undef, GEN_INT (lineno), buffer);
}
/* Set up for Dwarf output at the start of compilation. */
static void
dwarfout_init (main_input_filename)
- register const char *main_input_filename;
+ const char *main_input_filename;
{
/* Remember the name of the primary input file. */
ASM_OUTPUT_PUSH_SECTION (asm_out_file, DEBUG_SFNAMES_SECTION);
ASM_OUTPUT_LABEL (asm_out_file, SFNAMES_BEGIN_LABEL);
{
- register const char *pwd = getpwd ();
- register char *dirname;
+ const char *pwd = getpwd ();
+ char *dirname;
if (!pwd)
fatal_io_error ("can't get current directory");
static void
dwarfout_finish (main_input_filename)
- register const char *main_input_filename ATTRIBUTE_UNUSED;
+ const char *main_input_filename ATTRIBUTE_UNUSED;
{
char label[MAX_ARTIFICIAL_LABEL_BYTES];
OSDN Git Service
