From 2e4b9b8cc2e588371da3c00b58714b93b67796c9 Mon Sep 17 00:00:00 2001 From: Richard Henderson Date: Fri, 2 Mar 2001 18:17:07 -0800 Subject: [PATCH] Makefile.in (OBJS): Add dwarf2asm.o. * Makefile.in (OBJS): Add dwarf2asm.o. * dwarf2asm.c, dwarf2asm.h: New files. * dwarf2out.c (*): Use them. (size_of_uleb128, size_of_sleb128): Remove. (output_uleb128, output_sleb128): Remove. (UNALIGNED_SHORT_ASM_OP, UNALIGNED_INT_ASM_OP): Remove. (UNALIGNED_DOUBLE_INT_ASM_OP, ASM_BYTE_OP): Remove. (UNALIGNED_OFFSET_ASM_OP, UNALIGNED_WORD_ASM_OP): Remove. (FDE_LABEL, LINE_NUMBER_BEGIN_LABEL, LINE_NUMBER_END_LABEL): New. (ASM_OUTPUT_DWARF_DATA1, ASM_OUTPUT_DWARF_DELTA1): Remove. (ASM_OUTPUT_DWARF_DATA2, ASM_OUTPUT_DWARF_DELTA2): Remove. (ASM_OUTPUT_DWARF_DATA4, ASM_OUTPUT_DWARF_DELTA4): Remove. (ASM_OUTPUT_DWARF_DATA, ASM_OUTPUT_DWARF_DELTA): Remove. (ASM_OUTPUT_DWARF_ADDR, ASM_OUTPUT_DWARF_ADDR_DATA): Remove. (ASM_OUTPUT_DWARF_ADDR_DELTA, ASM_OUTPUT_DWARF_ADDR_CONST): Remove. (ASM_OUTPUT_DWARF_OFFSET4, ASM_OUTPUT_DWARF_OFFSET): Remove. (ASM_OUTPUT_DWARF_CONST_DOUBLE): Remove. (ASM_OUTPUT_DWARF_NSTRING, ASM_OUTPUT_DWARF_STRING): Remove. (dwarf2out_frame_debug): Remove unused variables. (output_loc_operands): Don't abort on 8 byte constants if host integers are wide enough. (output_symbolic_ref): Remove. (size_of_die): Don't assume 4 byte host integers. (output_line_info): Use ASM_GENERATE_INTERNAL_LABEL for begin and end labels. (add_const_value_attribute) [CONST_INT]: Verify we're not doing something stupid with HOST_WIDE_INT to long truncation. [CONST_DOUBLE]: Likewise. * config/arm/conix-elf.h (UNALIGNED_WORD_ASM_OP): Remove. (ASM_OUTPUT_DWARF2_ADDR_CONST, ASM_OUTPUT_DWARF_ADDR_CONST): Remove. * config/arm/unknown-elf.h: Likewise. * config/rs6000/aix.h (UNALIGNED_SHORT_ASM_OP): New. (UNALIGNED_INT_ASM_OP, UNALIGNED_DOUBLE_INT_ASM_OP): New. (ASM_OUTPUT_DWARF_ADDR_VAR, ASM_OUTPUT_DWARF_DELTA_VAR): Remove. (ASM_OUTPUT_DWARF_DELTA2, ASM_OUTPUT_DWARF_DELTA4): Remove. (ASM_OUTPUT_DWARF_DELTA, ASM_OUTPUT_DWARF_ADDR_DELTA): Remove. (ASM_OUTPUT_DWARF_ADDR, ASM_OUTPUT_DWARF_DATA4): Remove. (ASM_OUTPUT_DWARF_DATA2, ASM_OUTPUT_DWARF_OFFSET4): Remove. (ASM_OUTPUT_DWARF_OFFSET): Remove. * config/rs6000/sysv4.h (ASM_OUTPUT_DWARF_ADDR): Remove. * config/sparc/sp64-elf.h (UNALIGNED_DOUBLE_INT_ASM_OP): New. (UNALIGNED_LONGLONG_ASM_OP, ASM_OUTPUT_DWARF_ADDR): Remove. (ASM_OUTPUT_DWARF_ADDR_CONST, ASM_OUTPUT_DWARF_REF): Remove. From-SVN: r40197 --- gcc/ChangeLog | 47 ++ gcc/Makefile.in | 33 +- gcc/config/arm/conix-elf.h | 17 - gcc/config/arm/unknown-elf.h | 17 - gcc/config/rs6000/aix.h | 45 +- gcc/config/rs6000/sysv4.h | 30 - gcc/config/sparc/sp64-elf.h | 33 +- gcc/dwarf2asm.c | 585 +++++++++++++++++ gcc/dwarf2asm.h | 68 ++ gcc/dwarf2out.c | 1478 ++++++++++-------------------------------- 10 files changed, 1061 insertions(+), 1292 deletions(-) create mode 100644 gcc/dwarf2asm.c create mode 100644 gcc/dwarf2asm.h diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c71cd60..47f2d24 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,50 @@ +2001-03-02 Richard Henderson + + * Makefile.in (OBJS): Add dwarf2asm.o. + * dwarf2asm.c, dwarf2asm.h: New files. + * dwarf2out.c (*): Use them. + (size_of_uleb128, size_of_sleb128): Remove. + (output_uleb128, output_sleb128): Remove. + (UNALIGNED_SHORT_ASM_OP, UNALIGNED_INT_ASM_OP): Remove. + (UNALIGNED_DOUBLE_INT_ASM_OP, ASM_BYTE_OP): Remove. + (UNALIGNED_OFFSET_ASM_OP, UNALIGNED_WORD_ASM_OP): Remove. + (FDE_LABEL, LINE_NUMBER_BEGIN_LABEL, LINE_NUMBER_END_LABEL): New. + (ASM_OUTPUT_DWARF_DATA1, ASM_OUTPUT_DWARF_DELTA1): Remove. + (ASM_OUTPUT_DWARF_DATA2, ASM_OUTPUT_DWARF_DELTA2): Remove. + (ASM_OUTPUT_DWARF_DATA4, ASM_OUTPUT_DWARF_DELTA4): Remove. + (ASM_OUTPUT_DWARF_DATA, ASM_OUTPUT_DWARF_DELTA): Remove. + (ASM_OUTPUT_DWARF_ADDR, ASM_OUTPUT_DWARF_ADDR_DATA): Remove. + (ASM_OUTPUT_DWARF_ADDR_DELTA, ASM_OUTPUT_DWARF_ADDR_CONST): Remove. + (ASM_OUTPUT_DWARF_OFFSET4, ASM_OUTPUT_DWARF_OFFSET): Remove. + (ASM_OUTPUT_DWARF_CONST_DOUBLE): Remove. + (ASM_OUTPUT_DWARF_NSTRING, ASM_OUTPUT_DWARF_STRING): Remove. + (dwarf2out_frame_debug): Remove unused variables. + (output_loc_operands): Don't abort on 8 byte constants if + host integers are wide enough. + (output_symbolic_ref): Remove. + (size_of_die): Don't assume 4 byte host integers. + (output_line_info): Use ASM_GENERATE_INTERNAL_LABEL for begin + and end labels. + (add_const_value_attribute) [CONST_INT]: Verify we're not doing + something stupid with HOST_WIDE_INT to long truncation. + [CONST_DOUBLE]: Likewise. + + * config/arm/conix-elf.h (UNALIGNED_WORD_ASM_OP): Remove. + (ASM_OUTPUT_DWARF2_ADDR_CONST, ASM_OUTPUT_DWARF_ADDR_CONST): Remove. + * config/arm/unknown-elf.h: Likewise. + * config/rs6000/aix.h (UNALIGNED_SHORT_ASM_OP): New. + (UNALIGNED_INT_ASM_OP, UNALIGNED_DOUBLE_INT_ASM_OP): New. + (ASM_OUTPUT_DWARF_ADDR_VAR, ASM_OUTPUT_DWARF_DELTA_VAR): Remove. + (ASM_OUTPUT_DWARF_DELTA2, ASM_OUTPUT_DWARF_DELTA4): Remove. + (ASM_OUTPUT_DWARF_DELTA, ASM_OUTPUT_DWARF_ADDR_DELTA): Remove. + (ASM_OUTPUT_DWARF_ADDR, ASM_OUTPUT_DWARF_DATA4): Remove. + (ASM_OUTPUT_DWARF_DATA2, ASM_OUTPUT_DWARF_OFFSET4): Remove. + (ASM_OUTPUT_DWARF_OFFSET): Remove. + * config/rs6000/sysv4.h (ASM_OUTPUT_DWARF_ADDR): Remove. + * config/sparc/sp64-elf.h (UNALIGNED_DOUBLE_INT_ASM_OP): New. + (UNALIGNED_LONGLONG_ASM_OP, ASM_OUTPUT_DWARF_ADDR): Remove. + (ASM_OUTPUT_DWARF_ADDR_CONST, ASM_OUTPUT_DWARF_REF): Remove. + 2001-03-02 John David Anglin * cselib.c (hash_rtx): Cast enums to unsigned int. diff --git a/gcc/Makefile.in b/gcc/Makefile.in index bc6067e..9f3bb52 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -733,19 +733,22 @@ C_OBJS = c-parse.o c-lang.o $(C_AND_OBJC_OBJS) # Language-independent object files. -OBJS = diagnostic.o version.o tree.o print-tree.o stor-layout.o fold-const.o \ - function.o stmt.o except.o expr.o calls.o expmed.o explow.o optabs.o real.o \ - builtins.o intl.o varasm.o rtl.o print-rtl.o rtlanal.o emit-rtl.o genrtl.o \ - dbxout.o sdbout.o dwarfout.o dwarf2out.o xcoffout.o bitmap.o alias.o gcse.o \ - integrate.o jump.o cse.o loop.o doloop.o unroll.o flow.o combine.o varray.o \ - regclass.o regmove.o local-alloc.o global.o reload.o reload1.o caller-save.o\ - insn-peep.o reorg.o haifa-sched.o final.o recog.o reg-stack.o regrename.o \ - insn-opinit.o insn-recog.o insn-extract.o insn-output.o insn-emit.o lcm.o \ - profile.o insn-attrtab.o $(out_object_file) $(EXTRA_OBJS) convert.o \ - mbchar.o splay-tree.o graph.o sbitmap.o resource.o hash.o predict.o \ - lists.o ggc-common.o $(GGC) stringpool.o simplify-rtx.o ssa.o bb-reorder.o \ - sibcall.o conflict.o timevar.o ifcvt.o dominance.o dependence.o dce.o \ - sched-vis.o sched-deps.o sched-rgn.o sched-ebb.o hashtab.o cselib.o params.o +OBJS = \ + alias.o bb-reorder.o bitmap.o builtins.o caller-save.o calls.o \ + combine.o conflict.o convert.o cse.o cselib.o dbxout.o dce.o \ + dependence.o diagnostic.o doloop.o dominance.o dwarf2asm.o dwarf2out.o \ + dwarfout.o emit-rtl.o except.o explow.o expmed.o expr.o final.o flow.o \ + fold-const.o function.o gcse.o genrtl.o ggc-common.o global.o graph.o \ + haifa-sched.o hash.o hashtab.o ifcvt.o insn-attrtab.o insn-emit.o \ + insn-extract.o insn-opinit.o insn-output.o insn-peep.o insn-recog.o \ + integrate.o intl.o jump.o lcm.o lists.o local-alloc.o loop.o mbchar.o \ + optabs.o params.o predict.o print-rtl.o print-tree.o profile.o real.o \ + recog.o reg-stack.o regclass.o regmove.o regrename.o reload.o \ + reload1.o reorg.o resource.o rtl.o rtlanal.o sbitmap.o sched-deps.o \ + sched-ebb.o sched-rgn.o sched-vis.o sdbout.o sibcall.o simplify-rtx.o \ + splay-tree.o ssa.o stmt.o stor-layout.o stringpool.o timevar.o tree.o \ + unroll.o varasm.o varray.o version.o xcoffout.o \ + $(GGC) $(out_object_file) $(EXTRA_OBJS) BACKEND = toplev.o libbackend.a @@ -1397,7 +1400,9 @@ dwarfout.o : dwarfout.c $(CONFIG_H) system.h $(TREE_H) $(RTL_H) dwarf.h \ dwarf2out.o : dwarf2out.c $(CONFIG_H) system.h $(TREE_H) $(RTL_H) dwarf2.h \ flags.h insn-config.h reload.h output.h \ hard-reg-set.h $(REGS_H) $(EXPR_H) toplev.h dwarf2out.h varray.h \ - $(GGC_H) except.h + $(GGC_H) except.h dwarf2asm.h +dwarf2asm.o : dwarf2asm.c $(CONFIG_H) system.h flags.h $(RTL_H) output.h \ + dwarf2asm.h xcoffout.o : xcoffout.c $(CONFIG_H) system.h $(TREE_H) $(RTL_H) xcoffout.h \ flags.h toplev.h output.h dbxout.h $(GGC_H) emit-rtl.o : emit-rtl.c $(CONFIG_H) system.h $(RTL_H) $(TREE_H) flags.h \ diff --git a/gcc/config/arm/conix-elf.h b/gcc/config/arm/conix-elf.h index 2d447a5..a626af8 100644 --- a/gcc/config/arm/conix-elf.h +++ b/gcc/config/arm/conix-elf.h @@ -99,23 +99,6 @@ func_ptr __DTOR_END__[1] = { (func_ptr) 0 }; } \ while (0) -/* Don't know how to order these. UNALIGNED_WORD_ASM_OP is in - dwarf2.out. */ -#define UNALIGNED_WORD_ASM_OP "\t.4byte\t" - -#define ASM_OUTPUT_DWARF2_ADDR_CONST(FILE,ADDR) \ - fprintf ((FILE), "%s%s", UNALIGNED_WORD_ASM_OP, ADDR) - -#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \ - do \ - { \ - fprintf ((FILE), "%s", UNALIGNED_WORD_ASM_OP); \ - output_addr_const ((FILE), (RTX)); \ - fputc ('\n', (FILE)); \ - } \ - while (0) - - /* The ARM development system defines __main. */ #define NAME__MAIN "__gccmain" #define SYMBOL__MAIN __gccmain diff --git a/gcc/config/arm/unknown-elf.h b/gcc/config/arm/unknown-elf.h index 315baff..fab8155f 100644 --- a/gcc/config/arm/unknown-elf.h +++ b/gcc/config/arm/unknown-elf.h @@ -103,23 +103,6 @@ rdata_section () \ } \ while (0) -/* Don't know how to order these. UNALIGNED_WORD_ASM_OP is in - dwarf2.out. */ -#define UNALIGNED_WORD_ASM_OP "\t.4byte\t" - -#define ASM_OUTPUT_DWARF2_ADDR_CONST(FILE,ADDR) \ - fprintf ((FILE), "%s%s", UNALIGNED_WORD_ASM_OP, ADDR) - -#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \ - do \ - { \ - fprintf ((FILE), "%s", UNALIGNED_WORD_ASM_OP); \ - output_addr_const ((FILE), (RTX)); \ - fputc ('\n', (FILE)); \ - } \ - while (0) - - /* The ARM development system defines __main. */ #define NAME__MAIN "__gccmain" #define SYMBOL__MAIN __gccmain diff --git a/gcc/config/rs6000/aix.h b/gcc/config/rs6000/aix.h index a28fe1b..cb5db35 100644 --- a/gcc/config/rs6000/aix.h +++ b/gcc/config/rs6000/aix.h @@ -561,48 +561,9 @@ toc_section () \ use '.long' or '.word', but that aligns to a 4-byte boundary which is not what is required. So we define a million macros... */ -#define ASM_OUTPUT_DWARF_ADDR_VAR(FILE, LABEL, LENGTH) \ - do { fprintf ((FILE), "\t.vbyte\t%d,", LENGTH); \ - assemble_name (FILE, LABEL); \ - } while (0) - -#define ASM_OUTPUT_DWARF_DELTA_VAR(FILE, LABEL1, LABEL2, LENGTH) \ - do { fprintf ((FILE), "\t.vbyte\t%d,", LENGTH); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) - -#define ASM_OUTPUT_DWARF_DELTA2(FILE, LABEL1, LABEL2) \ - ASM_OUTPUT_DWARF_DELTA_VAR (FILE, LABEL1, LABEL2, 2) - -#define ASM_OUTPUT_DWARF_DELTA4(FILE, LABEL1, LABEL2) \ - ASM_OUTPUT_DWARF_DELTA_VAR (FILE, LABEL1, LABEL2, 4) - -#define ASM_OUTPUT_DWARF_DELTA(FILE, LABEL1, LABEL2) \ - ASM_OUTPUT_DWARF_DELTA_VAR (FILE, LABEL1, LABEL2, DWARF_OFFSET_SIZE) - -#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE, LABEL1, LABEL2) \ - ASM_OUTPUT_DWARF_DELTA_VAR (FILE, LABEL1, LABEL2, \ - POINTER_SIZE / BITS_PER_UNIT) - -#define ASM_OUTPUT_DWARF_ADDR(FILE, LABEL) \ - ASM_OUTPUT_DWARF_ADDR_VAR (FILE, LABEL, POINTER_SIZE / BITS_PER_UNIT) - -#define ASM_OUTPUT_DWARF_DATA4(FILE, VALUE) \ - fprintf ((FILE), "\t.vbyte\t4,0x%x", (unsigned) (VALUE)) - -#define ASM_OUTPUT_DWARF_DATA2(FILE, VALUE) \ - fprintf ((FILE), "\t.vbyte\t2,0x%x", (unsigned) (VALUE)) - -#define ASM_OUTPUT_DWARF_OFFSET4(FILE, LABEL) \ - ASM_OUTPUT_DWARF_ADDR_VAR (FILE, LABEL, 4) - -#define ASM_OUTPUT_DWARF_OFFSET(FILE, LABEL) \ - ASM_OUTPUT_DWARF_ADDR_VAR (FILE, LABEL, DWARF_OFFSET_SIZE) - -/* dwarf2out keys off this, but we don't have to have a real definition. */ -#define UNALIGNED_INT_ASM_OP bite_me +#define UNALIGNED_SHORT_ASM_OP "\t.vbyte\t2," +#define UNALIGNED_INT_ASM_OP "\t.vbyte\t4," +#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.vbyte\t8," /* Output before instructions. */ #define TEXT_SECTION_ASM_OP "\t.csect .text[PR]" diff --git a/gcc/config/rs6000/sysv4.h b/gcc/config/rs6000/sysv4.h index 5f1f950..6cf6379 100644 --- a/gcc/config/rs6000/sysv4.h +++ b/gcc/config/rs6000/sysv4.h @@ -871,36 +871,6 @@ do { \ } \ } while (0) -/* This is how to output an assembler line defining an address - constant for the dwarf call unwinding information. - For -mrelocatable, we mark all addresses that need to be fixed up - in the .fixup section. */ - -#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ -do { \ - if (TARGET_RELOCATABLE) \ - { \ - char buf[256]; \ - \ - ASM_GENERATE_INTERNAL_LABEL (buf, "LCP", fixuplabelno); \ - fixuplabelno++; \ - ASM_OUTPUT_LABEL (FILE, buf); \ - fprintf (FILE, "\t.%dbyte\t", POINTER_SIZE / BITS_PER_UNIT); \ - assemble_name (FILE, LABEL); \ - fprintf (FILE, "\n"); \ - fprintf (FILE, "\t.section \".fixup\",\"aw\"\n"); \ - ASM_OUTPUT_ALIGN (FILE, 2); \ - fprintf (FILE, "\t.long\t"); \ - assemble_name (FILE, buf); \ - fprintf (FILE, "\n\t.previous\n"); \ - } \ - else \ - { \ - fprintf (FILE, "\t.%dbyte\t", POINTER_SIZE / BITS_PER_UNIT); \ - assemble_name (FILE, LABEL); \ - } \ -} while (0) - /* This is the end of what might become sysv4.h. */ /* Allow stabs and dwarf, for now, make stabs the default debugging type, diff --git a/gcc/config/sparc/sp64-elf.h b/gcc/config/sparc/sp64-elf.h index b314899..1a7623b 100644 --- a/gcc/config/sparc/sp64-elf.h +++ b/gcc/config/sparc/sp64-elf.h @@ -124,33 +124,6 @@ crtbegin.o%s \ #undef ASM_IDENTIFY_GCC #define ASM_IDENTIFY_GCC(FILE) -/* Define the names of various pseudo-ops used by the Sparc/svr4 assembler. - ??? If ints are 64 bits then UNALIGNED_INT_ASM_OP (defined elsewhere) is - misnamed. These should all refer to explicit sizes (half/word/xword?), - anything other than short/int/long/etc. */ - -#define UNALIGNED_LONGLONG_ASM_OP "\t.uaxword\t" - -/* DWARF stuff. */ - -#define ASM_OUTPUT_DWARF_ADDR(FILE, LABEL) \ -do { \ - fprintf ((FILE), "%s", UNALIGNED_LONGLONG_ASM_OP); \ - assemble_name ((FILE), (LABEL)); \ - fprintf ((FILE), "\n"); \ -} while (0) - -#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE, RTX) \ -do { \ - fprintf ((FILE), "%s", UNALIGNED_LONGLONG_ASM_OP); \ - output_addr_const ((FILE), (RTX)); \ - fputc ('\n', (FILE)); \ -} while (0) - -/* ??? Not sure if this should be 4 or 8 bytes. 4 works for now. */ -#define ASM_OUTPUT_DWARF_REF(FILE, LABEL) \ -do { \ - fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \ - assemble_name ((FILE), (LABEL)); \ - fprintf ((FILE), "\n"); \ -} while (0) +/* Define the names of various pseudo-ops used by the Sparc/svr4 assembler. */ + +#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.uaxword\t" diff --git a/gcc/dwarf2asm.c b/gcc/dwarf2asm.c new file mode 100644 index 0000000..132d83c --- /dev/null +++ b/gcc/dwarf2asm.c @@ -0,0 +1,585 @@ +/* Dwarf2 assembler output helper routines. + Copyright (C) 2001 Free Software Foundation, Inc. + +This file is part of GNU CC. + +GNU CC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU CC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU CC; see the file COPYING. If not, write to +the Free Software Foundation, 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + + +#include "config.h" +#include "system.h" +#include "flags.h" +#include "rtl.h" +#include "output.h" +#include "dwarf2asm.h" +#include "tm_p.h" + + +/* How to start an assembler comment. */ +#ifndef ASM_COMMENT_START +#define ASM_COMMENT_START ";#" +#endif + +/* Definitions of defaults for assembler-dependent names of various + pseudo-ops and section names. These may be overridden in the tm.h + file (if necessary) for a particular assembler. */ + +#ifdef OBJECT_FORMAT_ELF +#ifndef UNALIGNED_SHORT_ASM_OP +#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t" +#endif +#ifndef UNALIGNED_INT_ASM_OP +#define UNALIGNED_INT_ASM_OP "\t.4byte\t" +#endif +#ifndef UNALIGNED_DOUBLE_INT_ASM_OP +#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t" +#endif +#endif /* OBJECT_FORMAT_ELF */ + +#ifndef ASM_BYTE_OP +#define ASM_BYTE_OP "\t.byte\t" +#endif + +/* We don't have unaligned support, let's hope the normal output works for + .debug_frame. But we know it won't work for .debug_info. */ +#if !defined(UNALIGNED_INT_ASM_OP) && defined(DWARF2_DEBUGGING_INFO) + #error DWARF2_DEBUGGING_INFO requires UNALIGNED_INT_ASM_OP. +#endif + + +#ifdef UNALIGNED_INT_ASM_OP +static const char * unaligned_integer_asm_op PARAMS ((int)); + +static inline const char * +unaligned_integer_asm_op (size) + int size; +{ + const char *op; + switch (size) + { + case 1: + op = ASM_BYTE_OP; + break; + case 2: + op = UNALIGNED_SHORT_ASM_OP; + break; + case 4: + op = UNALIGNED_INT_ASM_OP; + break; + case 8: +#ifdef UNALIGNED_DOUBLE_INT_ASM_OP + op = UNALIGNED_DOUBLE_INT_ASM_OP; + break; +#endif + default: + abort (); + } + return op; +} +#endif /* UNALIGNED_INT_ASM_OP */ + +void +dw2_asm_output_data VPARAMS ((int size, unsigned HOST_WIDE_INT value, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + int size; + unsigned HOST_WIDE_INT value; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + size = va_arg (ap, int); + value = va_arg (ap, unsigned HOST_WIDE_INT); + comment = va_arg (ap, const char *); +#endif + +#ifdef UNALIGNED_INT_ASM_OP + fputs (unaligned_integer_asm_op (size), asm_out_file); + fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value); +#else + assemble_integer (GEN_INT (value), size, 1); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_delta VPARAMS ((int size, const char *lab1, const char *lab2, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + int size; + const char *lab1, *lab2; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + size = va_arg (ap, int); + lab1 = va_arg (ap, const char *); + lab2 = va_arg (ap, const char *); + comment = va_arg (ap, const char *); +#endif + +#ifdef UNALIGNED_INT_ASM_OP + fputs (unaligned_integer_asm_op (size), asm_out_file); + assemble_name (asm_out_file, lab1); + fputc ('-', asm_out_file); + assemble_name (asm_out_file, lab2); +#else + assemble_integer (gen_rtx_MINUS (smallest_mode_for_size (size, MODE_INT, 0), + gen_rtx_SYMBOL_REF (Pmode, lab1), + gen_rtx_SYMBOL_REF (Pmode, lab2)), + size, 1); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_offset VPARAMS ((int size, const char *label, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + int size; + const char *label; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + size = va_arg (ap, int); + label = va_arg (ap, const char *); + comment = va_arg (ap, const char *); +#endif + +#ifdef UNALIGNED_INT_ASM_OP + fputs (unaligned_integer_asm_op (size), asm_out_file); + assemble_name (asm_out_file, label); +#else + assemble_integer (gen_rtx_SYMBOL_REF (Pmode, label), size, 1); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_pcrel VPARAMS ((int size, const char *label, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + int size; + const char *label; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + size = va_arg (ap, int); + label = va_arg (ap, const char *); + comment = va_arg (ap, const char *); +#endif + +#ifdef UNALIGNED_INT_ASM_OP + fputs (unaligned_integer_asm_op (size), asm_out_file); + + /* ??? This needs target conditionalization. E.g. the solaris + assembler uses %r_disp32(label). Others don't like "." and + we need to generate a temporary label here. */ + assemble_name (asm_out_file, label); + fputc ('-', asm_out_file); + fputc ('.', asm_out_file); +#else + abort (); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_addr_rtx VPARAMS ((int size, rtx addr, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + int size; + rtx addr; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + size = va_arg (ap, int); + addr = va_arg (ap, rtx); + comment = va_arg (ap, const char *); +#endif + +#ifdef UNALIGNED_INT_ASM_OP + fputs (unaligned_integer_asm_op (size), asm_out_file); + output_addr_const (asm_out_file, addr); +#else + assemble_integer (addr, size, 1); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_nstring VPARAMS ((const char *str, size_t orig_len, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + const char *str; + size_t orig_len; + const char *comment; +#endif + va_list ap; + size_t i, len = orig_len; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + str = va_arg (ap, const char *); + len = va_arg (ap, size_t); + comment = va_arg (ap, const char *); +#endif + + if (len == (size_t) -1) + len = strlen (str); + + if (flag_debug_asm && comment) + { + fputs ("\t.ascii \"", asm_out_file); + for (i = 0; i < len; i++) + { + int c = str[i]; + if (c == '\"' || c == '\\') + fputc ('\\', asm_out_file); + if (ISPRINT(c)) + fputc (c, asm_out_file); + else + fprintf (asm_out_file, "\\%o", c); + } + fprintf (asm_out_file, "\\0\"\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + fputc ('\n', asm_out_file); + } + else + { + /* If an explicit length was given, we can't assume there + is a null termination in the string buffer. */ + if (orig_len == (size_t) -1) + len += 1; + ASM_OUTPUT_ASCII (asm_out_file, str, len); + if (orig_len != (size_t) -1) + fprintf (asm_out_file, "%s0\n", ASM_BYTE_OP); + } + + va_end (ap); +} + + +/* Return the size of an unsigned LEB128 quantity. */ + +int +size_of_uleb128 (value) + unsigned HOST_WIDE_INT value; +{ + int size = 0, byte; + + do + { + byte = (value & 0x7f); + value >>= 7; + size += 1; + } + while (value != 0); + + return size; +} + +/* Return the size of a signed LEB128 quantity. */ + +int +size_of_sleb128 (value) + HOST_WIDE_INT value; +{ + int size = 0, byte; + + do + { + byte = (value & 0x7f); + value >>= 7; + size += 1; + } + while (!((value == 0 && (byte & 0x40) == 0) + || (value == -1 && (byte & 0x40) != 0))); + + return size; +} + +/* Output an unsigned LEB128 quantity. */ + +void +dw2_asm_output_data_uleb128 VPARAMS ((unsigned HOST_WIDE_INT value, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + unsigned HOST_WIDE_INT value; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + value = va_arg (ap, unsigned HOST_WIDE_INT); + comment = va_arg (ap, const char *); +#endif + +#ifdef HAVE_AS_LEB128 + fputs ("\t.uleb128\t", asm_out_file); + fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value); + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } +#else + { + unsigned HOST_WIDE_INT work = value; + + fputs (ASM_BYTE_OP, asm_out_file); + do + { + int byte = (work & 0x7f); + work >>= 7; + if (work != 0) + /* More bytes to follow. */ + byte |= 0x80; + + fprintf (asm_out_file, "0x%x", byte); + if (work != 0) + fputc (',', asm_out_file); + } + while (work != 0); + + if (flag_debug_asm) + { + fprintf (asm_out_file, "\t%s uleb128 ", ASM_COMMENT_START); + fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value); + if (comment) + { + fputs ("; ", asm_out_file); + vfprintf (asm_out_file, comment, ap); + } + } + } +#endif + fputc ('\n', asm_out_file); + + va_end (ap); +} + +/* Output an signed LEB128 quantity. */ + +void +dw2_asm_output_data_sleb128 VPARAMS ((HOST_WIDE_INT value, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + HOST_WIDE_INT value; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + value = va_arg (ap, HOST_WIDE_INT); + comment = va_arg (ap, const char *); +#endif + +#ifdef HAVE_AS_LEB128 + fputs ("\t.sleb128\t", asm_out_file); + fprintf (asm_out_file, HOST_WIDE_INT_PRINT_HEX, value); + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } +#else + { + HOST_WIDE_INT work = value; + int more, byte; + + fputs (ASM_BYTE_OP, asm_out_file); + do + { + byte = (work & 0x7f); + /* arithmetic shift */ + work >>= 7; + more = !((work == 0 && (byte & 0x40) == 0) + || (work == -1 && (byte & 0x40) != 0)); + if (more) + byte |= 0x80; + + fprintf (asm_out_file, "0x%x", byte); + if (more) + fputc (',', asm_out_file); + } + while (more); + + if (flag_debug_asm) + { + fprintf (asm_out_file, "\t%s sleb128 ", ASM_COMMENT_START); + fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, value); + if (comment) + { + fputs ("; ", asm_out_file); + vfprintf (asm_out_file, comment, ap); + } + } + } +#endif + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_delta_uleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED, + const char *lab2 ATTRIBUTE_UNUSED, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + const char *lab1, *lab2; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + lab1 = va_arg (ap, const char *); + lab2 = va_arg (ap, const char *); + comment = va_arg (ap, const char *); +#endif + +#ifdef HAVE_AS_LEB128 + fputs ("\t.uleb128\t", asm_out_file); + assemble_name (asm_out_file, lab1); + fputc ('-', asm_out_file); + assemble_name (asm_out_file, lab2); +#else + abort (); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} + +void +dw2_asm_output_delta_sleb128 VPARAMS ((const char *lab1 ATTRIBUTE_UNUSED, + const char *lab2 ATTRIBUTE_UNUSED, + const char *comment, ...)) +{ +#ifndef ANSI_PROTOTYPES + const char *lab1, *lab2; + const char *comment; +#endif + va_list ap; + + VA_START (ap, comment); + +#ifndef ANSI_PROTOTYPES + lab1 = va_arg (ap, const char *); + lab2 = va_arg (ap, const char *); + comment = va_arg (ap, const char *); +#endif + +#ifdef HAVE_AS_LEB128 + fputs ("\t.sleb128\t", asm_out_file); + assemble_name (asm_out_file, lab1); + fputc ('-', asm_out_file); + assemble_name (asm_out_file, lab2); +#else + abort (); +#endif + + if (flag_debug_asm && comment) + { + fprintf (asm_out_file, "\t%s ", ASM_COMMENT_START); + vfprintf (asm_out_file, comment, ap); + } + fputc ('\n', asm_out_file); + + va_end (ap); +} diff --git a/gcc/dwarf2asm.h b/gcc/dwarf2asm.h new file mode 100644 index 0000000..a1a2ae9 --- /dev/null +++ b/gcc/dwarf2asm.h @@ -0,0 +1,68 @@ +/* Dwarf2 assembler output helper routines. + Copyright (C) 2001 Free Software Foundation, Inc. + +This file is part of GNU CC. + +GNU CC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU CC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU CC; see the file COPYING. If not, write to +the Free Software Foundation, 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. */ + + +/* ??? Format checking yields "null format string" warnings, which is + the way these routines are signaled that there is no associated + debug information. So the attributes are commented out. */ + +extern void dw2_asm_output_data PARAMS ((int, unsigned HOST_WIDE_INT, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern void dw2_asm_output_delta PARAMS ((int, const char *, + const char *, + const char *, ...)) + /* ATTRIBUTE_PRINTF_4 */; + +extern void dw2_asm_output_offset PARAMS ((int, const char *, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern void dw2_asm_output_pcrel PARAMS ((int, const char *, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern void dw2_asm_output_addr_rtx PARAMS ((int, rtx, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern void dw2_asm_output_nstring PARAMS ((const char *, size_t, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern void dw2_asm_output_data_uleb128 PARAMS ((unsigned HOST_WIDE_INT, + const char *, ...)) + /* ATTRIBUTE_PRINTF_2 */; + +extern void dw2_asm_output_data_sleb128 PARAMS ((HOST_WIDE_INT, + const char *, ...)) + /* ATTRIBUTE_PRINTF_2 */; + +extern void dw2_asm_output_delta_uleb128 PARAMS ((const char *, const char *, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern void dw2_asm_output_delta_sleb128 PARAMS ((const char *, const char *, + const char *, ...)) + /* ATTRIBUTE_PRINTF_3 */; + +extern int size_of_uleb128 PARAMS ((unsigned HOST_WIDE_INT)); +extern int size_of_sleb128 PARAMS ((HOST_WIDE_INT)); diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c index a34aa58..48777fe 100644 --- a/gcc/dwarf2out.c +++ b/gcc/dwarf2out.c @@ -49,6 +49,7 @@ Boston, MA 02111-1307, USA. */ #include "except.h" #include "dwarf2.h" #include "dwarf2out.h" +#include "dwarf2asm.h" #include "toplev.h" #include "varray.h" #include "ggc.h" @@ -230,10 +231,6 @@ static char *stripattributes PARAMS ((const char *)); static const char *dwarf_cfi_name PARAMS ((unsigned)); static dw_cfi_ref new_cfi PARAMS ((void)); static void add_cfi PARAMS ((dw_cfi_ref *, dw_cfi_ref)); -static unsigned long size_of_uleb128 PARAMS ((unsigned long)); -static unsigned long size_of_sleb128 PARAMS ((long)); -static void output_uleb128 PARAMS ((unsigned long)); -static void output_sleb128 PARAMS ((long)); static void add_fde_cfi PARAMS ((const char *, dw_cfi_ref)); static void lookup_cfa_1 PARAMS ((dw_cfi_ref, dw_cfa_location *)); static void lookup_cfa PARAMS ((dw_cfa_location *)); @@ -254,25 +251,9 @@ static struct dw_loc_descr_struct *build_cfa_loc PARAMS ((dw_cfa_location *)); static void def_cfa_1 PARAMS ((const char *, dw_cfa_location *)); -/* Definitions of defaults for assembler-dependent names of various - pseudo-ops and section names. - Theses may be overridden in the tm.h file (if necessary) for a particular - assembler. */ - -#ifdef OBJECT_FORMAT_ELF -#ifndef UNALIGNED_SHORT_ASM_OP -#define UNALIGNED_SHORT_ASM_OP "\t.2byte\t" -#endif -#ifndef UNALIGNED_INT_ASM_OP -#define UNALIGNED_INT_ASM_OP "\t.4byte\t" -#endif -#ifndef UNALIGNED_DOUBLE_INT_ASM_OP -#define UNALIGNED_DOUBLE_INT_ASM_OP "\t.8byte\t" -#endif -#endif /* OBJECT_FORMAT_ELF */ - -#ifndef ASM_BYTE_OP -#define ASM_BYTE_OP "\t.byte\t" +/* How to start an assembler comment. */ +#ifndef ASM_COMMENT_START +#define ASM_COMMENT_START ";#" #endif /* Data and reference forms for relocatable data. */ @@ -309,9 +290,12 @@ static void def_cfa_1 PARAMS ((const char *, dw_cfa_location *)); #define CIE_AFTER_SIZE_LABEL "LSCIE" #define CIE_END_LABEL "LECIE" #define CIE_LENGTH_LABEL "LLCIE" -#define FDE_AFTER_SIZE_LABEL "LSFDE" +#define FDE_LABEL "LSFDE" +#define FDE_AFTER_SIZE_LABEL "LASFDE" #define FDE_END_LABEL "LEFDE" #define FDE_LENGTH_LABEL "LLFDE" +#define LINE_NUMBER_BEGIN_LABEL "LTSTART" +#define LINE_NUMBER_END_LABEL "LTEND" #define DIE_LABEL_PREFIX "DW" /* Definitions of defaults for various types of primitive assembly language @@ -323,212 +307,6 @@ static void def_cfa_1 PARAMS ((const char *, dw_cfa_location *)); fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION) #endif -#ifndef ASM_OUTPUT_DWARF_DATA1 -#define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \ - fprintf ((FILE), "%s0x%x", ASM_BYTE_OP, (unsigned) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA1 -#define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "%s", ASM_BYTE_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifdef UNALIGNED_INT_ASM_OP - -#ifndef UNALIGNED_OFFSET_ASM_OP -#define UNALIGNED_OFFSET_ASM_OP \ - (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP) -#endif - -#ifndef UNALIGNED_WORD_ASM_OP -#define UNALIGNED_WORD_ASM_OP \ - ((DWARF2_ADDR_SIZE) == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP \ - : (DWARF2_ADDR_SIZE) == 2 ? UNALIGNED_SHORT_ASM_OP \ - : UNALIGNED_INT_ASM_OP) -#endif - -#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); \ - } while (0) -#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); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA -#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "%s", UNALIGNED_OFFSET_ASM_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_DELTA -#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \ - do { fprintf ((FILE), "%s", UNALIGNED_WORD_ASM_OP); \ - assemble_name (FILE, LABEL1); \ - fprintf (FILE, "-"); \ - assemble_name (FILE, LABEL2); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR -#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ - do { fprintf ((FILE), "%s", UNALIGNED_WORD_ASM_OP); \ - assemble_name (FILE, LABEL); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_CONST -#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \ - do { \ - fprintf ((FILE), "%s", UNALIGNED_WORD_ASM_OP); \ - output_addr_const ((FILE), (RTX)); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_OFFSET4 -#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \ - do { fprintf ((FILE), "%s", UNALIGNED_INT_ASM_OP); \ - assemble_name (FILE, LABEL); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_OFFSET -#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \ - do { fprintf ((FILE), "%s", UNALIGNED_OFFSET_ASM_OP); \ - assemble_name (FILE, LABEL); \ - } while (0) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA2 -#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \ - fprintf ((FILE), "%s0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA4 -#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ - fprintf ((FILE), "%s0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA8 -#define ASM_OUTPUT_DWARF_DATA8(FILE,VALUE) \ - fprintf ((FILE), "%s0x%lx", UNALIGNED_DOUBLE_INT_ASM_OP, \ - (unsigned long) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA -#define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \ - fprintf ((FILE), "%s0x%lx", UNALIGNED_OFFSET_ASM_OP, \ - (unsigned long) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_DATA -#define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \ - fprintf ((FILE), "%s0x%lx", UNALIGNED_WORD_ASM_OP, \ - (unsigned long) (VALUE)) -#endif - -#ifndef ASM_OUTPUT_DWARF_CONST_DOUBLE -#define ASM_OUTPUT_DWARF_CONST_DOUBLE(FILE,HIGH_VALUE,LOW_VALUE) \ - do { \ - if (WORDS_BIG_ENDIAN) \ - { \ - fprintf ((FILE), "%s0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\ - fprintf ((FILE), "%s0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\ - } \ - else \ - { \ - fprintf ((FILE), "%s0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \ - fprintf ((FILE), "%s0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \ - } \ - } while (0) -#endif - -#else /* UNALIGNED_INT_ASM_OP */ - -/* We don't have unaligned support, let's hope the normal output works for - .debug_frame. But we know it won't work for .debug_info. */ - -#ifdef DWARF2_DEBUGGING_INFO - #error DWARF2_DEBUGGING_INFO requires UNALIGNED_INT_ASM_OP. -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR -#define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \ - assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), DWARF2_ADDR_SIZE, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_CONST -#define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) ASM_OUTPUT_DWARF_ADDR (FILE,RTX) -#endif - -#ifndef ASM_OUTPUT_DWARF_OFFSET4 -#define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \ - assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_OFFSET -#define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \ - assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA2 -#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \ - assemble_integer (gen_rtx_MINUS (HImode, \ - gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ - gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ - 2, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA4 -#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \ - assemble_integer (gen_rtx_MINUS (SImode, \ - gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ - gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ - 4, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_ADDR_DELTA -#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \ - assemble_integer (gen_rtx_MINUS (Pmode, \ - gen_rtx_SYMBOL_REF (Pmode, LABEL1), \ - gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \ - DWARF2_ADDR_SIZE, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_DELTA -#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \ - ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA2 -#define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \ - assemble_integer (GEN_INT (VALUE), 2, 1) -#endif - -#ifndef ASM_OUTPUT_DWARF_DATA4 -#define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \ - assemble_integer (GEN_INT (VALUE), 4, 1) -#endif - -#endif /* UNALIGNED_INT_ASM_OP */ - #ifdef SET_ASM_OP #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \ @@ -543,35 +321,6 @@ static void def_cfa_1 PARAMS ((const char *, dw_cfa_location *)); #endif #endif /* SET_ASM_OP */ -/* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing - newline is produced. When flag_debug_asm is asserted, we add commentary - at the end of the line, so we must avoid output of a newline here. */ -#ifndef ASM_OUTPUT_DWARF_NSTRING -#define ASM_OUTPUT_DWARF_NSTRING(FILE,P,SLEN) \ - do { \ - register int slen = (SLEN); \ - register const char *p = (P); \ - register int i; \ - fprintf (FILE, "\t.ascii \""); \ - for (i = 0; i < slen; i++) \ - { \ - register int c = p[i]; \ - if (c == '\"' || c == '\\') \ - putc ('\\', FILE); \ - if (ISPRINT(c)) \ - putc (c, FILE); \ - else \ - { \ - fprintf (FILE, "\\%o", c); \ - } \ - } \ - fprintf (FILE, "\\0\""); \ - } \ - while (0) -#endif -#define ASM_OUTPUT_DWARF_STRING(FILE,P) \ - ASM_OUTPUT_DWARF_NSTRING (FILE, P, strlen (P)) - /* The DWARF 2 CFA column which tracks the return address. Normally this is the column for PC, or the first column after all of the hard registers. */ @@ -1732,9 +1481,6 @@ dwarf2out_frame_debug (insn) if (insn == NULL_RTX) { - rtx insn; - int n_alternate_entry_points; - /* Set up state for generating call frame debug info. */ lookup_cfa (&cfa); if (cfa.reg != (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM)) @@ -1763,105 +1509,6 @@ dwarf2out_frame_debug (insn) dwarf2out_frame_debug_expr (insn, label); } -/* Return the size of an unsigned LEB128 quantity. */ - -static inline unsigned long -size_of_uleb128 (value) - register unsigned long value; -{ - register unsigned long size = 0; - register unsigned byte; - - do - { - byte = (value & 0x7f); - value >>= 7; - size += 1; - } - while (value != 0); - - return size; -} - -/* Return the size of a signed LEB128 quantity. */ - -static inline unsigned long -size_of_sleb128 (value) - register long value; -{ - register unsigned long size = 0; - register unsigned byte; - - do - { - byte = (value & 0x7f); - value >>= 7; - size += 1; - } - while (!(((value == 0) && ((byte & 0x40) == 0)) - || ((value == -1) && ((byte & 0x40) != 0)))); - - return size; -} - -/* Output an unsigned LEB128 quantity. */ - -static void -output_uleb128 (value) - register unsigned long value; -{ - unsigned long save_value = value; - - fprintf (asm_out_file, "%s", ASM_BYTE_OP); - do - { - register unsigned byte = (value & 0x7f); - value >>= 7; - if (value != 0) - /* More bytes to follow. */ - byte |= 0x80; - - fprintf (asm_out_file, "0x%x", byte); - if (value != 0) - fprintf (asm_out_file, ","); - } - while (value != 0); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value); -} - -/* Output an signed LEB128 quantity. */ - -static void -output_sleb128 (value) - register long value; -{ - register int more; - register unsigned byte; - long save_value = value; - - fprintf (asm_out_file, "%s", ASM_BYTE_OP); - do - { - byte = (value & 0x7f); - /* arithmetic shift */ - value >>= 7; - more = !((((value == 0) && ((byte & 0x40) == 0)) - || ((value == -1) && ((byte & 0x40) != 0)))); - if (more) - byte |= 0x80; - - fprintf (asm_out_file, "0x%x", byte); - if (more) - fprintf (asm_out_file, ","); - } - - while (more); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value); -} - /* Output a Call Frame Information opcode and its operand(s). */ static void @@ -1871,114 +1518,79 @@ output_cfi (cfi, fde) { if (cfi->dw_cfi_opc == DW_CFA_advance_loc) { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - cfi->dw_cfi_opc - | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx", - ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, (cfi->dw_cfi_opc + | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)), + "DW_CFA_advance_loc 0x%lx", + cfi->dw_cfi_oprnd1.dw_cfi_offset); } - else if (cfi->dw_cfi_opc == DW_CFA_offset) { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - cfi->dw_cfi_opc - | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx", - ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - - fputc ('\n', asm_out_file); - output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, (cfi->dw_cfi_opc + | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)), + "DW_CFA_offset, column 0x%lx", + cfi->dw_cfi_oprnd1.dw_cfi_reg_num); + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); } else if (cfi->dw_cfi_opc == DW_CFA_restore) { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - cfi->dw_cfi_opc - | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx", - ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, (cfi->dw_cfi_opc + | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f)), + "DW_CFA_restore, column 0x%lx", + cfi->dw_cfi_oprnd1.dw_cfi_reg_num); } else { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, - dwarf_cfi_name (cfi->dw_cfi_opc)); + dw2_asm_output_data (1, cfi->dw_cfi_opc, + "%s", dwarf_cfi_name (cfi->dw_cfi_opc)); - fputc ('\n', asm_out_file); switch (cfi->dw_cfi_opc) { case DW_CFA_set_loc: - ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr); - fputc ('\n', asm_out_file); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, + cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL); break; case DW_CFA_advance_loc1: - ASM_OUTPUT_DWARF_DELTA1 (asm_out_file, - cfi->dw_cfi_oprnd1.dw_cfi_addr, - fde->dw_fde_current_label); - fputc ('\n', asm_out_file); + dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr, + fde->dw_fde_current_label, NULL); fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; break; case DW_CFA_advance_loc2: - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, - cfi->dw_cfi_oprnd1.dw_cfi_addr, - fde->dw_fde_current_label); - fputc ('\n', asm_out_file); + dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr, + fde->dw_fde_current_label, NULL); fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; break; case DW_CFA_advance_loc4: - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, - cfi->dw_cfi_oprnd1.dw_cfi_addr, - fde->dw_fde_current_label); - fputc ('\n', asm_out_file); + dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr, + fde->dw_fde_current_label, NULL); fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; break; -#ifdef MIPS_DEBUGGING_INFO case DW_CFA_MIPS_advance_loc8: - /* TODO: not currently implemented. */ - abort (); + dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr, + fde->dw_fde_current_label, NULL); + fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr; break; -#endif case DW_CFA_offset_extended: case DW_CFA_GNU_negative_offset_extended: case DW_CFA_def_cfa: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, NULL); + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL); break; case DW_CFA_restore_extended: case DW_CFA_undefined: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - break; case DW_CFA_same_value: case DW_CFA_def_cfa_register: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, NULL); break; case DW_CFA_register: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num); - fputc ('\n', asm_out_file); - output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, NULL); + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, NULL); break; case DW_CFA_def_cfa_offset: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset); - fputc ('\n', asm_out_file); + case DW_CFA_GNU_args_size: + dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL); break; case DW_CFA_GNU_window_save: break; - case DW_CFA_GNU_args_size: - output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset); - fputc ('\n', asm_out_file); - break; case DW_CFA_def_cfa_expression: output_cfa_loc (cfi); break; @@ -2018,8 +1630,6 @@ output_call_frame_info (for_eh) found:; } - fputc ('\n', asm_out_file); - /* We're going to be generating comments, so turn on app. */ if (flag_debug_asm) app_enable (); @@ -2046,91 +1656,43 @@ output_call_frame_info (for_eh) ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh); #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh); - if (for_eh) - ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld); - else - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld); + dw2_asm_output_offset (for_eh ? 4 : DWARF_OFFSET_SIZE, ld, + "Length of Common Information Entry"); #else - if (for_eh) - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1); - else - ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1); + dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, + "Length of Common Information Entry"); #endif - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Common Information Entry", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); ASM_OUTPUT_LABEL (asm_out_file, l1); - if (for_eh) - /* Now that the CIE pointer is PC-relative for EH, - use 0 to identify the CIE. */ - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); - else - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - if (! for_eh && DWARF_OFFSET_SIZE == 8) - { - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID); - fputc ('\n', asm_out_file); - } + /* Now that the CIE pointer is PC-relative for EH, + use 0 to identify the CIE. */ + dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE), + (for_eh ? 0 : DW_CIE_ID), + "CIE Identifier Tag"); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START); + dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version"); - fputc ('\n', asm_out_file); if (eh_ptr) { /* The CIE contains a pointer to the exception region info for the frame. Make the augmentation string three bytes (including the trailing null) so the pointer is 4-byte aligned. The Solaris ld can't handle unaligned relocs. */ - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh"); - fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START); - } - else - { - ASM_OUTPUT_ASCII (asm_out_file, "eh", 3); - } - fputc ('\n', asm_out_file); - - ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__"); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s pointer to exception region info", - ASM_COMMENT_START); + dw2_asm_output_nstring ("eh", 3, "CIE Augmentation"); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, "__EXCEPTION_TABLE__", + "pointer to exception region info"); } else { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE Augmentation (none)", - ASM_COMMENT_START); + dw2_asm_output_data (1, 0, "CIE Augmentation (none)"); } - fputc ('\n', asm_out_file); - output_uleb128 (1); - if (flag_debug_asm) - fprintf (asm_out_file, " (CIE Code Alignment Factor)"); + dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor"); - fputc ('\n', asm_out_file); - output_sleb128 (DWARF_CIE_DATA_ALIGNMENT); - if (flag_debug_asm) - fprintf (asm_out_file, " (CIE Data Alignment Factor)"); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START); + dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT, + "CIE Data Alignment Factor"); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN, "CIE RA Column"); for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next) output_cfi (cfi, NULL); @@ -2154,23 +1716,16 @@ output_call_frame_info (for_eh) if (for_eh && fde->nothrow) continue; + ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, FDE_LABEL, for_eh + i * 2); ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2); ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2); #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i * 2); - if (for_eh) - ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld); - else - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld); + dw2_asm_output_offset (for_eh ? 4 : DWARF_OFFSET_SIZE, ld, "FDE Length"); #else - if (for_eh) - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1); - else - ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1); + dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1, + "FDE Length"); #endif - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START); - fputc ('\n', asm_out_file); ASM_OUTPUT_LABEL (asm_out_file, l1); /* ??? This always emits a 4 byte offset when for_eh is true, but it @@ -2182,24 +1737,17 @@ output_call_frame_info (for_eh) If the for_eh case is changed, then the struct in frame.c has to be adjusted appropriately. */ if (for_eh) - ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__"); + dw2_asm_output_delta (4, l1, "__FRAME_BEGIN__", "FDE CIE offset"); else - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION)); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START); + dw2_asm_output_offset (DWARF_OFFSET_SIZE, + stripattributes (FRAME_SECTION), + "FDE CIE offset"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, - fde->dw_fde_end, fde->dw_fde_begin); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, fde->dw_fde_begin, + "FDE initial location"); - fputc ('\n', asm_out_file); + dw2_asm_output_delta (DWARF2_ADDR_SIZE, fde->dw_fde_end, + fde->dw_fde_begin, "FDE address range"); /* Loop through the Call Frame Instructions associated with this FDE. */ @@ -2217,13 +1765,10 @@ output_call_frame_info (for_eh) fputc ('\n', asm_out_file); #endif } + #ifndef EH_FRAME_SECTION if (for_eh) - { - /* Emit terminating zero for table. */ - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0); - fputc ('\n', asm_out_file); - } + dw2_asm_output_data (4, 0, "End of Table"); #endif #ifdef MIPS_DEBUGGING_INFO /* Work around Irix 6 assembler bug whereby labels at the end of a section @@ -2902,23 +2447,21 @@ output_loc_operands (loc) { #ifdef DWARF2_DEBUGGING_INFO case DW_OP_addr: - ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr); - fputc ('\n', asm_out_file); + dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL); break; case DW_OP_const2u: case DW_OP_const2s: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data (2, val1->v.val_int, NULL); break; case DW_OP_const4u: case DW_OP_const4s: - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data (4, val1->v.val_int, NULL); break; case DW_OP_const8u: case DW_OP_const8s: - abort (); - fputc ('\n', asm_out_file); + if (HOST_BITS_PER_LONG < 64) + abort (); + dw2_asm_output_data (8, val1->v.val_int, NULL); break; case DW_OP_skip: case DW_OP_bra: @@ -2930,8 +2473,7 @@ output_loc_operands (loc) else abort (); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, offset); - fputc ('\n', asm_out_file); + dw2_asm_output_data (2, offset, NULL); } break; #else @@ -2952,24 +2494,19 @@ output_loc_operands (loc) #endif case DW_OP_const1u: case DW_OP_const1s: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, val1->v.val_int, NULL); break; case DW_OP_constu: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); break; case DW_OP_consts: - output_sleb128 (val1->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); break; case DW_OP_pick: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, val1->v.val_int, NULL); break; case DW_OP_plus_uconst: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); break; case DW_OP_breg0: case DW_OP_breg1: @@ -3003,31 +2540,24 @@ output_loc_operands (loc) case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: - output_sleb128 (val1->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); break; case DW_OP_regx: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); break; case DW_OP_fbreg: - output_sleb128 (val1->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); break; case DW_OP_bregx: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); - output_sleb128 (val2->v.val_int); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); + dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); break; case DW_OP_piece: - output_uleb128 (val1->v.val_unsigned); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); break; case DW_OP_deref_size: case DW_OP_xderef_size: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, val1->v.val_int, NULL); break; default: /* Other codes have no operands. */ @@ -3044,12 +2574,8 @@ output_loc_sequence (loc) for (; loc != NULL; loc = loc->dw_loc_next) { /* Output the opcode. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START, - dwarf_stack_op_name (loc->dw_loc_opc)); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, loc->dw_loc_opc, + "%s", dwarf_stack_op_name (loc->dw_loc_opc)); /* Output the operand(s) (if any). */ output_loc_operands (loc); @@ -3069,8 +2595,7 @@ output_cfa_loc (cfi) /* Output the size of the block. */ loc = cfi->dw_cfi_oprnd1.dw_cfi_loc; size = size_of_locs (loc); - output_uleb128 (size); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (size, NULL); /* Now output the operations themselves. */ output_loc_sequence (loc); @@ -3665,7 +3190,6 @@ static enum dwarf_form value_format PARAMS ((dw_attr_ref)); static void output_value_format PARAMS ((dw_attr_ref)); static void output_abbrev_section PARAMS ((void)); static void output_die_symbol PARAMS ((dw_die_ref)); -static void output_symbolic_ref PARAMS ((dw_die_ref)); static void output_die PARAMS ((dw_die_ref)); static void output_compilation_unit_header PARAMS ((void)); static void output_comp_unit PARAMS ((dw_die_ref)); @@ -5799,7 +5323,7 @@ size_of_die (die) size += constant_size (AT_unsigned (a)); break; case dw_val_class_long_long: - size += 1 + 8; /* block */ + size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */ break; case dw_val_class_float: size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */ @@ -6023,12 +5547,7 @@ output_value_format (a) dw_attr_ref a; { enum dwarf_form form = value_format (a); - - output_uleb128 (form); - if (flag_debug_asm) - fprintf (asm_out_file, " (%s)", dwarf_form_name (form)); - - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form)); } /* Output the .debug_abbrev section which defines the DIE abbreviation @@ -6044,45 +5563,30 @@ output_abbrev_section () { register dw_die_ref abbrev = abbrev_die_table[abbrev_id]; - output_uleb128 (abbrev_id); - if (flag_debug_asm) - fprintf (asm_out_file, " (abbrev code)"); + dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)"); - fputc ('\n', asm_out_file); - output_uleb128 (abbrev->die_tag); - if (flag_debug_asm) - fprintf (asm_out_file, " (TAG: %s)", - dwarf_tag_name (abbrev->die_tag)); + dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)", + dwarf_tag_name (abbrev->die_tag)); - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "%s0x%x", ASM_BYTE_OP, - abbrev->die_child != NULL ? DW_children_yes : DW_children_no); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, - (abbrev->die_child != NULL - ? "DW_children_yes" : "DW_children_no")); - - fputc ('\n', asm_out_file); + if (abbrev->die_child != NULL) + dw2_asm_output_data (1, DW_children_yes, "DW_children_yes"); + else + dw2_asm_output_data (1, DW_children_no, "DW_children_no"); for (a_attr = abbrev->die_attr; a_attr != NULL; a_attr = a_attr->dw_attr_next) { - output_uleb128 (a_attr->dw_attr); - if (flag_debug_asm) - fprintf (asm_out_file, " (%s)", - dwarf_attr_name (a_attr->dw_attr)); - - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)", + dwarf_attr_name (a_attr->dw_attr)); output_value_format (a_attr); } - fprintf (asm_out_file, "%s0,0\n", ASM_BYTE_OP); + dw2_asm_output_data (1, 0, NULL); + dw2_asm_output_data (1, 0, NULL); } /* Terminate the table. */ - fprintf (asm_out_file, "%s0\n", ASM_BYTE_OP); + dw2_asm_output_data (1, 0, NULL); } /* Output a symbol we can use to refer to this DIE from another CU. */ @@ -6104,20 +5608,6 @@ output_die_symbol (die) ASM_OUTPUT_LABEL (asm_out_file, sym); } -/* Output a symbolic (i.e. FORM_ref_addr) reference to TARGET_DIE. */ - -static inline void -output_symbolic_ref (target_die) - dw_die_ref target_die; -{ - char *sym = target_die->die_symbol; - - if (sym == 0) - abort (); - - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, sym); -} - /* Output the DIE and its attributes. Called recursively to generate the definitions of each child DIE. */ @@ -6134,42 +5624,24 @@ output_die (die) if (die->die_symbol) output_die_symbol (die); - output_uleb128 (die->die_abbrev); - if (flag_debug_asm) - fprintf (asm_out_file, " (DIE (0x%lx) %s)", - die->die_offset, dwarf_tag_name (die->die_tag)); - - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)", + die->die_offset, dwarf_tag_name (die->die_tag)); for (a = die->die_attr; a != NULL; a = a->dw_attr_next) { + const char *name = dwarf_attr_name (a->dw_attr); + switch (AT_class (a)) { case dw_val_class_addr: - ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, AT_addr (a)); + dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name); break; case dw_val_class_loc: size = size_of_locs (AT_loc (a)); /* Output the block length for this list of location operations. */ - switch (constant_size (size)) - { - case 1: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size); - break; - case 2: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size); - break; - default: - abort (); - } - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (constant_size (size), size, "%s", name); output_loc_sequence (AT_loc (a)); break; @@ -6178,123 +5650,94 @@ output_die (die) /* ??? It would be slightly more efficient to use a scheme like is used for unsigned constants below, but gdb 4.x does not sign extend. Gdb 5.x does sign extend. */ - output_sleb128 (AT_int (a)); + dw2_asm_output_data_sleb128 (AT_int (a), "%s", name); break; case dw_val_class_unsigned_const: - switch (constant_size (AT_unsigned (a))) - { - case 1: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_unsigned (a)); - break; - case 2: - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, AT_unsigned (a)); - break; - case 4: - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_unsigned (a)); - break; - case 8: - ASM_OUTPUT_DWARF_DATA8 (asm_out_file, AT_unsigned (a)); - break; - default: - abort (); - } + dw2_asm_output_data (constant_size (AT_unsigned (a)), + AT_unsigned (a), "%s", name); break; case dw_val_class_long_long: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_CONST_DOUBLE (asm_out_file, - a->dw_attr_val.v.val_long_long.hi, - a->dw_attr_val.v.val_long_long.low); + { + unsigned HOST_WIDE_INT first, second; - if (flag_debug_asm) - fprintf (asm_out_file, - "\t%s long long constant", ASM_COMMENT_START); + dw2_asm_output_data (1, 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR, + "%s", name); - fputc ('\n', asm_out_file); + if (WORDS_BIG_ENDIAN) + { + first = a->dw_attr_val.v.val_long_long.hi; + second = a->dw_attr_val.v.val_long_long.low; + } + else + { + first = a->dw_attr_val.v.val_long_long.low; + second = a->dw_attr_val.v.val_long_long.hi; + } + dw2_asm_output_data (HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR, + first, "long long constant"); + dw2_asm_output_data (HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR, + second, NULL); + } break; case dw_val_class_float: { register unsigned int i; - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - a->dw_attr_val.v.val_float.length * 4); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - fputc ('\n', asm_out_file); - for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i) - { - ASM_OUTPUT_DWARF_DATA4 (asm_out_file, - a->dw_attr_val.v.val_float.array[i]); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s fp constant word %u", - ASM_COMMENT_START, i); + dw2_asm_output_data (1, a->dw_attr_val.v.val_float.length * 4, + "%s", name); - fputc ('\n', asm_out_file); - } + for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i) + dw2_asm_output_data (4, a->dw_attr_val.v.val_float.array[i], + "fp constant word %u", i); break; } case dw_val_class_flag: - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_flag (a)); + dw2_asm_output_data (1, AT_flag (a), "%s", name); break; case dw_val_class_die_ref: if (AT_ref_external (a)) - output_symbolic_ref (AT_ref (a)); + { + char *sym = AT_ref (a)->die_symbol; + if (sym == 0) + abort (); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name); + } else if (AT_ref (a)->die_offset == 0) abort (); else - ASM_OUTPUT_DWARF_DATA (asm_out_file, AT_ref (a)->die_offset); + dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset, + "%s", name); break; case dw_val_class_fde_ref: { char l1[20]; - ASM_GENERATE_INTERNAL_LABEL - (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1); - fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE); + ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL, + a->dw_attr_val.v.val_fde_index * 2); + dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name); } break; case dw_val_class_lbl_id: - ASM_OUTPUT_DWARF_ADDR (asm_out_file, AT_lbl (a)); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name); break; case dw_val_class_lbl_offset: - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, AT_lbl (a)); + dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name); break; case dw_val_class_str: - if (flag_debug_asm) - ASM_OUTPUT_DWARF_STRING (asm_out_file, AT_string (a)); - else - ASM_OUTPUT_ASCII (asm_out_file, AT_string (a), - (int) strlen (AT_string (a)) + 1); + dw2_asm_output_nstring (AT_string (a), -1, "%s", name); break; default: abort (); } - - if (AT_class (a) != dw_val_class_loc - && AT_class (a) != dw_val_class_long_long - && AT_class (a) != dw_val_class_float) - { - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s", - ASM_COMMENT_START, dwarf_attr_name (a->dw_attr)); - - fputc ('\n', asm_out_file); - } } for (c = die->die_child; c != NULL; c = c->die_sib) @@ -6303,12 +5746,8 @@ output_die (die) if (die->die_child != NULL) { /* Add null byte to terminate sibling list. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx", - ASM_COMMENT_START, die->die_offset); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx", + die->die_offset); } } @@ -6318,28 +5757,15 @@ output_die (die) static void output_compilation_unit_header () { - ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.", - ASM_COMMENT_START); + dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset - DWARF_OFFSET_SIZE, + "Length of Compilation Unit Info"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START); + dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF2_ADDR_SIZE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START); + dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label, + "Offset Into Abbrev. Section"); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)"); } /* Output the compilation unit DIE and its children. */ @@ -6373,7 +5799,6 @@ output_comp_unit (die) secname = (const char *) DEBUG_INFO_SECTION; /* Output debugging information. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, secname); output_compilation_unit_header (); output_die (die); @@ -6431,30 +5856,17 @@ output_pubnames () register unsigned i; register unsigned long pubnames_length = size_of_pubnames (); - ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Public Names Info.", - ASM_COMMENT_START); + dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length, + "Length of Public Names Info"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); + dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.", - ASM_COMMENT_START); + dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, + "Offset of Compilation Unit Info"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START); + dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset, + "Compilation Unit Length"); - fputc ('\n', asm_out_file); for (i = 0; i < pubname_table_in_use; ++i) { register pubname_ref pub = &pubname_table[i]; @@ -6463,28 +5875,13 @@ output_pubnames () if (pub->die->die_mark == 0) abort (); - ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name); - fprintf (asm_out_file, "%s external name", ASM_COMMENT_START); - } - else - { - ASM_OUTPUT_ASCII (asm_out_file, pub->name, - (int) strlen (pub->name) + 1); - } + dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset, + "DIE offset"); - fputc ('\n', asm_out_file); + dw2_asm_output_nstring (pub->name, -1, "external name"); } - ASM_OUTPUT_DWARF_DATA (asm_out_file, 0); - fputc ('\n', asm_out_file); + dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL); } /* Add a new entry to .debug_aranges if appropriate. */ @@ -6518,60 +5915,33 @@ output_aranges () register unsigned i; register unsigned long aranges_length = size_of_aranges (); - ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Address Ranges Info.", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); + dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length, + "Length of Address Ranges Info"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.", - ASM_COMMENT_START); + dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF2_ADDR_SIZE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START); + dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label, + "Offset of Compilation Unit Info"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Size of Segment Descriptor", - ASM_COMMENT_START); + dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address"); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "Size of Segment Descriptor"); /* We need to align to twice the pointer size here. */ if (DWARF_ARANGES_PAD_SIZE) { - /* Pad using a 2 bytes word so that padding is correct - for any pointer size. */ - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, 0); + /* Pad using a 2 byte words so that padding is correct for any + pointer size. */ + dw2_asm_output_data (2, 0, "Pad to %d byte boundary", + 2 * DWARF2_ADDR_SIZE); for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2) - fprintf (asm_out_file, ",0"); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Pad to %d byte boundary", - ASM_COMMENT_START, 2 * DWARF2_ADDR_SIZE); + dw2_asm_output_data (2, 0, NULL); } - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, text_section_label, "Address"); + dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label, + text_section_label, "Length"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, - text_section_label); - if (flag_debug_asm) - fprintf (asm_out_file, "%s Length", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); for (i = 0; i < arange_table_in_use; ++i) { dw_die_ref die = arange_table[i]; @@ -6581,7 +5951,12 @@ output_aranges () abort (); if (die->die_tag == DW_TAG_subprogram) - ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (die)); + { + dw2_asm_output_offset (DWARF2_ADDR_SIZE, get_AT_low_pc (die), + "Address"); + dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die), + get_AT_low_pc (die), "Length"); + } else { /* A static variable; extract the symbol from DW_AT_location. @@ -6597,32 +5972,17 @@ output_aranges () if (loc->dw_loc_opc != DW_OP_addr) abort (); - ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, - loc->dw_loc_oprnd1.v.val_addr); + dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, + loc->dw_loc_oprnd1.v.val_addr, "Address"); + dw2_asm_output_data (DWARF2_ADDR_SIZE, + get_AT_unsigned (die, DW_AT_byte_size), + "Length"); } - - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - if (die->die_tag == DW_TAG_subprogram) - ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (die), - get_AT_low_pc (die)); - else - ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, - get_AT_unsigned (die, DW_AT_byte_size)); - - if (flag_debug_asm) - fprintf (asm_out_file, "%s Length", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); } /* Output the terminator words. */ - ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0); - fputc ('\n', asm_out_file); + dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); + dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL); } @@ -6930,30 +6290,15 @@ output_file_names () if (dirs[i].used != 0) { dirs[i].used = idx++; - - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_NSTRING (asm_out_file, - dirs[i].path, dirs[i].length - 1); - fprintf (asm_out_file, "%s Directory Entry: 0x%x\n", - ASM_COMMENT_START, dirs[i].used); - } - else - { - ASM_OUTPUT_ASCII (asm_out_file, dirs[i].path, dirs[i].length - 1); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - fputc ('\n', asm_out_file); - } + dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1, + "Directory Entry: 0x%x", dirs[i].used); } + dw2_asm_output_data (1, 0, "End directory table"); + /* Correct the index for the current working directory entry if it exists. */ if (idx_offset == 0) dirs[0].used = 0; - /* Terminate the directory name array. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s End directory table", ASM_COMMENT_START); - fputc ('\n', asm_out_file); /* Now write all the file names. */ for (i = 1; i < (int) line_file_table.in_use; ++i) @@ -6961,38 +6306,19 @@ output_file_names () int file_idx = backmap[i]; int dir_idx = dirs[files[file_idx].dir_idx].dir_idx; - if (flag_debug_asm) - { - ASM_OUTPUT_DWARF_STRING (asm_out_file, - files[file_idx].path - + dirs[dir_idx].length); - fprintf (asm_out_file, "%s File Entry: 0x%x\n", - ASM_COMMENT_START, i); - } - else - ASM_OUTPUT_ASCII (asm_out_file, - files[file_idx].path + dirs[dir_idx].length, - (files[file_idx].length - - dirs[dir_idx].length) + 1); + dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1, + "File Entry: 0x%x", i); /* Include directory index. */ - output_uleb128 (dirs[dir_idx].used); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL); /* Modification time. */ - output_uleb128 (0); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (0, NULL); /* File length in bytes. */ - output_uleb128 (0); - fputc ('\n', asm_out_file); + dw2_asm_output_data_uleb128 (0, NULL); } - - /* Terminate the file name table */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s End file name table", ASM_COMMENT_START); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "End file name table"); } @@ -7002,6 +6328,7 @@ output_file_names () static void output_line_info () { + char l1[20], l2[20]; char line_label[MAX_ARTIFICIAL_LABEL_BYTES]; char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES]; register unsigned opc; @@ -7013,52 +6340,33 @@ output_line_info () register unsigned long current_file; register unsigned long function; - ASM_OUTPUT_DWARF_DELTA (asm_out_file, ".LTEND", ".LTSTART"); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Length of Source Line Info.", - ASM_COMMENT_START); + ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0); + ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0); - fputc ('\n', asm_out_file); - ASM_OUTPUT_LABEL (asm_out_file, ".LTSTART"); - ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START); + dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1, + "Length of Source Line Info"); + ASM_OUTPUT_LABEL (asm_out_file, l1); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ()); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START); + dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Minimum Instruction Length", - ASM_COMMENT_START); + dw2_asm_output_data (DWARF_OFFSET_SIZE, size_of_line_prolog (), + "Prolog Length"); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Default is_stmt_start flag", - ASM_COMMENT_START); + dw2_asm_output_data (1, DWARF_LINE_MIN_INSTR_LENGTH, + "Minimum Instruction Length"); - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "%s%d", ASM_BYTE_OP, DWARF_LINE_BASE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)", - ASM_COMMENT_START); + dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START, + "Default is_stmt_start flag"); - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "%s%u", ASM_BYTE_OP, DWARF_LINE_RANGE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)", - ASM_COMMENT_START); + dw2_asm_output_data (1, DWARF_LINE_BASE, + "Line Base Value (Special Opcodes)"); - fputc ('\n', asm_out_file); - fprintf (asm_out_file, "%s%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START); + dw2_asm_output_data (1, DWARF_LINE_RANGE, + "Line Range Value (Special Opcodes)"); + + dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE, + "Special Opcode Base"); - fputc ('\n', asm_out_file); for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc) { switch (opc) @@ -7074,11 +6382,9 @@ output_line_info () n_op_args = 0; break; } - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args", - ASM_COMMENT_START, opc, n_op_args); - fputc ('\n', asm_out_file); + + dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args", + opc, n_op_args); } /* Write out the information about the files we use. */ @@ -7110,44 +6416,31 @@ output_line_info () continue; #endif - /* Emit debug info for the address of the current line, choosing - the encoding that uses the least amount of space. */ - /* ??? Unfortunately, we have little choice here currently, and must - always use the most general form. Gcc does not know the address - delta itself, so we can't use DW_LNS_advance_pc. There are no known - dwarf2 aware assemblers at this time, so we can't use any special - pseudo ops that would allow the assembler to optimally encode this for - us. Many ports do have length attributes which will give an upper - bound on the address range. We could perhaps use length attributes - to determine when it is safe to use DW_LNS_fixed_advance_pc. */ + /* Emit debug info for the address of the current line. + + Unfortunately, we have little choice here currently, and must always + use the most general form. Gcc does not know the address delta + itself, so we can't use DW_LNS_advance_pc. Many ports do have length + attributes which will give an upper bound on the address range. We + could perhaps use length attributes to determine when it is safe to + use DW_LNS_fixed_advance_pc. */ + ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index); if (0) { /* This can handle deltas up to 0xffff. This takes 3 bytes. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, + "DW_LNS_fixed_advance_pc"); + dw2_asm_output_delta (2, line_label, prev_line_label, NULL); } else { /* This can handle any delta. This takes 4+DWARF2_ADDR_SIZE bytes. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + DWARF2_ADDR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_set_address"); + dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); + dw2_asm_output_data (1, DW_LNE_set_address, NULL); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, line_label, NULL); } strcpy (prev_line_label, line_label); @@ -7156,17 +6449,9 @@ output_line_info () if (line_info->dw_file_num != current_file) { current_file = line_info->dw_file_num; - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (current_file); - if (flag_debug_asm) - fprintf (asm_out_file, " (\"%s\")", - line_file_table.table[current_file]); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); + dw2_asm_output_data_uleb128 (current_file, "(\"%s\")", + line_file_table.table[current_file]); } /* Emit debug info for the current line number, choosing the encoding @@ -7181,77 +6466,44 @@ output_line_info () /* This can handle deltas from -10 to 234, using the current definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This takes 1 byte. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - DWARF_LINE_OPCODE_BASE + line_delta); - if (flag_debug_asm) - fprintf (asm_out_file, - "\t%s line %ld", ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, + "line %lu", current_line); } else { /* This can handle any delta. This takes at least 4 bytes, depending on the value being encoded. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s advance to line %ld", - ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - output_sleb128 (line_offset); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_advance_line, + "advance to line %lu", current_line); + dw2_asm_output_data_sleb128 (line_offset, NULL); + dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); } } else { /* We still need to start a new row, so output a copy insn. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); } } /* Emit debug info for the address of the end of the function. */ if (0) { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, + "DW_LNS_fixed_advance_pc"); + dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL); } else { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + DWARF2_ADDR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_set_address"); + dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); + dw2_asm_output_data (1, DW_LNE_set_address, NULL); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, text_end_label, NULL); } - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); + dw2_asm_output_data_uleb128 (1, NULL); + dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); function = 0; current_file = 1; @@ -7279,47 +6531,26 @@ output_line_info () function = line_info->function; /* Set the address register to the first line in the function */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1 + DWARF2_ADDR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_set_address"); + dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); + dw2_asm_output_data (1, DW_LNE_set_address, NULL); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, line_label, NULL); } else { /* ??? See the DW_LNS_advance_pc comment above. */ if (0) { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, - prev_line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, + "DW_LNS_fixed_advance_pc"); + dw2_asm_output_delta (2, line_label, prev_line_label, NULL); } else { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + DWARF2_ADDR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_set_address"); + dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); + dw2_asm_output_data (1, DW_LNE_set_address, NULL); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, line_label, NULL); } } strcpy (prev_line_label, line_label); @@ -7329,17 +6560,9 @@ output_line_info () if (line_info->dw_file_num != current_file) { current_file = line_info->dw_file_num; - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (current_file); - if (flag_debug_asm) - fprintf (asm_out_file, " (\"%s\")", - line_file_table.table[current_file]); - - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file"); + dw2_asm_output_data_uleb128 (current_file, "(\"%s\")", + line_file_table.table[current_file]); } /* Emit debug info for the current line number, choosing the encoding @@ -7350,39 +6573,18 @@ output_line_info () line_delta = line_offset - DWARF_LINE_BASE; current_line = line_info->dw_line_num; if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1)) - { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, - DWARF_LINE_OPCODE_BASE + line_delta); - if (flag_debug_asm) - fprintf (asm_out_file, - "\t%s line %ld", ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - } + dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta, + "line %lu", current_line); else { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s advance to line %ld", - ASM_COMMENT_START, current_line); - - fputc ('\n', asm_out_file); - output_sleb128 (line_offset); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_advance_line, + "advance to line %lu", current_line); + dw2_asm_output_data_sleb128 (line_offset, NULL); + dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); } } else - { - /* We still need to start a new row, so output a copy insn. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START); - fputc ('\n', asm_out_file); - } + dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy"); #if 0 cont: @@ -7400,47 +6602,27 @@ output_line_info () ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function); if (0) { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, - prev_line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, DW_LNS_fixed_advance_pc, + "DW_LNS_fixed_advance_pc"); + dw2_asm_output_delta (2, line_label, prev_line_label, NULL); } else { - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_set_address", - ASM_COMMENT_START); - fputc ('\n', asm_out_file); - output_uleb128 (1 + DWARF2_ADDR_SIZE); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_set_address"); + dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL); + dw2_asm_output_data (1, DW_LNE_set_address, NULL); + dw2_asm_output_offset (DWARF2_ADDR_SIZE, line_label, NULL); } /* Output the marker for the end of this sequence. */ - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0); - if (flag_debug_asm) - fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", - ASM_COMMENT_START); - - fputc ('\n', asm_out_file); - output_uleb128 (1); - fputc ('\n', asm_out_file); - ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence); - fputc ('\n', asm_out_file); + dw2_asm_output_data (1, 0, "DW_LNE_end_sequence"); + dw2_asm_output_data_uleb128 (1, NULL); + dw2_asm_output_data (1, DW_LNE_end_sequence, NULL); } } /* Output the marker for the end of the line number info. */ - ASM_OUTPUT_LABEL (asm_out_file, ".LTEND"); + ASM_OUTPUT_LABEL (asm_out_file, l2); } /* Given a pointer to a tree node for some base type, return a pointer to @@ -8617,12 +7799,28 @@ add_const_value_attribute (die, rtl) switch (GET_CODE (rtl)) { case CONST_INT: - /* Note that a CONST_INT rtx could represent either an integer or a - floating-point constant. A CONST_INT is used whenever the constant - will fit into a single word. In all such cases, the original mode - of the constant value is wiped out, and the CONST_INT rtx is - assigned VOIDmode. */ - add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl)); + /* Note that a CONST_INT rtx could represent either an integer + or a floating-point constant. A CONST_INT is used whenever + the constant will fit into a single word. In all such + cases, the original mode of the constant value is wiped + out, and the CONST_INT rtx is assigned VOIDmode. */ + { + HOST_WIDE_INT val = INTVAL (rtl); + + /* ??? We really should be using HOST_WIDE_INT throughout. */ + if (val < 0) + { + if ((long) val != val) + abort (); + add_AT_int (die, DW_AT_const_value, (long) val); + } + else + { + if ((unsigned long) val != (unsigned HOST_WIDE_INT) val) + abort (); + add_AT_int (die, DW_AT_const_value, (unsigned long) val); + } + } break; case CONST_DOUBLE: @@ -8662,8 +7860,13 @@ add_const_value_attribute (die, rtl) add_AT_float (die, DW_AT_const_value, length, array); } else - add_AT_long_long (die, DW_AT_const_value, - CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); + { + /* ??? We really should be using HOST_WIDE_INT throughout. */ + if (HOST_BITS_PER_LONG != HOST_BITS_PER_WIDE_INT) + abort (); + add_AT_long_long (die, DW_AT_const_value, + CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl)); + } } break; @@ -11692,9 +10895,8 @@ dwarf2out_line (filename, line) ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL, separate_line_info_table_in_use); if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s:%d", ASM_COMMENT_START, + fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line); - fputc ('\n', asm_out_file); /* expand the line info table if necessary */ if (separate_line_info_table_in_use @@ -11722,9 +10924,8 @@ dwarf2out_line (filename, line) ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL, line_info_table_in_use); if (flag_debug_asm) - fprintf (asm_out_file, "\t%s %s:%d", ASM_COMMENT_START, + fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START, filename, line); - fputc ('\n', asm_out_file); /* Expand the line info table if necessary. */ if (line_info_table_in_use == line_info_table_allocated) @@ -11929,18 +11130,15 @@ dwarf2out_finish () add_sibling_attributes (node->die); /* Output a terminator label for the .text section. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION); ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0); #if 0 /* Output a terminator label for the .data section. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION); ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0); /* Output a terminator label for the .bss section. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION); ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0); #endif @@ -11950,7 +11148,6 @@ dwarf2out_finish () { if (! DWARF2_ASM_LINE_DEBUG_INFO) { - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION); output_line_info (); } @@ -11979,14 +11176,12 @@ dwarf2out_finish () output_comp_unit (comp_unit_die); /* Output the abbreviation table. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION); output_abbrev_section (); if (pubname_table_in_use) { /* Output public names table. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION); output_pubnames (); } @@ -11996,7 +11191,6 @@ dwarf2out_finish () if (fde_table_in_use) { /* Output the address range information. */ - fputc ('\n', asm_out_file); ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION); output_aranges (); } -- 2.7.4