This is the mail archive of the
binutils@sources.redhat.com
mailing list for the binutils project.
gas misoptimizes gcc3 .eh_frame
- To: binutils at sources dot redhat dot com
- Subject: gas misoptimizes gcc3 .eh_frame
- From: Richard Henderson <rth at redhat dot com>
- Date: Mon, 14 May 2001 15:47:03 -0700
- Cc: Jason Merrill <jason at redhat dot com>
Gcc3 has changed to use a leading 'z' in the augmentation string,
which denotes a uleb128 in *both* the CIE and FDE indicating how
large the augmentation section is.
Problem 1, normally gas would see that as an unknown augmentation
and stop optimizing.
Problem 2, if the unknown augmentation string is trivially "fixed",
(but even without, I've seen this on one Alpha example), gas will
not skip the FDE augmentation section, which will corrupt the data
being stored there.
Fixed thus. The included test case checks for both of the above.
r~
* ehopt.c (get_cie_info): Rename from eh_frame_code_alignment;
also collect whether to expect an FDE augmentation.
(check_eh_frame): Rewrite as a state machine. Track where in
an FDE we are located, skip any augmentation.
(eh_frame_estimate_size_before_relax): Get code alignment from
the fragment subtype.
(eh_frame_relax_frag, eh_frame_convert_frag): Likewise.
* read.c (emit_leb128_expr): Call check_eh_frame.
* gas/elf/ehopt0.s: New.
* gas/elf/ehopt0.d: New.
* gas/elf/elf.exp: Run it.
Index: ehopt.c
===================================================================
RCS file: /cvs/src/src/gas/ehopt.c,v
retrieving revision 1.6
diff -c -p -d -r1.6 ehopt.c
*** ehopt.c 2001/03/30 07:07:09 1.6
--- ehopt.c 2001/05/14 22:31:10
*************** __FRAME_BEGIN__:
*** 88,117 ****
not know this value, it always uses four bytes. We will know the
value at the end of assembly, so we can do better. */
! static int eh_frame_code_alignment PARAMS ((int));
! /* Get the code alignment factor from the CIE. */
static int
! eh_frame_code_alignment (in_seg)
! int in_seg;
{
- /* ??? Assume .eh_frame and .debug_frame have the same alignment. */
- static int code_alignment;
-
fragS *f;
fixS *fix;
int offset;
char CIE_id;
char augmentation[10];
int iaug;
!
! if (code_alignment != 0)
! return code_alignment;
!
! /* Can't find the alignment if we've changed sections. */
! if (! in_seg)
! return -1;
/* We should find the CIE at the start of the section. */
--- 88,114 ----
not know this value, it always uses four bytes. We will know the
value at the end of assembly, so we can do better. */
! struct cie_info
! {
! unsigned code_alignment;
! int z_augmentation;
! };
! static int get_cie_info PARAMS ((struct cie_info *));
+ /* Extract information from the CIE. */
+
static int
! get_cie_info (info)
! struct cie_info *info;
{
fragS *f;
fixS *fix;
int offset;
char CIE_id;
char augmentation[10];
int iaug;
! int code_alignment = 0;
/* We should find the CIE at the start of the section. */
*************** eh_frame_code_alignment (in_seg)
*** 147,156 ****
|| f->fr_literal[offset + 1] != CIE_id
|| f->fr_literal[offset + 2] != CIE_id
|| f->fr_literal[offset + 3] != CIE_id)
! {
! code_alignment = -1;
! return -1;
! }
/* Next make sure the CIE version number is 1. */
--- 144,150 ----
|| f->fr_literal[offset + 1] != CIE_id
|| f->fr_literal[offset + 2] != CIE_id
|| f->fr_literal[offset + 3] != CIE_id)
! return 0;
/* Next make sure the CIE version number is 1. */
*************** eh_frame_code_alignment (in_seg)
*** 163,172 ****
if (f == NULL
|| f->fr_fix - offset < 1
|| f->fr_literal[offset] != 1)
! {
! code_alignment = -1;
! return -1;
! }
/* Skip the augmentation (a null terminated string). */
--- 157,163 ----
if (f == NULL
|| f->fr_fix - offset < 1
|| f->fr_literal[offset] != 1)
! return 0;
/* Skip the augmentation (a null terminated string). */
*************** eh_frame_code_alignment (in_seg)
*** 180,189 ****
f = f->fr_next;
}
if (f == NULL)
! {
! code_alignment = -1;
! return -1;
! }
while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
{
if ((size_t) iaug < (sizeof augmentation) - 1)
--- 171,178 ----
f = f->fr_next;
}
if (f == NULL)
! return 0;
!
while (offset < f->fr_fix && f->fr_literal[offset] != '\0')
{
if ((size_t) iaug < (sizeof augmentation) - 1)
*************** eh_frame_code_alignment (in_seg)
*** 203,212 ****
f = f->fr_next;
}
if (f == NULL)
! {
! code_alignment = -1;
! return -1;
! }
augmentation[iaug] = '\0';
if (augmentation[0] == '\0')
--- 192,198 ----
f = f->fr_next;
}
if (f == NULL)
! return 0;
augmentation[iaug] = '\0';
if (augmentation[0] == '\0')
*************** eh_frame_code_alignment (in_seg)
*** 230,257 ****
f = f->fr_next;
}
if (f == NULL)
! {
! code_alignment = -1;
! return -1;
! }
! }
! else
! {
! code_alignment = -1;
! return -1;
}
/* We're now at the code alignment factor, which is a ULEB128. If
it isn't a single byte, forget it. */
code_alignment = f->fr_literal[offset] & 0xff;
! if ((code_alignment & 0x80) != 0 || code_alignment == 0)
! {
! code_alignment = -1;
! return -1;
! }
! return code_alignment;
}
/* This function is called from emit_expr. It looks for cases which
--- 216,237 ----
f = f->fr_next;
}
if (f == NULL)
! return 0;
}
+ else if (augmentation[0] != 'z')
+ return 0;
/* We're now at the code alignment factor, which is a ULEB128. If
it isn't a single byte, forget it. */
code_alignment = f->fr_literal[offset] & 0xff;
! if ((code_alignment & 0x80) != 0)
! code_alignment = 0;
! info->code_alignment = code_alignment;
! info->z_augmentation = (augmentation[0] == 'z');
!
! return 1;
}
/* This function is called from emit_expr. It looks for cases which
*************** check_eh_frame (exp, pnbytes)
*** 274,284 ****
{
struct frame_data
{
symbolS *size_end_sym;
fragS *loc4_frag;
- int saw_size;
- int saw_advance_loc4;
int loc4_fix;
};
static struct frame_data eh_frame_data;
--- 254,281 ----
{
struct frame_data
{
+ enum frame_state
+ {
+ state_idle,
+ state_saw_size,
+ state_saw_cie_offset,
+ state_saw_pc_begin,
+ state_seeing_aug_size,
+ state_skipping_aug,
+ state_wait_loc4,
+ state_saw_loc4,
+ state_error,
+ } state;
+
+ int cie_info_ok;
+ struct cie_info cie_info;
+
symbolS *size_end_sym;
fragS *loc4_frag;
int loc4_fix;
+
+ int aug_size;
+ int aug_shift;
};
static struct frame_data eh_frame_data;
*************** check_eh_frame (exp, pnbytes)
*** 297,419 ****
else
return 0;
! if (d->saw_size && S_IS_DEFINED (d->size_end_sym))
{
/* We have come to the end of the CIE or FDE. See below where
we set saw_size. We must check this first because we may now
be looking at the next size. */
! d->saw_size = 0;
! d->saw_advance_loc4 = 0;
}
! if (! d->saw_size
! && *pnbytes == 4)
{
! /* This might be the size of the CIE or FDE. We want to know
! the size so that we don't accidentally optimize across an FDE
! boundary. We recognize the size in one of two forms: a
! symbol which will later be defined as a difference, or a
! subtraction of two symbols. Either way, we can tell when we
! are at the end of the FDE because the symbol becomes defined
! (in the case of a subtraction, the end symbol, from which the
! start symbol is being subtracted). Other ways of describing
! the size will not be optimized. */
! if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
! && ! S_IS_DEFINED (exp->X_add_symbol))
{
! d->saw_size = 1;
! d->size_end_sym = exp->X_add_symbol;
}
! }
! else if (d->saw_size
! && *pnbytes == 1
! && exp->X_op == O_constant
! && exp->X_add_number == DW_CFA_advance_loc4)
! {
! /* This might be a DW_CFA_advance_loc4. Record the frag and the
! position within the frag, so that we can change it later. */
! d->saw_advance_loc4 = 1;
! frag_grow (1);
! d->loc4_frag = frag_now;
! d->loc4_fix = frag_now_fix ();
! }
! else if (d->saw_advance_loc4
! && *pnbytes == 4
! && exp->X_op == O_constant)
! {
! int ca;
! /* This is a case which we can optimize. The two symbols being
! subtracted were in the same frag and the expression was
! reduced to a constant. We can do the optimization entirely
! in this function. */
! d->saw_advance_loc4 = 0;
! ca = eh_frame_code_alignment (1);
! if (ca < 0)
{
! /* Don't optimize. */
}
! else if (exp->X_add_number % ca == 0
! && exp->X_add_number / ca < 0x40)
{
! d->loc4_frag->fr_literal[d->loc4_fix]
! = DW_CFA_advance_loc | (exp->X_add_number / ca);
! /* No more bytes needed. */
! return 1;
}
! else if (exp->X_add_number < 0x100)
{
! d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
! *pnbytes = 1;
}
! else if (exp->X_add_number < 0x10000)
{
! d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
! *pnbytes = 2;
}
! }
! else if (d->saw_advance_loc4
! && *pnbytes == 4
! && exp->X_op == O_subtract)
! {
! /* This is a case we can optimize. The expression was not
! reduced, so we can not finish the optimization until the end
! of the assembly. We set up a variant frag which we handle
! later. */
! d->saw_advance_loc4 = 0;
! frag_var (rs_cfa, 4, 0, 0, make_expr_symbol (exp),
! d->loc4_fix, (char *) d->loc4_frag);
! return 1;
}
- else
- d->saw_advance_loc4 = 0;
return 0;
}
/* The function estimates the size of a rs_cfa variant frag based on
the current values of the symbols. It is called before the
! relaxation loop. We set fr_subtype to the expected length. */
int
eh_frame_estimate_size_before_relax (frag)
fragS *frag;
{
- int ca;
offsetT diff;
int ret;
- ca = eh_frame_code_alignment (0);
diff = resolve_symbol_value (frag->fr_symbol, 0);
! if (ca < 0)
! ret = 4;
! else if (diff % ca == 0 && diff / ca < 0x40)
ret = 0;
else if (diff < 0x100)
ret = 1;
--- 294,470 ----
else
return 0;
! if (d->state >= state_saw_size && S_IS_DEFINED (d->size_end_sym))
{
/* We have come to the end of the CIE or FDE. See below where
we set saw_size. We must check this first because we may now
be looking at the next size. */
! d->state = state_idle;
}
! switch (d->state)
{
! case state_idle:
! if (*pnbytes == 4)
{
! /* This might be the size of the CIE or FDE. We want to know
! the size so that we don't accidentally optimize across an FDE
! boundary. We recognize the size in one of two forms: a
! symbol which will later be defined as a difference, or a
! subtraction of two symbols. Either way, we can tell when we
! are at the end of the FDE because the symbol becomes defined
! (in the case of a subtraction, the end symbol, from which the
! start symbol is being subtracted). Other ways of describing
! the size will not be optimized. */
! if ((exp->X_op == O_symbol || exp->X_op == O_subtract)
! && ! S_IS_DEFINED (exp->X_add_symbol))
! {
! d->state = state_saw_size;
! d->size_end_sym = exp->X_add_symbol;
! }
}
! break;
! case state_saw_size:
! case state_saw_cie_offset:
! /* Assume whatever form it appears in, it appears atomically. */
! d->state += 1;
! break;
! case state_saw_pc_begin:
! /* Decide whether we should see an augmentation. */
! if (! d->cie_info_ok
! && ! (d->cie_info_ok = get_cie_info (&d->cie_info)))
! d->state = state_error;
! else if (d->cie_info.z_augmentation)
! {
! d->state = state_seeing_aug_size;
! d->aug_size = 0;
! d->aug_shift = 0;
! }
! else
! d->state = state_wait_loc4;
! break;
! case state_seeing_aug_size:
! /* Bytes == -1 means this comes from an leb128 directive. */
! if ((int)*pnbytes == -1 && exp->X_op == O_constant)
{
! d->aug_size = exp->X_add_number;
! d->state = state_skipping_aug;
}
! else if (*pnbytes == 1 && exp->X_op == O_constant)
{
! unsigned char byte = exp->X_add_number;
! d->aug_size |= (byte & 0x7f) << d->aug_shift;
! d->aug_shift += 7;
! if ((byte & 0x80) == 0)
! d->state = state_skipping_aug;
}
! else
! d->state = state_error;
! break;
!
! case state_skipping_aug:
! if ((int)*pnbytes < 0)
! d->state = state_error;
! else
{
! int left = (d->aug_size -= *pnbytes);
! if (left == 0)
! d->state = state_wait_loc4;
! else if (left < 0)
! d->state = state_error;
}
! break;
!
! case state_wait_loc4:
! if (*pnbytes == 1
! && exp->X_op == O_constant
! && exp->X_add_number == DW_CFA_advance_loc4)
{
! /* This might be a DW_CFA_advance_loc4. Record the frag and the
! position within the frag, so that we can change it later. */
! frag_grow (1);
! d->state = state_saw_loc4;
! d->loc4_frag = frag_now;
! d->loc4_fix = frag_now_fix ();
}
! break;
! case state_saw_loc4:
! d->state = state_wait_loc4;
! if (*pnbytes != 4)
! break;
! if (exp->X_op == O_constant)
! {
! /* This is a case which we can optimize. The two symbols being
! subtracted were in the same frag and the expression was
! reduced to a constant. We can do the optimization entirely
! in this function. */
! if (d->cie_info.code_alignment > 0
! && exp->X_add_number % d->cie_info.code_alignment == 0
! && exp->X_add_number / d->cie_info.code_alignment < 0x40)
! {
! d->loc4_frag->fr_literal[d->loc4_fix]
! = DW_CFA_advance_loc
! | (exp->X_add_number / d->cie_info.code_alignment);
! /* No more bytes needed. */
! return 1;
! }
! else if (exp->X_add_number < 0x100)
! {
! d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc1;
! *pnbytes = 1;
! }
! else if (exp->X_add_number < 0x10000)
! {
! d->loc4_frag->fr_literal[d->loc4_fix] = DW_CFA_advance_loc2;
! *pnbytes = 2;
! }
! }
! else if (exp->X_op == O_subtract)
! {
! /* This is a case we can optimize. The expression was not
! reduced, so we can not finish the optimization until the end
! of the assembly. We set up a variant frag which we handle
! later. */
! int fr_subtype;
! if (d->cie_info.code_alignment > 0)
! fr_subtype = d->cie_info.code_alignment << 3;
! else
! fr_subtype = 0;
! frag_var (rs_cfa, 4, 0, fr_subtype, make_expr_symbol (exp),
! d->loc4_fix, (char *) d->loc4_frag);
! return 1;
! }
! break;
!
! case state_error:
! /* Just skipping everything. */
! break;
}
return 0;
}
/* The function estimates the size of a rs_cfa variant frag based on
the current values of the symbols. It is called before the
! relaxation loop. We set fr_subtype{0:2} to the expected length. */
int
eh_frame_estimate_size_before_relax (frag)
fragS *frag;
{
offsetT diff;
+ int ca = frag->fr_subtype >> 3;
int ret;
diff = resolve_symbol_value (frag->fr_symbol, 0);
! if (ca > 0 && diff % ca == 0 && diff / ca < 0x40)
ret = 0;
else if (diff < 0x100)
ret = 1;
*************** eh_frame_estimate_size_before_relax (fra
*** 422,435 ****
else
ret = 4;
! frag->fr_subtype = ret;
return ret;
}
/* This function relaxes a rs_cfa variant frag based on the current
! values of the symbols. fr_subtype is the current length of the
! frag. This returns the change in frag length. */
int
eh_frame_relax_frag (frag)
--- 473,486 ----
else
ret = 4;
! frag->fr_subtype = (frag->fr_subtype & ~7) | ret;
return ret;
}
/* This function relaxes a rs_cfa variant frag based on the current
! values of the symbols. fr_subtype{0:2} is the current length of
! the frag. This returns the change in frag length. */
int
eh_frame_relax_frag (frag)
*************** eh_frame_relax_frag (frag)
*** 437,450 ****
{
int oldsize, newsize;
! oldsize = frag->fr_subtype;
newsize = eh_frame_estimate_size_before_relax (frag);
return newsize - oldsize;
}
/* This function converts a rs_cfa variant frag into a normal fill
frag. This is called after all relaxation has been done.
! fr_subtype will be the desired length of the frag. */
void
eh_frame_convert_frag (frag)
--- 488,501 ----
{
int oldsize, newsize;
! oldsize = frag->fr_subtype & 7;
newsize = eh_frame_estimate_size_before_relax (frag);
return newsize - oldsize;
}
/* This function converts a rs_cfa variant frag into a normal fill
frag. This is called after all relaxation has been done.
! fr_subtype{0:2} will be the desired length of the frag. */
void
eh_frame_convert_frag (frag)
*************** eh_frame_convert_frag (frag)
*** 459,486 ****
diff = resolve_symbol_value (frag->fr_symbol, finalize_syms);
! if (frag->fr_subtype == 0)
{
! int ca;
! ca = eh_frame_code_alignment (0);
! assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
! loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | (diff / ca);
! }
! else if (frag->fr_subtype == 1)
! {
assert (diff < 0x100);
loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
frag->fr_literal[frag->fr_fix] = diff;
! }
! else if (frag->fr_subtype == 2)
! {
assert (diff < 0x10000);
loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
}
- else
- md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
frag->fr_fix += frag->fr_subtype;
frag->fr_type = rs_fill;
--- 510,541 ----
diff = resolve_symbol_value (frag->fr_symbol, finalize_syms);
! switch (frag->fr_subtype & 7)
{
! case 0:
! {
! int ca = frag->fr_subtype >> 3;
! assert (ca > 0 && diff % ca == 0 && diff / ca < 0x40);
! loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc | (diff / ca);
! }
! break;
! case 1:
assert (diff < 0x100);
loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc1;
frag->fr_literal[frag->fr_fix] = diff;
! break;
!
! case 2:
assert (diff < 0x10000);
loc4_frag->fr_literal[loc4_fix] = DW_CFA_advance_loc2;
md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 2);
+ break;
+
+ default:
+ md_number_to_chars (frag->fr_literal + frag->fr_fix, diff, 4);
+ break;
}
frag->fr_fix += frag->fr_subtype;
frag->fr_type = rs_fill;
Index: read.c
===================================================================
RCS file: /cvs/src/src/gas/read.c,v
retrieving revision 1.36
diff -c -p -d -r1.36 read.c
*** read.c 2001/03/28 17:24:01 1.36
--- read.c 2001/05/14 22:31:10
*************** emit_leb128_expr (exp, sign)
*** 4393,4398 ****
--- 4393,4399 ----
int sign;
{
operatorT op = exp->X_op;
+ int nbytes;
if (op == O_absent || op == O_illegal)
{
*************** emit_leb128_expr (exp, sign)
*** 4411,4416 ****
--- 4412,4423 ----
as_warn (_("register value used as expression"));
op = O_constant;
}
+
+ /* Let check_eh_frame know that data is being emitted. nbytes == -1 is
+ a signal that this is leb128 data. It shouldn't optimize this away. */
+ nbytes = -1;
+ if (check_eh_frame (exp, &nbytes))
+ abort ();
if (op == O_constant)
{
Index: testsuite/gas/elf/ehopt0.d
===================================================================
RCS file: ehopt0.d
diff -N ehopt0.d
*** /dev/null Tue May 5 13:32:27 1998
--- ehopt0.d Mon May 14 15:31:11 2001
***************
*** 0 ****
--- 1,9 ----
+ #objdump: -s -j .eh_frame
+ #name: elf ehopt0
+
+ .*: +file format .*
+
+ Contents of section .eh_frame:
+ 0+000 10000000 00000000 017a0001 781a0004 .*
+ 0+010 01000000 12000000 18000000 00000000 .*
+ 0+020 08000000 04080000 0044 .*
Index: testsuite/gas/elf/ehopt0.s
===================================================================
RCS file: ehopt0.s
diff -N ehopt0.s
*** /dev/null Tue May 5 13:32:27 1998
--- ehopt0.s Mon May 14 15:31:11 2001
***************
*** 0 ****
--- 1,32 ----
+ .text
+ $LFB1:
+ .4byte 0
+ $L1:
+ .4byte 0
+ $LFE1:
+ .section .eh_frame,"aw",@progbits
+ __FRAME_BEGIN__:
+ .4byte $LECIE1-$LSCIE1
+ $LSCIE1:
+ .4byte 0x0
+ .byte 0x1
+ .ascii "z\0"
+ .byte 0x1
+ .byte 0x78
+ .byte 0x1a
+ .byte 0x0
+ .byte 0x4
+ .4byte 1
+ .p2align 1
+ $LECIE1:
+ $LSFDE1:
+ .4byte $LEFDE1-$LASFDE1
+ $LASFDE1:
+ .4byte $LASFDE1-__FRAME_BEGIN__
+ .4byte $LFB1
+ .4byte $LFE1-$LFB1
+ .byte 0x4
+ .4byte $LFE1-$LFB1
+ .byte 0x4
+ .4byte $L1-$LFB1
+ $LEFDE1:
Index: testsuite/gas/elf/elf.exp
===================================================================
RCS file: /cvs/src/src/gas/testsuite/gas/elf/elf.exp,v
retrieving revision 1.6
diff -c -p -d -r1.6 elf.exp
*** elf.exp 2000/05/21 18:06:40 1.6
--- elf.exp 2001/05/14 22:31:11
*************** if { ([istarget "*-*-elf*"]
*** 11,16 ****
--- 11,17 ----
&& ![istarget *-*-linux*coff*]
&& ![istarget *-*-linux*oldld*]
} then {
+ run_dump_test "ehopt0"
run_dump_test "section0"
run_dump_test "section1"
}