From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 26271 invoked by alias); 10 Feb 2011 16:00:12 -0000 Received: (qmail 26243 invoked by uid 22791); 10 Feb 2011 16:00:09 -0000 X-SWARE-Spam-Status: No, hits=-2.7 required=5.0 tests=ALL_TRUSTED,AWL,BAYES_00 X-Spam-Check-By: sourceware.org Received: from localhost (HELO gcc.gnu.org) (127.0.0.1) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 10 Feb 2011 16:00:02 +0000 From: "iains at gcc dot gnu.org" To: gcc-bugs@gcc.gnu.org Subject: [Bug target/47324] r157762 caused g++.dg/torture/stackalign failures with -O3 -g at -m32 on darwin X-Bugzilla-Reason: CC X-Bugzilla-Type: changed X-Bugzilla-Watch-Reason: None X-Bugzilla-Product: gcc X-Bugzilla-Component: target X-Bugzilla-Keywords: X-Bugzilla-Severity: normal X-Bugzilla-Who: iains at gcc dot gnu.org X-Bugzilla-Status: NEW X-Bugzilla-Priority: P3 X-Bugzilla-Assigned-To: unassigned at gcc dot gnu.org X-Bugzilla-Target-Milestone: --- X-Bugzilla-Changed-Fields: Message-ID: In-Reply-To: References: X-Bugzilla-URL: http://gcc.gnu.org/bugzilla/ Auto-Submitted: auto-generated Content-Type: text/plain; charset="UTF-8" MIME-Version: 1.0 Date: Thu, 10 Feb 2011 16:05:00 -0000 Mailing-List: contact gcc-bugs-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-bugs-owner@gcc.gnu.org X-SW-Source: 2011-02/txt/msg01323.txt.bz2 http://gcc.gnu.org/bugzilla/show_bug.cgi?id=47324 --- Comment #35 from Iain Sandoe 2011-02-10 15:59:27 UTC --- (In reply to comment #34) > For #c32, you obviously can't hardcode darwin ugly hacks into generic code. > The #c33 patch looks much better, but still > 1) in output_loc_sequence, you need to use DWARF2_FRAME_REG_OUT even if > !for_eh, > so that conditional has to go (on ppc, DWARF2-FRAME_REG_OUT changes the > value Thanks Jakub, yeah that was an oversight - was looking at the ppc code this morning... so -- something like this? Index: gcc/dwarf2out.c =================================================================== --- gcc/dwarf2out.c (revision 170000) +++ gcc/dwarf2out.c (working copy) @@ -474,7 +474,7 @@ static bool clobbers_queued_reg_save (const_rtx); static void dwarf2out_frame_debug_expr (rtx, const char *); /* Support for complex CFA locations. */ -static void output_cfa_loc (dw_cfi_ref); +static void output_cfa_loc (dw_cfi_ref, int); static void output_cfa_loc_raw (dw_cfi_ref); static void get_cfa_from_loc_descr (dw_cfa_location *, struct dw_loc_descr_struct *); @@ -3317,7 +3317,7 @@ output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int fo case DW_CFA_def_cfa_expression: case DW_CFA_expression: - output_cfa_loc (cfi); + output_cfa_loc (cfi, for_eh); break; case DW_CFA_GNU_negative_offset_extended: @@ -5056,7 +5056,7 @@ static void get_ref_die_offset_label (char *, dw_d /* Output location description stack opcode's operands (if any). */ static void -output_loc_operands (dw_loc_descr_ref loc) +output_loc_operands (dw_loc_descr_ref loc, int for_eh) { dw_val_ref val1 = &loc->dw_loc_oprnd1; dw_val_ref val2 = &loc->dw_loc_oprnd2; @@ -5227,14 +5227,24 @@ static void dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); break; case DW_OP_regx: - dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); + { + unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, for_eh); + gcc_assert (size_of_uleb128 (r) + == size_of_uleb128 (val1->v.val_unsigned)); + dw2_asm_output_data_uleb128 (r, NULL); + } break; case DW_OP_fbreg: dw2_asm_output_data_sleb128 (val1->v.val_int, NULL); break; case DW_OP_bregx: - dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); - dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); + { + unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, for_eh); + gcc_assert (size_of_uleb128 (r) + == size_of_uleb128 (val1->v.val_unsigned)); + dw2_asm_output_data_uleb128 (r, NULL); + dw2_asm_output_data_sleb128 (val2->v.val_int, NULL); + } break; case DW_OP_piece: dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL); @@ -5291,16 +5301,32 @@ static void /* Output a sequence of location operations. */ static void -output_loc_sequence (dw_loc_descr_ref loc) +output_loc_sequence (dw_loc_descr_ref loc, int for_eh) { for (; loc != NULL; loc = loc->dw_loc_next) { + enum dwarf_location_atom opc = loc->dw_loc_opc; /* Output the opcode. */ - dw2_asm_output_data (1, loc->dw_loc_opc, - "%s", dwarf_stack_op_name (loc->dw_loc_opc)); + if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31) + { + unsigned r = (opc - DW_OP_breg0); + r = DWARF2_FRAME_REG_OUT (r, for_eh); + gcc_assert (r <= 31); + opc = (enum dwarf_location_atom) (DW_OP_breg0 + r); + } + else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31) + { + unsigned r = (opc - DW_OP_reg0); + r = DWARF2_FRAME_REG_OUT (r, for_eh); + gcc_assert (r <= 31); + opc = (enum dwarf_location_atom) (DW_OP_reg0 + r); + } + dw2_asm_output_data (1, opc, + "%s", dwarf_stack_op_name (opc)); + /* Output the operand(s) (if any). */ - output_loc_operands (loc); + output_loc_operands (loc, for_eh); } } @@ -5361,9 +5387,18 @@ output_loc_operands_raw (dw_loc_descr_ref loc) } break; + case DW_OP_regx: + { + unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1); + gcc_assert (size_of_uleb128 (r) + == size_of_uleb128 (val1->v.val_unsigned)); + fputc (',', asm_out_file); + dw2_asm_output_data_uleb128_raw (r); + } + break; + case DW_OP_constu: case DW_OP_plus_uconst: - case DW_OP_regx: case DW_OP_piece: fputc (',', asm_out_file); dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned); @@ -5414,10 +5449,15 @@ output_loc_operands_raw (dw_loc_descr_ref loc) break; case DW_OP_bregx: - fputc (',', asm_out_file); - dw2_asm_output_data_uleb128_raw (val1->v.val_unsigned); - fputc (',', asm_out_file); - dw2_asm_output_data_sleb128_raw (val2->v.val_int); + { + unsigned r = DWARF2_FRAME_REG_OUT (val1->v.val_unsigned, 1); + gcc_assert (size_of_uleb128 (r) + == size_of_uleb128 (val1->v.val_unsigned)); + fputc (',', asm_out_file); + dw2_asm_output_data_uleb128_raw (r); + fputc (',', asm_out_file); + dw2_asm_output_data_sleb128_raw (val2->v.val_int); + } break; case DW_OP_GNU_implicit_pointer: @@ -5435,8 +5475,24 @@ output_loc_sequence_raw (dw_loc_descr_ref loc) { while (1) { + enum dwarf_location_atom opc = loc->dw_loc_opc; /* Output the opcode. */ - fprintf (asm_out_file, "%#x", loc->dw_loc_opc); + if (opc >= DW_OP_breg0 && opc <= DW_OP_breg31) + { + unsigned r = (opc - DW_OP_breg0); + r = DWARF2_FRAME_REG_OUT (r, 1); + gcc_assert (r <= 31); + opc = (enum dwarf_location_atom) (DW_OP_breg0 + r); + } + else if (opc >= DW_OP_reg0 && opc <= DW_OP_reg31) + { + unsigned r = (opc - DW_OP_reg0); + r = DWARF2_FRAME_REG_OUT (r, 1); + gcc_assert (r <= 31); + opc = (enum dwarf_location_atom) (DW_OP_reg0 + r); + } + /* Output the opcode. */ + fprintf (asm_out_file, "%#x", opc); output_loc_operands_raw (loc); if (!loc->dw_loc_next) @@ -5451,14 +5507,16 @@ output_loc_sequence_raw (dw_loc_descr_ref loc) description based on a cfi entry with a complex address. */ static void -output_cfa_loc (dw_cfi_ref cfi) +output_cfa_loc (dw_cfi_ref cfi, int for_eh) { dw_loc_descr_ref loc; unsigned long size; if (cfi->dw_cfi_opc == DW_CFA_expression) { - dw2_asm_output_data (1, cfi->dw_cfi_oprnd1.dw_cfi_reg_num, NULL); + unsigned r = + DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh); + dw2_asm_output_data (1, r, NULL); loc = cfi->dw_cfi_oprnd2.dw_cfi_loc; } else @@ -5469,7 +5527,7 @@ static void dw2_asm_output_data_uleb128 (size, NULL); /* Now output the operations themselves. */ - output_loc_sequence (loc); + output_loc_sequence (loc, for_eh); } /* Similar, but used for .cfi_escape. */ @@ -5482,7 +5540,9 @@ output_cfa_loc_raw (dw_cfi_ref cfi) if (cfi->dw_cfi_opc == DW_CFA_expression) { - fprintf (asm_out_file, "%#x,", cfi->dw_cfi_oprnd1.dw_cfi_reg_num); + unsigned r = + DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, 1); + fprintf (asm_out_file, "%#x,", r); loc = cfi->dw_cfi_oprnd2.dw_cfi_loc; } else @@ -11075,7 +11135,7 @@ output_loc_list (dw_loc_list_ref list_head) gcc_assert (size <= 0xffff); dw2_asm_output_data (2, size, "%s", "Location expression size"); - output_loc_sequence (curr->expr); + output_loc_sequence (curr->expr, 0); } dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, @@ -11153,7 +11213,7 @@ output_die (dw_die_ref die) else dw2_asm_output_data (constant_size (size), size, "%s", name); - output_loc_sequence (AT_loc (a)); + output_loc_sequence (AT_loc (a), 0); break; case dw_val_class_const: