From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 21480 invoked by alias); 25 Feb 2011 13:35:15 -0000 Received: (qmail 20661 invoked by uid 22791); 25 Feb 2011 13:35:11 -0000 X-SWARE-Spam-Status: No, hits=1.4 required=5.0 tests=AWL,BAYES_99,MSGID_MULTIPLE_AT,TW_TM X-Spam-Check-By: sourceware.org Received: from mailhost.u-strasbg.fr (HELO mailhost.u-strasbg.fr) (130.79.200.157) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 25 Feb 2011 13:35:03 +0000 Received: from md1.u-strasbg.fr (md1.u-strasbg.fr [IPv6:2001:660:2402::186]) by mailhost.u-strasbg.fr (8.14.3/jtpda-5.5pre1) with ESMTP id p1PDYtK4094738 ; Fri, 25 Feb 2011 14:34:55 +0100 (CET) (envelope-from pierre.muller@ics-cnrs.unistra.fr) Received: from mailserver.u-strasbg.fr (ms4.u-strasbg.fr [130.79.204.13]) by md1.u-strasbg.fr (8.14.4/jtpda-5.5pre1) with ESMTP id p1PDYsbS096057 ; Fri, 25 Feb 2011 14:34:54 +0100 (CET) (envelope-from pierre.muller@ics-cnrs.unistra.fr) Received: from E6510Muller (gw-ics.u-strasbg.fr [130.79.210.225]) (user=mullerp mech=LOGIN) by mailserver.u-strasbg.fr (8.14.4/jtpda-5.5pre1) with ESMTP id p1PDYska059032 (version=TLSv1/SSLv3 cipher=AES128-SHA bits=128 verify=NO) ; Fri, 25 Feb 2011 14:34:54 +0100 (CET) (envelope-from pierre.muller@ics-cnrs.unistra.fr) From: "Pierre Muller" To: "'Kai Tietz'" Cc: "'H.J. Lu'" , "'Binutils'" References: <-8460070221060995487@unknownmsgid> <-6930711422310680743@unknownmsgid> <4D63D49D.90101@redhat.com> <-2339605939192327273@unknownmsgid> <-3886800211494155692@unknownmsgid> <1561346207520594884@unknownmsgid> <5095785081977025060@unknownmsgid> In-Reply-To: Subject: [RFC-v2] Use only dwarf_vma types in dwarf code Date: Fri, 25 Feb 2011 13:35:00 -0000 Message-ID: <00d601cbd4f0$c911af10$5b350d30$@muller@ics-cnrs.unistra.fr> MIME-Version: 1.0 Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: 7bit Mailing-List: contact binutils-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: binutils-owner@sourceware.org X-SW-Source: 2011-02/txt/msg00310.txt.bz2 I corrected the patch according to the remarks made before by Kai, I put again the main message of my first RFC starting here: >>>>>>>>>>>>>>>> This patch RFC is follow up of the thread concerning problems with the act that readelf defines BFD64 under other conditions than dwarf.c leading to potential problems. The idea is to completely remove bfd_vma and dwarf_signed_vma from dwarf.h and dwarf.c sources. The patch is pretty mechanical, but there are several points that probably needs discussion: 1) This basically makes use of 8-byte for dwarf_vma and dwarf_signed_vma for almost all modern machines/compilers. It could still impact performance for system where int64 computation is slow, I have no idea if this can really be a problem or not. 2) I also tried to remove (long) and (unsigned long) types whenever they seemed to me to be used for something that could be a target address or offset and replaced it by a dwarf_{signed_}vma type. (This is also related to the Mingw64 target issue for which 'long' is 4-byte whereas 'void *' is 8-byte). But I might not have caught all occurrences and might have misunderstood some other cases. An example is the address field of the Machine_State_Registers, I don't know if this relates really to a target address... Another important point is that I have no machine that can run the testsuite on my patch, so that it might very well introduce regression that I am unaware of. Anyhow, I will be pleased to get comments on this patch. Pierre Muller GDB pascal language maintainer 2011-02-25 Pierre Muller Replace bfd_vma type and analog types by dwarf_vma and analogs. Use dwarf specific print functions to display these type values. * dwarf.h (dwarf_signed_vma): New type; (DWARF2_External_LineInfo): Replace bfd_vma by dwarf_vma. (DWARF2_External_PubNames): Likewise. (DWARF2_External_CompUnit): Likewise. (DWARF2_External_ARange): Likewise. (read_leb128): Change return type to dwarf_vma. * dwarf.c (print_dwarf_vma): Use __MINGW32__ conditional and check byte_size values. (dwarf_vmatoa): Change parameter type to dwarf_vma. (dwarf_svmatoa): New static function. (read_leb128): Change return type to dwarf_vma. (read_sleb128): New static function. (struct State_Machine_Registers): Change address field type to dwarf_vma. (process_extended_line_op): Adapt to type changes. (fetch_indirect_string): Likewise. (idisplay_block): Likewise. (decode_location_expression): Likewise. (read_and_display_attr_value): Likewise. (process_debug_info): Likewise. (display_debug_lines_raw): Likewise. (display_debug_lines_decoded): Likewise. (SLEB macro): Use new read_sleb128 function. Index: binutils/dwarf.h =================================================================== RCS file: /cvs/src/src/binutils/dwarf.h,v retrieving revision 1.21 diff -u -p -r1.21 dwarf.h --- binutils/dwarf.h 23 Feb 2011 08:52:33 -0000 1.21 +++ binutils/dwarf.h 25 Feb 2011 10:12:30 -0000 @@ -20,6 +20,7 @@ MA 02110-1301, USA. */ typedef unsigned HOST_WIDEST_INT dwarf_vma; +typedef HOST_WIDEST_INT dwarf_signed_vma; typedef unsigned HOST_WIDEST_INT dwarf_size_type; /* Structure found in the .debug_line section. */ @@ -38,7 +39,7 @@ DWARF2_External_LineInfo; typedef struct { - bfd_vma li_length; + dwarf_vma li_length; unsigned short li_version; unsigned int li_prologue_length; unsigned char li_min_insn_length; @@ -62,10 +63,10 @@ DWARF2_External_PubNames; typedef struct { - bfd_vma pn_length; + dwarf_vma pn_length; unsigned short pn_version; - bfd_vma pn_offset; - bfd_vma pn_size; + dwarf_vma pn_offset; + dwarf_vma pn_size; } DWARF2_Internal_PubNames; @@ -81,9 +82,9 @@ DWARF2_External_CompUnit; typedef struct { - bfd_vma cu_length; + dwarf_vma cu_length; unsigned short cu_version; - bfd_vma cu_abbrev_offset; + dwarf_vma cu_abbrev_offset; unsigned char cu_pointer_size; } DWARF2_Internal_CompUnit; @@ -100,9 +101,9 @@ DWARF2_External_ARange; typedef struct { - bfd_vma ar_length; + dwarf_vma ar_length; unsigned short ar_version; - bfd_vma ar_info_offset; + dwarf_vma ar_info_offset; unsigned char ar_pointer_size; unsigned char ar_segment_size; } @@ -165,15 +166,15 @@ typedef struct unsigned int pointer_size; unsigned int offset_size; int dwarf_version; - bfd_vma cu_offset; - bfd_vma base_address; + dwarf_vma cu_offset; + dwarf_vma base_address; /* This is an array of offsets to the location list table. */ - bfd_vma *loc_offsets; + dwarf_vma *loc_offsets; int *have_frame_base; unsigned int num_loc_offsets; unsigned int max_loc_offsets; /* List of .debug_ranges offsets seen in this .debug_info. */ - bfd_vma *range_lists; + dwarf_vma *range_lists; unsigned int num_range_lists; unsigned int max_range_lists; } @@ -217,5 +218,5 @@ void *cmalloc (size_t, size_t); void *xcmalloc (size_t, size_t); void *xcrealloc (void *, size_t, size_t); -bfd_vma read_leb128 (unsigned char *data, +dwarf_vma read_leb128 (unsigned char *data, unsigned int *length_return, int sign); Index: binutils/dwarf.c =================================================================== RCS file: /cvs/src/src/binutils/dwarf.c,v retrieving revision 1.84 diff -u -p -r1.84 dwarf.c --- binutils/dwarf.c 23 Feb 2011 08:52:33 -0000 1.84 +++ binutils/dwarf.c 25 Feb 2011 10:12:30 -0000 @@ -106,12 +106,13 @@ static void print_dwarf_vma (dwarf_vma val, unsigned byte_size) { static char buff[18]; + int offset; /* Printf does not have a way of specifiying a maximum field width for an integer value, so we print the full value into a buffer and then select the precision we need. */ #if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2) -#ifndef __MSVCRT__ +#ifndef __MINGW32__ snprintf (buff, sizeof (buff), "%16.16llx ", val); #else snprintf (buff, sizeof (buff), "%016I64x ", val); @@ -120,11 +121,29 @@ print_dwarf_vma (dwarf_vma val, unsigned snprintf (buff, sizeof (buff), "%16.16lx ", val); #endif - fputs (buff + (byte_size == 4 ? 8 : 0), stdout); + if (byte_size == 0) + offset = 0; + else + if (byte_size > 0 && byte_size <= 8) + offset = 16 - 2 * byte_size; + else + error("Wrong size in print_dwarf_vma"); + + fputs (buff + offset, stdout); } +#if __STDC_VERSION__ >= 199901L || (defined(__GNUC__) && __GNUC__ >= 2) +#ifndef __MINGW32__ +#define DWARF_VMA_FMT "ll" +#else +#define DWARF_VMA_FMT "I64" +#endif +#else +#define DWARF_VMA_FMT "l" +#endif + static const char * -dwarf_vmatoa (const char *fmtch, bfd_vma value) +dwarf_vmatoa (const char *fmtch, dwarf_vma value) { /* As dwarf_vmatoa is used more then once in a printf call for output, we are cycling through an fixed array of pointers @@ -136,7 +155,7 @@ dwarf_vmatoa (const char *fmtch, bfd_vma char fmt[32]; char *ret; - sprintf (fmt, "%%%s%s", BFD_VMA_FMT, fmtch); + sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch); ret = buf[buf_pos++].place; buf_pos %= ARRAY_SIZE(buf); @@ -146,10 +165,35 @@ dwarf_vmatoa (const char *fmtch, bfd_vma return ret; } -bfd_vma +#if 0 +static char * +dwarf_svmatoa (const char *fmtch, dwarf_signed_vma value) +{ + /* As dwarf_vmatoa is used more then once in a printf call + for output, we are cycling through an fixed array of pointers + for return address. */ + static int buf_pos = 0; + static struct dwarf_vmatoa_buf { + char place[64]; + } buf[16]; + char fmt[32]; + char *ret; + + sprintf (fmt, "%%%s%s", DWARF_VMA_FMT, fmtch); + + ret = buf[buf_pos++].place; + buf_pos %= ARRAY_SIZE(buf); + + snprintf (ret, sizeof (buf[0].place), fmt, value); + + return ret; +} +#endif + +dwarf_vma read_leb128 (unsigned char *data, unsigned int *length_return, int sign) { - bfd_vma result = 0; + dwarf_vma result = 0; unsigned int num_read = 0; unsigned int shift = 0; unsigned char byte; @@ -159,7 +203,7 @@ read_leb128 (unsigned char *data, unsign byte = *data++; num_read++; - result |= ((bfd_vma) (byte & 0x7f)) << shift; + result |= ((dwarf_vma) (byte & 0x7f)) << shift; shift += 7; @@ -175,9 +219,16 @@ read_leb128 (unsigned char *data, unsign return result; } -typedef struct State_Machine_Registers +/* Create a signed version to avoid painful typecasts. */ +static dwarf_signed_vma +read_sleb128 (unsigned char *data, unsigned int *length_return) +{ + return (dwarf_signed_vma) read_leb128 (data, length_return, 1); +} + + typedef struct State_Machine_Registers { - unsigned long address; + dwarf_vma address; unsigned int file; unsigned int line; unsigned int column; @@ -216,7 +267,7 @@ process_extended_line_op (unsigned char unsigned int bytes_read; unsigned int len; unsigned char *name; - bfd_vma adr; + dwarf_vma adr; len = read_leb128 (data, & bytes_read, 0); data += bytes_read; @@ -253,19 +304,17 @@ process_extended_line_op (unsigned char printf (" %d\t", ++state_machine_regs.last_file_entry); name = data; data += strlen ((char *) data) + 1; - printf ("%" BFD_VMA_FMT "u\t", read_leb128 (data, & bytes_read, 0)); + printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); data += bytes_read; - printf ("%" BFD_VMA_FMT "u\t", - read_leb128 (data, & bytes_read, 0)); + printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); data += bytes_read; - printf ("%" BFD_VMA_FMT "u\t", read_leb128 (data, & bytes_read, 0)); + printf ("%s\t", dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); printf ("%s\n\n", name); break; case DW_LNE_set_discriminator: printf (_("set Discriminator to %s\n"), - dwarf_vmatoa ("u", - read_leb128 (data, & bytes_read, 0))); + dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); break; /* HP extensions. */ @@ -316,7 +365,7 @@ process_extended_line_op (unsigned char } static const char * -fetch_indirect_string (bfd_vma offset) +fetch_indirect_string (dwarf_vma offset) { struct dwarf_section *section = &debug_displays [str].section; @@ -327,7 +376,8 @@ fetch_indirect_string (bfd_vma offset) offset -= section->address; if (offset > section->size) { - warn (_("DW_FORM_strp offset too big: %lx\n"), (long) offset); + warn (_("DW_FORM_strp offset too big: %s\n"), + dwarf_vmatoa ("x", offset)); return _(""); } @@ -615,9 +665,9 @@ get_FORM_name (unsigned long form) } static unsigned char * -display_block (unsigned char *data, unsigned long length) +display_block (unsigned char *data, dwarf_vma length) { - printf (_(" %lu byte block: "), length); + printf (_(" %s byte block: "), dwarf_vmatoa ("u", length)); while (length --) printf ("%lx ", (unsigned long) byte_get (data++, 1)); @@ -630,13 +680,13 @@ decode_location_expression (unsigned cha unsigned int pointer_size, unsigned int offset_size, int dwarf_version, - bfd_vma length, - bfd_vma cu_offset, + dwarf_vma length, + dwarf_vma cu_offset, struct dwarf_section * section) { unsigned op; unsigned int bytes_read; - bfd_vma uvalue; + dwarf_vma uvalue; unsigned char *end = data + length; int need_frame_base = 0; @@ -687,13 +737,13 @@ decode_location_expression (unsigned cha data += 8; break; case DW_OP_constu: - printf ("DW_OP_constu: %" BFD_VMA_FMT "u", - read_leb128 (data, &bytes_read, 0)); + printf ("DW_OP_constu: %s", + dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0))); data += bytes_read; break; case DW_OP_consts: - printf ("DW_OP_consts: %" BFD_VMA_FMT "d", - read_leb128 (data, &bytes_read, 1)); + printf ("DW_OP_consts: %s", + dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read))); data += bytes_read; break; case DW_OP_dup: @@ -748,8 +798,8 @@ decode_location_expression (unsigned cha printf ("DW_OP_plus"); break; case DW_OP_plus_uconst: - printf ("DW_OP_plus_uconst: %" BFD_VMA_FMT "u", - read_leb128 (data, &bytes_read, 0)); + printf ("DW_OP_plus_uconst: %s", + dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0))); data += bytes_read; break; case DW_OP_shl: @@ -894,36 +944,37 @@ decode_location_expression (unsigned cha case DW_OP_breg29: case DW_OP_breg30: case DW_OP_breg31: - printf ("DW_OP_breg%d (%s): %" BFD_VMA_FMT "d", + printf ("DW_OP_breg%d (%s): %s", op - DW_OP_breg0, regname (op - DW_OP_breg0, 1), - read_leb128 (data, &bytes_read, 1)); + dwarf_vmatoa ("d", (dwarf_signed_vma) + read_leb128 (data, &bytes_read, 1))); data += bytes_read; break; case DW_OP_regx: uvalue = read_leb128 (data, &bytes_read, 0); data += bytes_read; - printf ("DW_OP_regx: %" BFD_VMA_FMT "u (%s)", - uvalue, regname (uvalue, 1)); + printf ("DW_OP_regx: %s (%s)", + dwarf_vmatoa ("u", uvalue), regname (uvalue, 1)); break; case DW_OP_fbreg: need_frame_base = 1; - printf ("DW_OP_fbreg: %" BFD_VMA_FMT "d", - read_leb128 (data, &bytes_read, 1)); + printf ("DW_OP_fbreg: %s", + dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read))); data += bytes_read; break; case DW_OP_bregx: uvalue = read_leb128 (data, &bytes_read, 0); data += bytes_read; - printf ("DW_OP_bregx: %" BFD_VMA_FMT "u (%s) %" BFD_VMA_FMT "d", - uvalue, regname (uvalue, 1), - read_leb128 (data, &bytes_read, 1)); + printf ("DW_OP_bregx: %s (%s) %s", + dwarf_vmatoa ("u", uvalue), regname (uvalue, 1), + dwarf_vmatoa ("d", read_sleb128 (data, &bytes_read))); data += bytes_read; break; case DW_OP_piece: - printf ("DW_OP_piece: %" BFD_VMA_FMT "u", - read_leb128 (data, &bytes_read, 0)); + printf ("DW_OP_piece: %s", + dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0))); data += bytes_read; break; case DW_OP_deref_size: @@ -943,15 +994,17 @@ decode_location_expression (unsigned cha case DW_OP_call2: /* XXX: Strictly speaking for 64-bit DWARF3 files this ought to be an 8-byte wide computation. */ - printf ("DW_OP_call2: <0x%" BFD_VMA_FMT "x>", - (bfd_signed_vma) byte_get (data, 2) + cu_offset); + printf ("DW_OP_call2: <0x%s>", + dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 2) + + cu_offset)); data += 2; break; case DW_OP_call4: /* XXX: Strictly speaking for 64-bit DWARF3 files this ought to be an 8-byte wide computation. */ - printf ("DW_OP_call4: <0x%" BFD_VMA_FMT "x>", - (bfd_signed_vma) byte_get (data, 4) + cu_offset); + printf ("DW_OP_call4: <0x%s>", + dwarf_vmatoa ("x", (dwarf_signed_vma) byte_get (data, 4) + + cu_offset)); data += 4; break; case DW_OP_call_ref: @@ -965,14 +1018,14 @@ decode_location_expression (unsigned cha } if (dwarf_version == 2) { - printf ("DW_OP_call_ref: <0x%lx>", - (long) byte_get (data, pointer_size)); + printf ("DW_OP_call_ref: <0x%s>", + dwarf_vmatoa ("x", byte_get (data, pointer_size))); data += pointer_size; } else { - printf ("DW_OP_call_ref: <0x%lx>", - (long) byte_get (data, offset_size)); + printf ("DW_OP_call_ref: <0x%s>", + dwarf_vmatoa ("x", byte_get (data, offset_size))); data += offset_size; } break; @@ -984,11 +1037,11 @@ decode_location_expression (unsigned cha break; case DW_OP_bit_piece: printf ("DW_OP_bit_piece: "); - printf ("size: %" BFD_VMA_FMT "u ", - read_leb128 (data, &bytes_read, 0)); + printf ("size: %s ", + dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0))); data += bytes_read; - printf ("offset: %" BFD_VMA_FMT "u ", - read_leb128 (data, &bytes_read, 0)); + printf ("offset: %s ", + dwarf_vmatoa ("u", read_leb128 (data, &bytes_read, 0))); data += bytes_read; break; @@ -1037,20 +1090,18 @@ decode_location_expression (unsigned cha } if (dwarf_version == 2) { - printf ("DW_OP_GNU_implicit_pointer: " - "<0x%" BFD_VMA_FMT "x> %" BFD_VMA_FMT "d", - (bfd_vma) byte_get (data, pointer_size), - (bfd_signed_vma) read_leb128 (data + pointer_size, - &bytes_read, 1)); + printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s", + dwarf_vmatoa ("x", byte_get (data, pointer_size)), + dwarf_vmatoa ("d", read_sleb128 (data + pointer_size, + &bytes_read))); data += pointer_size + bytes_read; } else { - printf ("DW_OP_GNU_implicit_pointer: " - "<0x%" BFD_VMA_FMT "x> %" BFD_VMA_FMT "d", - (bfd_vma) byte_get (data, offset_size), - (bfd_signed_vma) read_leb128 (data + offset_size, - &bytes_read, 1)); + printf ("DW_OP_GNU_implicit_pointer: <0x%s> %s", + dwarf_vmatoa ("x", byte_get (data, offset_size)), + dwarf_vmatoa ("d", read_sleb128 (data + offset_size, + &bytes_read))); data += offset_size + bytes_read; } break; @@ -1112,15 +1163,15 @@ static unsigned char * read_and_display_attr_value (unsigned long attribute, unsigned long form, unsigned char * data, - bfd_vma cu_offset, - bfd_vma pointer_size, - bfd_vma offset_size, + dwarf_vma cu_offset, + dwarf_vma pointer_size, + dwarf_vma offset_size, int dwarf_version, debug_info * debug_info_p, int do_loc, struct dwarf_section * section) { - bfd_vma uvalue = 0; + dwarf_vma uvalue = 0; unsigned char *block_start = NULL; unsigned char * orig_data = data; unsigned int bytes_read; @@ -1207,7 +1258,7 @@ read_and_display_attr_value (unsigned lo { case DW_FORM_ref_addr: if (!do_loc) - printf (" <0x%" BFD_VMA_FMT "x>", uvalue); + printf (" <0x%s>", dwarf_vmatoa ("x",uvalue)); break; case DW_FORM_ref1: @@ -1215,14 +1266,14 @@ read_and_display_attr_value (unsigned lo case DW_FORM_ref4: case DW_FORM_ref_udata: if (!do_loc) - printf (" <0x%" BFD_VMA_FMT "x>", uvalue + cu_offset); + printf (" <0x%s>", dwarf_vmatoa ("x", uvalue + cu_offset)); break; case DW_FORM_data4: case DW_FORM_addr: case DW_FORM_sec_offset: if (!do_loc) - printf (" 0x%" BFD_VMA_FMT "x", uvalue); + printf (" 0x%s", dwarf_vmatoa ("x", uvalue)); break; case DW_FORM_flag_present: @@ -1232,7 +1283,7 @@ read_and_display_attr_value (unsigned lo case DW_FORM_sdata: case DW_FORM_udata: if (!do_loc) - printf (" %" BFD_VMA_FMT "d", uvalue); + printf (" %s", dwarf_vmatoa ("d", uvalue)); break; case DW_FORM_ref8: @@ -1240,7 +1291,7 @@ read_and_display_attr_value (unsigned lo if (!do_loc) { uvalue = byte_get (data, 4); - printf (" 0x%" BFD_VMA_FMT "x", uvalue); + printf (" 0x%s", dwarf_vmatoa ("x", uvalue)); printf (" 0x%lx", (unsigned long) byte_get (data + 4, 4)); } if ((do_loc || do_debug_loc || do_debug_ranges) @@ -1249,7 +1300,7 @@ read_and_display_attr_value (unsigned lo if (sizeof (uvalue) == 8) uvalue = byte_get (data, 8); else - error (_("DW_FORM_data8 is unsupported when sizeof (bfd_vma) != 8\n")); + error (_("DW_FORM_data8 is unsupported when sizeof (dwarf_vma) != 8\n")); } data += 8; break; @@ -1354,7 +1405,7 @@ read_and_display_attr_value (unsigned lo if (lmax == 0 || num >= lmax) { lmax += 1024; - debug_info_p->loc_offsets = (bfd_vma *) + debug_info_p->loc_offsets = (dwarf_vma *) xcrealloc (debug_info_p->loc_offsets, lmax, sizeof (*debug_info_p->loc_offsets)); debug_info_p->have_frame_base = (int *) @@ -1385,7 +1436,7 @@ read_and_display_attr_value (unsigned lo if (lmax == 0 || num >= lmax) { lmax += 1024; - debug_info_p->range_lists = (bfd_vma *) + debug_info_p->range_lists = (dwarf_vma *) xcrealloc (debug_info_p->range_lists, lmax, sizeof (*debug_info_p->range_lists)); debug_info_p->max_range_lists = lmax; @@ -1463,9 +1514,10 @@ read_and_display_attr_value (unsigned lo case DW_LANG_Upc: printf ("(Unified Parallel C)"); break; default: if (uvalue >= DW_LANG_lo_user && uvalue <= DW_LANG_hi_user) - printf ("(implementation defined: %" BFD_VMA_FMT "x)", uvalue); + printf ("(implementation defined: %s)", + dwarf_vmatoa ("x", uvalue)); else - printf ("(Unknown: %" BFD_VMA_FMT "x)", uvalue); + printf ("(Unknown: %s)", dwarf_vmatoa("x", uvalue)); break; } break; @@ -1829,9 +1881,9 @@ static unsigned char * read_and_display_attr (unsigned long attribute, unsigned long form, unsigned char * data, - bfd_vma cu_offset, - bfd_vma pointer_size, - bfd_vma offset_size, + dwarf_vma cu_offset, + dwarf_vma pointer_size, + dwarf_vma offset_size, int dwarf_version, debug_info * debug_info_p, int do_loc, @@ -1943,7 +1995,7 @@ process_debug_info (struct dwarf_section unsigned char *hdrptr; unsigned char *tags; int level; - bfd_vma cu_offset; + dwarf_vma cu_offset; int offset_size; int initial_length_size; unsigned char signature[8] = { 0 }; @@ -2378,14 +2430,14 @@ display_debug_lines_raw (struct dwarf_se data += strlen ((char *) data) + 1; - printf ("%" BFD_VMA_FMT "u\t", - read_leb128 (data, & bytes_read, 0)); + printf ("%s\t", + dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); data += bytes_read; - printf ("%" BFD_VMA_FMT "u\t", - read_leb128 (data, & bytes_read, 0)); + printf ("%s\t", + dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); data += bytes_read; - printf ("%" BFD_VMA_FMT "u\t", - read_leb128 (data, & bytes_read, 0)); + printf ("%s\t", + dwarf_vmatoa ("u", read_leb128 (data, & bytes_read, 0))); data += bytes_read; printf ("%s\n", name); } @@ -2400,8 +2452,8 @@ display_debug_lines_raw (struct dwarf_se while (data < end_of_sequence) { unsigned char op_code; - int adv; - unsigned long int uladv; + dwarf_signed_vma adv; + dwarf_vma uladv; unsigned int bytes_read; op_code = *data++; @@ -2414,8 +2466,10 @@ display_debug_lines_raw (struct dwarf_se { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; - printf (_(" Special opcode %d: advance Address by %lu to 0x%lx"), - op_code, uladv, state_machine_regs.address); + printf (_(" Special opcode %d: " + "advance Address by %s to 0x%s"), + op_code, dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address)); } else { @@ -2426,14 +2480,16 @@ display_debug_lines_raw (struct dwarf_se state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; - printf (_(" Special opcode %d: advance Address by %lu to 0x%lx[%d]"), - op_code, uladv, state_machine_regs.address, + printf (_(" Special opcode %d: " + "advance Address by %s to 0x%s[%d]"), + op_code, dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address), state_machine_regs.op_index); } adv = (op_code % linfo.li_line_range) + linfo.li_line_base; state_machine_regs.line += adv; - printf (_(" and Line by %d to %d\n"), - adv, state_machine_regs.line); + printf (_(" and Line by %s to %d\n"), + dwarf_vmatoa ("d", adv), state_machine_regs.line); } else switch (op_code) { @@ -2452,8 +2508,9 @@ display_debug_lines_raw (struct dwarf_se { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; - printf (_(" Advance PC by %lu to 0x%lx\n"), uladv, - state_machine_regs.address); + printf (_(" Advance PC by %s to 0x%s\n"), + dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address)); } else { @@ -2464,39 +2521,42 @@ display_debug_lines_raw (struct dwarf_se state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; - printf (_(" Advance PC by %lu to 0x%lx[%d]\n"), uladv, - state_machine_regs.address, + printf (_(" Advance PC by %s to 0x%s[%d]\n"), + dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address), state_machine_regs.op_index); } break; case DW_LNS_advance_line: - adv = read_leb128 (data, & bytes_read, 1); + adv = read_sleb128 (data, & bytes_read); data += bytes_read; state_machine_regs.line += adv; - printf (_(" Advance Line by %d to %d\n"), adv, - state_machine_regs.line); + printf (_(" Advance Line by %s to %d\n"), + dwarf_vmatoa ("d", adv), + state_machine_regs.line); break; case DW_LNS_set_file: adv = read_leb128 (data, & bytes_read, 0); data += bytes_read; - printf (_(" Set File Name to entry %d in the File Name Table\n"), - adv); + printf (_(" Set File Name to entry %s in the File Name Table\n"), + dwarf_vmatoa ("d", adv)); state_machine_regs.file = adv; break; case DW_LNS_set_column: uladv = read_leb128 (data, & bytes_read, 0); data += bytes_read; - printf (_(" Set column to %lu\n"), uladv); + printf (_(" Set column to %s\n"), + dwarf_vmatoa ("u", uladv)); state_machine_regs.column = uladv; break; case DW_LNS_negate_stmt: adv = state_machine_regs.is_stmt; adv = ! adv; - printf (_(" Set is_stmt to %d\n"), adv); + printf (_(" Set is_stmt to %s\n"), dwarf_vmatoa("d", adv)); state_machine_regs.is_stmt = adv; break; @@ -2511,8 +2571,9 @@ display_debug_lines_raw (struct dwarf_se { uladv *= linfo.li_min_insn_length; state_machine_regs.address += uladv; - printf (_(" Advance PC by constant %lu to 0x%lx\n"), uladv, - state_machine_regs.address); + printf (_(" Advance PC by constant %s to 0x%s\n"), + dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address)); } else { @@ -2523,8 +2584,9 @@ display_debug_lines_raw (struct dwarf_se state_machine_regs.op_index = (state_machine_regs.op_index + uladv) % linfo.li_max_ops_per_insn; - printf (_(" Advance PC by constant %lu to 0x%lx[%d]\n"), - uladv, state_machine_regs.address, + printf (_(" Advance PC by constant %s to 0x%s[%d]\n"), + dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address), state_machine_regs.op_index); } break; @@ -2534,8 +2596,9 @@ display_debug_lines_raw (struct dwarf_se data += 2; state_machine_regs.address += uladv; state_machine_regs.op_index = 0; - printf (_(" Advance PC by fixed size amount %lu to 0x%lx\n"), - uladv, state_machine_regs.address); + printf (_(" Advance PC by fixed size amount %s to 0x%s\n"), + dwarf_vmatoa ("u", uladv), + dwarf_vmatoa ("x", state_machine_regs.address)); break; case DW_LNS_set_prologue_end: @@ -2549,7 +2612,7 @@ display_debug_lines_raw (struct dwarf_se case DW_LNS_set_isa: uladv = read_leb128 (data, & bytes_read, 0); data += bytes_read; - printf (_(" Set ISA to %lu\n"), uladv); + printf (_(" Set ISA to %s\n"), dwarf_vmatoa ("u", uladv)); break; default: @@ -2557,8 +2620,8 @@ display_debug_lines_raw (struct dwarf_se for (i = standard_opcodes[op_code - 1]; i > 0 ; --i) { - printf ("0x%" BFD_VMA_FMT "x%s", - read_leb128 (data, &bytes_read, 0), + printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data, + &bytes_read, 0)), i == 1 ? "" : ", "); data += bytes_read; } @@ -2888,7 +2951,7 @@ display_debug_lines_decoded (struct dwar break; case DW_LNS_advance_line: - adv = read_leb128 (data, & bytes_read, 1); + adv = read_sleb128 (data, & bytes_read); data += bytes_read; state_machine_regs.line += adv; break; @@ -2971,8 +3034,8 @@ display_debug_lines_decoded (struct dwar for (i = standard_opcodes[op_code - 1]; i > 0 ; --i) { - printf ("0x%" BFD_VMA_FMT "x%s", - read_leb128 (data, &bytes_read, 0), + printf ("0x%s%s", dwarf_vmatoa ("x", read_leb128 (data, + &bytes_read, 0)), i == 1 ? "" : ", "); data += bytes_read; } @@ -3007,24 +3070,24 @@ display_debug_lines_decoded (struct dwar if (!do_wide || (fileNameLength <= MAX_FILENAME_LENGTH)) { if (linfo.li_max_ops_per_insn == 1) - printf ("%-35s %11d %#18lx\n", newFileName, - state_machine_regs.line, + printf ("%-35s %11d %#18" DWARF_VMA_FMT "x\n", + newFileName, state_machine_regs.line, state_machine_regs.address); else - printf ("%-35s %11d %#18lx[%d]\n", newFileName, - state_machine_regs.line, + printf ("%-35s %11d %#18" DWARF_VMA_FMT "x[%d]\n", + newFileName, state_machine_regs.line, state_machine_regs.address, state_machine_regs.op_index); } else { if (linfo.li_max_ops_per_insn == 1) - printf ("%s %11d %#18lx\n", newFileName, - state_machine_regs.line, + printf ("%s %11d %#18" DWARF_VMA_FMT "x\n", + newFileName, state_machine_regs.line, state_machine_regs.address); else - printf ("%s %11d %#18lx[%d]\n", newFileName, - state_machine_regs.line, + printf ("%s %11d %#18" DWARF_VMA_FMT "x[%d]\n", + newFileName, state_machine_regs.line, state_machine_regs.address, state_machine_regs.op_index); } @@ -4110,7 +4173,7 @@ frame_display_row (Frame_Chunk *fc, int #define GET(N) byte_get (start, N); start += N #define LEB() read_leb128 (start, & length_return, 0); start += length_return -#define SLEB() read_leb128 (start, & length_return, 1); start += length_return +#define SLEB() read_sleb128 (start, & length_return); start += length_return static int display_debug_frames (struct dwarf_section *section,