This is the mail archive of the elfutils-devel@sourceware.org mailing list for the elfutils project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[PATCH][V2] Change calling convention of dwarf_getmacros to allow opcode 0xff


The previous patch kept one extra bit for destinguishing .debug_macro
from .debug_macinfo iteration.  That was a left-over from the first
proposals and it really makes no sense to keep that as a separate bit
now.  Drop it, deduce the information from available context.

Thanks,
Petr

----8<----------------------------------------------------------------

We now require callers to pass DWARF_GETMACROS_START to start the
iteration.  0 is still accepted, but signals to libdw that the
iteration request comes from an old-style caller, and that opcode 0xff
should be rejected when iterating .debug_macro, to avoid confusion.

Signed-off-by: Petr Machata <pmachata@redhat.com>
---
 NEWS                           |   2 -
 libdw/ChangeLog                |   7 ++
 libdw/dwarf_getmacros.c        | 157 +++++++++++++++++++++++------------------
 libdw/libdw.h                  |  40 ++++++-----
 tests/ChangeLog                |  10 +++
 tests/dwarf-getmacros.c        |  27 +++++--
 tests/run-dwarf-getmacros.sh   |  11 +++
 tests/testfile-macros-0xff.bz2 | Bin 0 -> 2844 bytes
 tests/testfile-macros-0xff.s   | 153 +++++++++++++++++++++++++++++++++++++++
 9 files changed, 314 insertions(+), 93 deletions(-)
 create mode 100755 tests/testfile-macros-0xff.bz2
 create mode 100644 tests/testfile-macros-0xff.s

diff --git a/NEWS b/NEWS
index 8f0780b..a7ead0a 100644
--- a/NEWS
+++ b/NEWS
@@ -8,8 +8,6 @@ libdw: New function dwarf_peel_type. dwarf_aggregate_size now uses
        dwarf_macro_getparamcnt, and dwarf_macro_param are available
        for more generalized inspection of macros and their parameters.
 
-XXX: Fix serving of 0xff based on what ends up in Dwarf 5.
-
 Version 0.160
 
 libdw: New functions dwarf_cu_getdwarf, dwarf_cu_die.
diff --git a/libdw/ChangeLog b/libdw/ChangeLog
index 37f94df..7129eab 100644
--- a/libdw/ChangeLog
+++ b/libdw/ChangeLog
@@ -1,3 +1,10 @@
+2014-12-02  Petr Machata  <pmachata@redhat.com>
+
+	* dwarf_getmacros.c (token_from_offset, offset_from_token): New
+	helper functions.
+	(do_dwarf_getmacros_die): Merge into dwarf_getmacros.
+	* libdw.h (DWARF_GETMACROS_START): New macro.
+
 2014-11-24  Mark Wielaard  <mjw@redhat.com>
 
 	* dwarf_getsrclines.c (read_srclines): Check line_range is not zero
diff --git a/libdw/dwarf_getmacros.c b/libdw/dwarf_getmacros.c
index 8d9d78b..0ba3854 100644
--- a/libdw/dwarf_getmacros.c
+++ b/libdw/dwarf_getmacros.c
@@ -384,13 +384,53 @@ read_macros (Dwarf *dbg, int sec_index,
   return 0;
 }
 
+/* Token layout:
+
+   - The highest bit is used for distinguishing between callers that
+     know that opcode 0xff may have one of two incompatible meanings.
+     The mask that we use for selecting this bit is
+     DWARF_GETMACROS_START.
+
+   - The rest of the token (31 or 63 bits) encodes address inside the
+     macro unit.
+
+   Besides, token value of 0 signals end of iteration and -1 is
+   reserved for signaling errors.  That means it's impossible to
+   represent maximum offset of a .debug_macro unit to new-style
+   callers (which in practice decreases the permissible macro unit
+   size by another 1 byte).  */
+
+static ptrdiff_t
+token_from_offset (ptrdiff_t offset, bool accept_0xff)
+{
+  if (offset == -1 || offset == 0)
+    return offset;
+
+  /* Make sure the offset didn't overflow into the flag bit.  */
+  assert ((offset & DWARF_GETMACROS_START) == 0);
+
+  if (accept_0xff)
+    offset |= DWARF_GETMACROS_START;
+
+  return offset;
+}
+
+static ptrdiff_t
+offset_from_token (ptrdiff_t token, bool *accept_0xffp)
+{
+  *accept_0xffp = (token & DWARF_GETMACROS_START) != 0;
+  token &= ~DWARF_GETMACROS_START;
+
+  return token;
+}
+
 static ptrdiff_t
 gnu_macros_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
 			  int (*callback) (Dwarf_Macro *, void *),
-			  void *arg, ptrdiff_t token, bool accept_0xff,
+			  void *arg, ptrdiff_t offset, bool accept_0xff,
 			  Dwarf_Die *cudie)
 {
-  assert (token <= 0);
+  assert (offset >= 0);
 
   if (macoff >= dbg->sectiondata[IDX_debug_macro]->d_size)
     {
@@ -398,23 +438,19 @@ gnu_macros_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
       return -1;
     }
 
-  ptrdiff_t ret = read_macros (dbg, IDX_debug_macro, macoff,
-			       callback, arg, -token, accept_0xff, cudie);
-  if (ret == -1)
-    return -1;
-  else
-    return -ret;
+  return read_macros (dbg, IDX_debug_macro, macoff,
+		      callback, arg, offset, accept_0xff, cudie);
 }
 
 static ptrdiff_t
 macro_info_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
 			  int (*callback) (Dwarf_Macro *, void *),
-			  void *arg, ptrdiff_t token, Dwarf_Die *cudie)
+			  void *arg, ptrdiff_t offset, Dwarf_Die *cudie)
 {
-  assert (token >= 0);
+  assert (offset >= 0);
 
   return read_macros (dbg, IDX_debug_macinfo, macoff,
-		      callback, arg, token, true, cudie);
+		      callback, arg, offset, true, cudie);
 }
 
 ptrdiff_t
@@ -428,21 +464,22 @@ dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
       return -1;
     }
 
-  /* We use token values > 0 for iteration through .debug_macinfo and
-     values < 0 for iteration through .debug_macro.  Return value of
-     -1 also signifies an error, but that's fine, because .debug_macro
-     always contains at least three bytes of headers and after
-     iterating one opcode, we should never see anything above -4.  */
-  assert (token <= 0);
+  bool accept_0xff;
+  ptrdiff_t offset = offset_from_token (token, &accept_0xff);
+  assert (accept_0xff);
+
+  offset = gnu_macros_getmacros_off (dbg, macoff, callback, arg, offset,
+				     accept_0xff, NULL);
 
-  return gnu_macros_getmacros_off (dbg, macoff, callback, arg, token, true,
-				   NULL);
+  return token_from_offset (offset, accept_0xff);
 }
 
-static ptrdiff_t
-do_dwarf_getmacros_die (Dwarf_Die *cudie, Dwarf_Off *macoffp,
-			int (*callback) (Dwarf_Macro *, void *),
-			void *arg, ptrdiff_t token, bool accept_0xff)
+ptrdiff_t
+dwarf_getmacros (cudie, callback, arg, token)
+     Dwarf_Die *cudie;
+     int (*callback) (Dwarf_Macro *, void *);
+     void *arg;
+     ptrdiff_t token;
 {
   if (cudie == NULL)
     {
@@ -450,50 +487,6 @@ do_dwarf_getmacros_die (Dwarf_Die *cudie, Dwarf_Off *macoffp,
       return -1;
     }
 
-  if (token > 0 && macoffp != NULL)
-    /* A continuation call from DW_AT_macro_info iteration, meaning
-       *MACOFF contains previously-cached offset.  */
-    return macro_info_getmacros_off (cudie->cu->dbg, *macoffp,
-				     callback, arg, token, cudie);
-
-  /* A fresh start of DW_AT_macro_info iteration, or a continuation
-     thereof without a cache.  */
-  if (token > 0
-      || (token == 0 && dwarf_hasattr (cudie, DW_AT_macro_info)))
-    {
-      Dwarf_Word macoff;
-      if (macoffp == NULL)
-	macoffp = &macoff;
-      if (get_offset_from (cudie, DW_AT_macro_info, macoffp) != 0)
-	return -1;
-      return macro_info_getmacros_off (cudie->cu->dbg, *macoffp,
-				       callback, arg, token, cudie);
-    }
-
-  if (token < 0 && macoffp != NULL)
-    /* A continuation call from DW_AT_GNU_macros iteration.  */
-    return gnu_macros_getmacros_off (cudie->cu->dbg, *macoffp,
-				     callback, arg, token, accept_0xff,
-				     cudie);
-
-  /* Likewise without cache, or iteration start.  */
-  Dwarf_Word macoff;
-  if (macoffp == NULL)
-    macoffp = &macoff;
-  if (get_offset_from (cudie, DW_AT_GNU_macros, macoffp) != 0)
-    return -1;
-  return gnu_macros_getmacros_off (cudie->cu->dbg, *macoffp,
-				   callback, arg, token, accept_0xff,
-				   cudie);
-}
-
-ptrdiff_t
-dwarf_getmacros (die, callback, arg, offset)
-     Dwarf_Die *die;
-     int (*callback) (Dwarf_Macro *, void *);
-     void *arg;
-     ptrdiff_t offset;
-{
   /* This function might be called from a code that expects to see
      DW_MACINFO_* opcodes, not DW_MACRO_{GNU_,}* ones.  It is fine to
      serve most DW_MACRO_{GNU_,}* opcodes to such code, because those
@@ -511,7 +504,33 @@ dwarf_getmacros (die, callback, arg, offset)
      some small probability that the two opcodes would look
      superficially similar enough that a client would be confused and
      misbehave as a result.  For this reason, we refuse to serve
-     through this interface 0xff's originating from .debug_macro.  */
+     through this interface 0xff's originating from .debug_macro
+     unless the TOKEN that we obtained indicates the call originates
+     from a new-style caller.  See above for details on what
+     information is encoded into tokens.  */
+
+  bool accept_0xff;
+  ptrdiff_t offset = offset_from_token (token, &accept_0xff);
+
+  /* DW_AT_macro_info */
+  if (dwarf_hasattr (cudie, DW_AT_macro_info))
+    {
+      Dwarf_Word macoff;
+      if (get_offset_from (cudie, DW_AT_macro_info, &macoff) != 0)
+	return -1;
+      offset = macro_info_getmacros_off (cudie->cu->dbg, macoff,
+					 callback, arg, offset, cudie);
+    }
+  else
+    {
+      /* DW_AT_GNU_macros, DW_AT_macros */
+      Dwarf_Word macoff;
+      if (get_offset_from (cudie, DW_AT_GNU_macros, &macoff) != 0)
+	return -1;
+      offset = gnu_macros_getmacros_off (cudie->cu->dbg, macoff,
+					 callback, arg, offset, accept_0xff,
+					 cudie);
+    }
 
-  return do_dwarf_getmacros_die (die, NULL, callback, arg, offset, false);
+  return token_from_offset (offset, accept_0xff);
 }
diff --git a/libdw/libdw.h b/libdw/libdw.h
index c0baa21..b2b2282 100644
--- a/libdw/libdw.h
+++ b/libdw/libdw.h
@@ -32,6 +32,7 @@
 #include <gelf.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
 
 
 #if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)
@@ -845,22 +846,24 @@ extern int dwarf_entry_breakpoints (Dwarf_Die *die, Dwarf_Addr **bkpts);
 
 
 /* Iterate through the macro unit referenced by CUDIE and call
-   CALLBACK for each macro information entry.  Keeps iterating while
-   CALLBACK returns DWARF_CB_OK.  If the callback returns
-   DWARF_CB_ABORT, it stops iterating and returns a continuation
-   token, which can be used to restart the iteration at the point
-   where it ended.  A TOKEN of 0 starts the iteration.  Returns -1 for
-   errors or 0 if there are no more macro entries.
+   CALLBACK for each macro information entry.  To start the iteration,
+   one would pass DWARF_GETMACROS_START for TOKEN.
+
+   The iteration continues while CALLBACK returns DWARF_CB_OK.  If the
+   callback returns DWARF_CB_ABORT, the iteration stops and a
+   continuation token is returned, which can be used to restart the
+   iteration at the point where it ended.  Returns -1 for errors or 0
+   if there are no more macro entries.
 
    Note that the Dwarf_Macro pointer passed to the callback is only
    valid for the duration of the callback invocation.
 
-   Note that this interface will refuse to serve opcode 0xff from
-   .debug_macro sections.  Such opcode is considered invalid and will
-   cause dwarf_getmacros to return with error.  Note that this should
-   be no limitation as of now, as DW_MACRO_GNU_* domain doesn't
-   allocate 0xff.  It is however a theoretical possibility with future
-   Dwarf standards.  */
+   For backward compatibility, a token of 0 is accepted for starting
+   the iteration as well, but in that case this interface will refuse
+   to serve opcode 0xff from .debug_macro sections.  Such opcode would
+   be considered invalid and would cause dwarf_getmacros to return
+   with error.  */
+#define DWARF_GETMACROS_START PTRDIFF_MIN
 extern ptrdiff_t dwarf_getmacros (Dwarf_Die *cudie,
 				  int (*callback) (Dwarf_Macro *, void *),
 				  void *arg, ptrdiff_t token)
@@ -871,13 +874,16 @@ extern ptrdiff_t dwarf_getmacros (Dwarf_Die *cudie,
    iterates .debug_macro.  This can be used for handling
    DW_MACRO_GNU_transparent_include's or similar opcodes.
 
+   TOKEN value of DWARF_GETMACROS_START can be used to start the
+   iteration.
+
    It is not appropriate to obtain macro unit offset by hand from a CU
    DIE and then request iteration through this interface.  The reason
    for this is that if a dwarf_macro_getsrcfiles is later called,
    there would be no way to figure out what DW_AT_comp_dir was present
    on the CU DIE, and file names referenced in either the macro unit
    itself, or the .debug_line unit that it references, might be wrong.
-   Use dwarf_getmacro.  */
+   Use dwarf_getmacros.  */
 extern ptrdiff_t dwarf_getmacros_off (Dwarf *dbg, Dwarf_Off macoff,
 				      int (*callback) (Dwarf_Macro *, void *),
 				      void *arg, ptrdiff_t token)
@@ -895,9 +901,11 @@ extern int dwarf_macro_getsrcfiles (Dwarf *dbg, Dwarf_Macro *macro,
 /* Return macro opcode.  That's a constant that can be either from
    DW_MACINFO_* domain or DW_MACRO_GNU_* domain.  The two domains have
    compatible values, so it's OK to use either of them for
-   comparisons.  The only differences is 0xff, which currently is
-   never served from .debug_macro, and can thus be safely assumed to
-   mean DW_MACINFO_vendor_ext.  */
+   comparisons.  The only differences is 0xff, which could be either
+   DW_MACINFO_vendor_ext or a vendor-defined DW_MACRO_* constant.  One
+   would need to look if the CU DIE which the iteration was requested
+   for has attribute DW_AT_macro_info, or either of DW_AT_GNU_macros
+   or DW_AT_macros to differentiate the two interpretations.  */
 extern int dwarf_macro_opcode (Dwarf_Macro *macro, unsigned int *opcodep)
      __nonnull_attribute__ (2);
 
diff --git a/tests/ChangeLog b/tests/ChangeLog
index 909a61e..eb77673 100644
--- a/tests/ChangeLog
+++ b/tests/ChangeLog
@@ -1,3 +1,13 @@
+2014-12-02  Petr Machata  <pmachata@redhat.com>
+
+	* dwarf-getmacros.c (mac): Skip over DW_MACINFO_undef,
+	DW_MACRO_GNU_undef_indirect opcodes.  Add a default branch.
+	(main): Initialize off to DWARF_GETMACROS_START when an extra
+	command line argument is passed.
+	* testfile-macros-0xff.bz2: New test case.
+	* testfile-macros-0xff.s: New file (source for the above).
+	* run-dwarf-getmacros.sh: Add two tests.
+
 2014-11-21  Mark Wielaard  <mjw@redhat.com>
 
 	* run-readelf-A.sh: New test.
diff --git a/tests/dwarf-getmacros.c b/tests/dwarf-getmacros.c
index f203d5b..92e093c 100644
--- a/tests/dwarf-getmacros.c
+++ b/tests/dwarf-getmacros.c
@@ -34,9 +34,9 @@ mac (Dwarf_Macro *macro, void *dbg)
 {
   static int level = 0;
 
-  switch (({ unsigned int opcode;
-	     dwarf_macro_opcode (macro, &opcode);
-	     opcode; }))
+  unsigned int opcode;
+  dwarf_macro_opcode (macro, &opcode);
+  switch (opcode)
     {
     case DW_MACRO_GNU_transparent_include:
       {
@@ -50,7 +50,7 @@ mac (Dwarf_Macro *macro, void *dbg)
 
 	printf ("%*sinclude %#" PRIx64 "\n", level, "", w);
 	++level;
-	include (dbg, w, 0);
+	include (dbg, w, DWARF_GETMACROS_START);
 	--level;
 	printf ("%*s/include\n", level, "");
 	break;
@@ -88,6 +88,19 @@ mac (Dwarf_Macro *macro, void *dbg)
 	printf ("%*s%s\n", level, "", value);
 	break;
       }
+
+    case DW_MACINFO_undef:
+    case DW_MACRO_GNU_undef_indirect:
+      break;
+
+    default:
+      {
+	size_t paramcnt;
+	dwarf_macro_getparamcnt (macro, &paramcnt);
+	printf ("%*sopcode %u with %zd arguments\n",
+		level, "", opcode, paramcnt);
+	break;
+      }
     }
 
   return DWARF_CB_ABORT;
@@ -105,17 +118,19 @@ include (Dwarf *dbg, Dwarf_Off macoff, ptrdiff_t token)
 }
 
 int
-main (int argc __attribute__ ((unused)), char *argv[])
+main (int argc, char *argv[])
 {
+  assert (argc >= 3);
   const char *name = argv[1];
   ptrdiff_t cuoff = strtol (argv[2], NULL, 0);
+  bool new_style = argc > 3;
 
   int fd = open (name, O_RDONLY);
   Dwarf *dbg = dwarf_begin (fd, DWARF_C_READ);
 
   Dwarf_Die cudie_mem, *cudie = dwarf_offdie (dbg, cuoff, &cudie_mem);
 
-  for (ptrdiff_t off = 0;
+  for (ptrdiff_t off = new_style ? DWARF_GETMACROS_START : 0;
        (off = dwarf_getmacros (cudie, mac, dbg, off)); )
     if (off == -1)
       {
diff --git a/tests/run-dwarf-getmacros.sh b/tests/run-dwarf-getmacros.sh
index 8f7c4a8..0a488fa 100755
--- a/tests/run-dwarf-getmacros.sh
+++ b/tests/run-dwarf-getmacros.sh
@@ -696,4 +696,15 @@ file /home/mark/src/tests/macro.c
 /file
 EOF
 
+testfiles testfile-macros-0xff
+testrun_compare ${abs_builddir}/dwarf-getmacros testfile-macros-0xff 0xb <<\EOF
+invalid opcode
+EOF
+testrun_compare ${abs_builddir}/dwarf-getmacros testfile-macros-0xff 0xb '' <<\EOF
+opcode 255 with 0 arguments
+file /home/petr/proj/elfutils/master/elfutils/x.c
+ FOO 0
+/file
+EOF
+
 exit 0
diff --git a/tests/testfile-macros-0xff.bz2 b/tests/testfile-macros-0xff.bz2
new file mode 100755
index 0000000000000000000000000000000000000000..a19662a3d43170f7200c50f2984693450fda79e4
GIT binary patch
literal 2844
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

literal 0
HcmV?d00001

diff --git a/tests/testfile-macros-0xff.s b/tests/testfile-macros-0xff.s
new file mode 100644
index 0000000..7fdd35c
--- /dev/null
+++ b/tests/testfile-macros-0xff.s
@@ -0,0 +1,153 @@
+	.file	"x.c"
+	.text
+.Ltext0:
+	.globl	main
+	.type	main, @function
+main:
+.LFB0:
+	.file 1 "x.c"
+	.loc 1 3 0
+	.cfi_startproc
+	pushq	%rbp
+	.cfi_def_cfa_offset 16
+	.cfi_offset 6, -16
+	movq	%rsp, %rbp
+	.cfi_def_cfa_register 6
+	.loc 1 3 0
+	movl	$0, %eax
+	popq	%rbp
+	.cfi_def_cfa 7, 8
+	ret
+	.cfi_endproc
+.LFE0:
+	.size	main, .-main
+.Letext0:
+	.section	.debug_info,"",@progbits
+.Ldebug_info0:
+	.long	0x52
+	.value	0x4
+	.long	.Ldebug_abbrev0
+	.byte	0x8
+	.uleb128 0x1
+	.long	.LASF244
+	.byte	0x4
+	.string	"x.c"
+	.long	.LASF245
+	.quad	.Ltext0
+	.quad	.Letext0-.Ltext0
+	.long	.Ldebug_line0
+	.long	.Ldebug_macro0
+	.uleb128 0x2
+	.long	.LASF246
+	.byte	0x1
+	.byte	0x3
+	.long	0x4e
+	.quad	.LFB0
+	.quad	.LFE0-.LFB0
+	.uleb128 0x1
+	.byte	0x9c
+	.uleb128 0x3
+	.byte	0x4
+	.byte	0x5
+	.string	"int"
+	.byte	0
+	.section	.debug_abbrev,"",@progbits
+.Ldebug_abbrev0:
+	.uleb128 0x1
+	.uleb128 0x11
+	.byte	0x1
+	.uleb128 0x25
+	.uleb128 0xe
+	.uleb128 0x13
+	.uleb128 0xb
+	.uleb128 0x3
+	.uleb128 0x8
+	.uleb128 0x1b
+	.uleb128 0xe
+	.uleb128 0x11
+	.uleb128 0x1
+	.uleb128 0x12
+	.uleb128 0x7
+	.uleb128 0x10
+	.uleb128 0x17
+	.uleb128 0x2119
+	.uleb128 0x17
+	.byte	0
+	.byte	0
+	.uleb128 0x2
+	.uleb128 0x2e
+	.byte	0
+	.uleb128 0x3f
+	.uleb128 0x19
+	.uleb128 0x3
+	.uleb128 0xe
+	.uleb128 0x3a
+	.uleb128 0xb
+	.uleb128 0x3b
+	.uleb128 0xb
+	.uleb128 0x49
+	.uleb128 0x13
+	.uleb128 0x11
+	.uleb128 0x1
+	.uleb128 0x12
+	.uleb128 0x7
+	.uleb128 0x40
+	.uleb128 0x18
+	.uleb128 0x2117
+	.uleb128 0x19
+	.byte	0
+	.byte	0
+	.uleb128 0x3
+	.uleb128 0x24
+	.byte	0
+	.uleb128 0xb
+	.uleb128 0xb
+	.uleb128 0x3e
+	.uleb128 0xb
+	.uleb128 0x3
+	.uleb128 0x8
+	.byte	0
+	.byte	0
+	.byte	0
+	.section	.debug_aranges,"",@progbits
+	.long	0x2c
+	.value	0x2
+	.long	.Ldebug_info0
+	.byte	0x8
+	.byte	0
+	.value	0
+	.value	0
+	.quad	.Ltext0
+	.quad	.Letext0-.Ltext0
+	.quad	0
+	.quad	0
+	.section	.debug_macro,"",@progbits
+.Ldebug_macro0:
+	.value	0x4
+	.byte	0x6
+	.long	.Ldebug_line0
+	.byte   0x1
+	.byte   0xff
+	.uleb128 0
+	.byte   0xff
+	.byte	0x3
+	.uleb128 0
+	.uleb128 0x1
+	.byte	0x5
+	.uleb128 0x1
+	.long	.LASF243
+	.byte	0x4
+	.byte	0
+	.section	.debug_line,"",@progbits
+.Ldebug_line0:
+	.section	.debug_str,"MS",@progbits,1
+.LASF245:
+	.string	"/home/petr/proj/elfutils/master/elfutils"
+.LASF244:
+	.string	"GNU C++ 4.9.0 20140422 (Red Hat 4.9.0-1) -mtune=generic -march=x86-64 -g3"
+.LASF243:
+	.string	"FOO 0"
+.LASF246:
+	.string	"main"
+	.ident	"GCC: (GNU) 4.9.0 20140422 (Red Hat 4.9.0-1)"
+	.section	.note.GNU-stack,"",@progbits
-- 
2.1.0


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]