ia32: Directly put the bitfields in ia32_attr_t instead of having another...

ia32: Directly put the bitfields in ia32_attr_t instead of having another struct needlessly wrapping them.

ir/be/ia32/bearch_ia32.c

@@ -161,8 +161,7 @@ static void ia32_set_frame_entity(ir_node *node, ir_entity *entity,
 	ia32_attr_t *attr = get_ia32_attr(node);
 	/* set ls_mode based on entity unless we explicitely requested
 	 * a certain mode */
-	if (attr->data.need_32bit_stackent || attr->data.need_64bit_stackent
-	    || is_ia32_Conv_I2I(node))
+	if (attr->need_32bit_stackent || attr->need_64bit_stackent || is_ia32_Conv_I2I(node))
 		return;
 	ir_mode *mode = get_type_mode(type);
 	/** we 8bit stores have a special register requirement, so we can't simply
@@ -1012,9 +1011,9 @@ static void ia32_collect_frame_entity_nodes(ir_node *node, void *data)
 
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
 	const ir_type     *type;
-	if (attr->data.need_32bit_stackent) {
+	if (attr->need_32bit_stackent) {
 		type = get_type_for_mode(ia32_mode_gp);
-	} else if (attr->data.need_64bit_stackent) {
+	} else if (attr->need_64bit_stackent) {
 		type = get_type_for_mode(mode_Ls);
 	} else {
 		ir_mode *mode = get_ia32_ls_mode(node);

ir/be/ia32/ia32_emitter.c

@@ -369,7 +369,7 @@ static void ia32_emit_am(ir_node const *const node)
 	/* emit offset */
 	if (ent != NULL) {
 		const ia32_attr_t *attr = get_ia32_attr_const(node);
-		ia32_emit_entity(ent, attr->data.am_sc_no_pic_adjust);
+		ia32_emit_entity(ent, attr->am_sc_no_pic_adjust);
 	}
 
 	/* also handle special case if nothing is set */
@@ -552,7 +552,7 @@ destination_operand:
 					 * This means that it is sufficient to test whether the operands are
 					 * permuted.  In particular it is not necessary to consider wether the
 					 * result is to be placed into the explicit register operand. */
-					if (get_ia32_x87_attr_const(node)->attr.data.ins_permuted)
+					if (get_ia32_x87_attr_const(node)->attr.ins_permuted)
 						be_emit_char('r');
 				} else if (*fmt == 'X') {
 					ia32_emit_xmm_mode_suffix(node);
@@ -765,7 +765,7 @@ static x86_condition_code_t determine_final_cc(const ir_node *node,
 		flags_attr = get_ia32_attr_const(flags);
 	}
 
-	if (flags_attr->data.ins_permuted)
+	if (flags_attr->ins_permuted)
 		cc = x86_invert_condition_code(cc);
 	return cc;
 }
@@ -889,7 +889,7 @@ static void emit_ia32_CMovcc(const ir_node *node)
 	 * be set by memory operand folding
 	 * Permuting inputs of a cmov means the condition is negated!
 	 */
-	if (attr->data.ins_permuted)
+	if (attr->ins_permuted)
 		cc = x86_negate_condition_code(cc);
 
 	const arch_register_t *in_true
@@ -2359,7 +2359,7 @@ static void bemit_bt(ir_node const *const node)
 static void bemit_cmovcc(const ir_node *node)
 {
 	const ia32_attr_t     *attr         = get_ia32_attr_const(node);
-	int                    ins_permuted = attr->data.ins_permuted;
+	int                    ins_permuted = attr->ins_permuted;
 	const arch_register_t *out          = arch_get_irn_register_out(node, pn_ia32_res);
 	x86_condition_code_t   cc           = get_ia32_condcode(node);
 	cc = determine_final_cc(node, n_ia32_CMovcc_eflags, cc);
@@ -2973,7 +2973,7 @@ static void bemit_copybi(const ir_node *node)
 static void bemit_fbinop(ir_node const *const node, unsigned const op_fwd, unsigned const op_rev)
 {
 	ia32_x87_attr_t const *const attr = get_ia32_x87_attr_const(node);
-	unsigned               const op   = attr->attr.data.ins_permuted ? op_rev : op_fwd;
+	unsigned               const op   = attr->attr.ins_permuted ? op_rev : op_fwd;
 	if (get_ia32_op_type(node) == ia32_Normal) {
 		assert(!attr->pop || attr->res_in_reg);
 

ir/be/ia32/ia32_fpu.c

@@ -95,7 +95,7 @@ static ir_node *create_fpu_mode_spill(void *env, ir_node *state, bool force,
 static void set_32bit_stackent(ir_node *node)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.need_32bit_stackent = true;
+	attr->need_32bit_stackent = true;
 }
 
 static ir_node *create_fldcw_ent(ir_node *block, ir_entity *entity)

ir/be/ia32/ia32_new_nodes.c

@@ -123,7 +123,7 @@ static void ia32_dump_node(FILE *F, const ir_node *n, dump_reason_t reason)
 
 					if (attr->am_ent != NULL) {
 						fputs(get_entity_name(attr->am_ent), F);
-						if (attr->data.am_sc_no_pic_adjust) {
+						if (attr->am_sc_no_pic_adjust) {
 							fputs("(no_pic_adjust)", F);
 						}
 					}
@@ -213,7 +213,7 @@ static void ia32_dump_node(FILE *F, const ir_node *n, dump_reason_t reason)
 					fprintf(F, "condition_code = <invalid (0x%X)>\n",
 					        (unsigned)get_ia32_condcode(n));
 				}
-				fprintf(F, "ins_permuted = %u\n", (unsigned)attr->data.ins_permuted);
+				fprintf(F, "ins_permuted = %u\n", (unsigned)attr->ins_permuted);
 			} else if (is_ia32_CopyB(n) || is_ia32_CopyB_i(n)) {
 				fprintf(F, "size = %u\n", get_ia32_copyb_size(n));
 			}
@@ -404,7 +404,7 @@ const ia32_climbframe_attr_t *get_ia32_climbframe_attr_const(const ir_node *node
 ia32_op_type_t get_ia32_op_type(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return (ia32_op_type_t)attr->data.tp;
+	return (ia32_op_type_t)attr->tp;
 }
 
 /**
@@ -413,13 +413,13 @@ ia32_op_type_t get_ia32_op_type(const ir_node *node)
 void set_ia32_op_type(ir_node *node, ia32_op_type_t tp)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.tp     = tp;
+	attr->tp = tp;
 }
 
 ia32_am_type_t get_ia32_am_support(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return (ia32_am_type_t)attr->data.am_arity;
+	return (ia32_am_type_t)attr->am_arity;
 }
 
 /**
@@ -427,8 +427,8 @@ ia32_am_type_t get_ia32_am_support(const ir_node *node)
  */
 void set_ia32_am_support(ir_node *node, ia32_am_type_t arity)
 {
-	ia32_attr_t *attr   = get_ia32_attr(node);
-	attr->data.am_arity = arity;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->am_arity = arity;
 }
 
 /**
@@ -470,13 +470,13 @@ void set_ia32_am_ent(ir_node *node, ir_entity *entity)
 void set_ia32_am_tls_segment(ir_node *node, bool value)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.am_tls_segment = value;
+	attr->am_tls_segment = value;
 }
 
 bool get_ia32_am_tls_segment(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.am_tls_segment;
+	return attr->am_tls_segment;
 }
 
 /**
@@ -485,7 +485,7 @@ bool get_ia32_am_tls_segment(const ir_node *node)
 unsigned get_ia32_am_scale(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.am_scale;
+	return attr->am_scale;
 }
 
 /**
@@ -495,7 +495,7 @@ void set_ia32_am_scale(ir_node *node, unsigned scale)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
 	assert(scale <= 3 && "AM scale out of range [0 ... 3]");
-	attr->data.am_scale = scale;
+	attr->am_scale = scale;
 }
 
 void ia32_copy_am_attrs(ir_node *to, const ir_node *from)
@@ -514,8 +514,8 @@ void ia32_copy_am_attrs(ir_node *to, const ir_node *from)
  */
 void set_ia32_use_frame(ir_node *node)
 {
-	ia32_attr_t *attr    = get_ia32_attr(node);
-	attr->data.use_frame = 1;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->use_frame = 1;
 }
 
 /**
@@ -523,8 +523,8 @@ void set_ia32_use_frame(ir_node *node)
  */
 void clear_ia32_use_frame(ir_node *node)
 {
-	ia32_attr_t *attr    = get_ia32_attr(node);
-	attr->data.use_frame = 0;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->use_frame = 0;
 }
 
 /**
@@ -533,7 +533,7 @@ void clear_ia32_use_frame(ir_node *node)
 int is_ia32_use_frame(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.use_frame;
+	return attr->use_frame;
 }
 
 /**
@@ -541,8 +541,8 @@ int is_ia32_use_frame(const ir_node *node)
  */
 void set_ia32_commutative(ir_node *node)
 {
-	ia32_attr_t *attr         = get_ia32_attr(node);
-	attr->data.is_commutative = 1;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->is_commutative = 1;
 }
 
 /**
@@ -550,8 +550,8 @@ void set_ia32_commutative(ir_node *node)
  */
 void clear_ia32_commutative(ir_node *node)
 {
-	ia32_attr_t *attr         = get_ia32_attr(node);
-	attr->data.is_commutative = 0;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->is_commutative = 0;
 }
 
 /**
@@ -560,61 +560,61 @@ void clear_ia32_commutative(ir_node *node)
 int is_ia32_commutative(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.is_commutative;
+	return attr->is_commutative;
 }
 
 void set_ia32_need_stackent(ir_node *node)
 {
-	ia32_attr_t *attr     = get_ia32_attr(node);
-	attr->data.need_stackent = 1;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->need_stackent = 1;
 }
 
 void clear_ia32_need_stackent(ir_node *node)
 {
-	ia32_attr_t *attr     = get_ia32_attr(node);
-	attr->data.need_stackent = 0;
+	ia32_attr_t *const attr = get_ia32_attr(node);
+	attr->need_stackent = 0;
 }
 
 int is_ia32_need_stackent(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.need_stackent;
+	return attr->need_stackent;
 }
 
 void set_ia32_is_reload(ir_node *node)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.is_reload = 1;
+	attr->is_reload = 1;
 }
 
 int is_ia32_is_reload(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.is_reload;
+	return attr->is_reload;
 }
 
 void set_ia32_is_spill(ir_node *node)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.is_spill = 1;
+	attr->is_spill = 1;
 }
 
 int is_ia32_is_spill(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.is_spill;
+	return attr->is_spill;
 }
 
 void set_ia32_is_remat(ir_node *node)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.is_remat = 1;
+	attr->is_remat = 1;
 }
 
 int is_ia32_is_remat(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.is_remat;
+	return attr->is_remat;
 }
 
 /**
@@ -705,7 +705,7 @@ unsigned get_ia32_copyb_size(const ir_node *node)
 unsigned get_ia32_exc_label(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
-	return attr->data.has_except_label;
+	return attr->has_except_label;
 }
 
 /**
@@ -714,7 +714,7 @@ unsigned get_ia32_exc_label(const ir_node *node)
 void set_ia32_exc_label(ir_node *node, unsigned flag)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
-	attr->data.has_except_label = flag;
+	attr->has_except_label = flag;
 }
 
 /**
@@ -724,7 +724,7 @@ ir_label_t get_ia32_exc_label_id(const ir_node *node)
 {
 	const ia32_attr_t *attr = get_ia32_attr_const(node);
 
-	assert(attr->data.has_except_label);
+	assert(attr->has_except_label);
 	return attr->exc_label;
 }
 
@@ -735,7 +735,7 @@ void set_ia32_exc_label_id(ir_node *node, ir_label_t id)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
 
-	assert(attr->data.has_except_label);
+	assert(attr->has_except_label);
 	attr->exc_label = id;
 }
 
@@ -770,7 +770,7 @@ void ia32_swap_left_right(ir_node *node)
 	ir_node     *right = get_irn_n(node, n_ia32_binary_right);
 
 	assert(is_ia32_commutative(node));
-	attr->data.ins_permuted = !attr->data.ins_permuted;
+	attr->ins_permuted = !attr->ins_permuted;
 	set_irn_n(node, n_ia32_binary_left,  right);
 	set_irn_n(node, n_ia32_binary_right, left);
 }
@@ -902,19 +902,19 @@ static int ia32_attrs_equal_(const ia32_attr_t *a, const ia32_attr_t *b)
 {
 	/* nodes with not yet assigned entities shouldn't be CSEd (important for
 	 * unsigned int -> double conversions */
-	if (a->data.use_frame && a->frame_ent == NULL)
+	if (a->use_frame && a->frame_ent == NULL)
 		return false;
 
-	return a->data.tp == b->data.tp
-	    && a->data.am_scale == b->data.am_scale
+	return a->tp == b->tp
+	    && a->am_scale == b->am_scale
 	    && a->am_offs == b->am_offs
 	    && a->am_ent == b->am_ent
-	    && a->data.am_sc_no_pic_adjust == b->data.am_sc_no_pic_adjust
+	    && a->am_sc_no_pic_adjust == b->am_sc_no_pic_adjust
 	    && a->ls_mode == b->ls_mode
-	    && a->data.use_frame == b->data.use_frame
+	    && a->use_frame == b->use_frame
 	    && a->frame_ent == b->frame_ent
-	    && a->data.has_except_label == b->data.has_except_label
-	    && a->data.ins_permuted == b->data.ins_permuted;
+	    && a->has_except_label == b->has_except_label
+	    && a->ins_permuted == b->ins_permuted;
 }
 
 /** Compare nodes attributes for all "normal" nodes. */

ir/be/ia32/ia32_nodes_attr.h

@@ -84,27 +84,25 @@ typedef enum {
 typedef struct ia32_attr_t ia32_attr_t;
 struct ia32_attr_t {
 	except_attr  exc;               /**< the exception attribute. MUST be the first one. */
-	struct ia32_attr_data_bitfield {
-		unsigned tp:3;                  /**< ia32 node type. */
-		unsigned am_arity:2;            /**< Indicates the address mode type supported by this node. */
-		unsigned am_scale:2;            /**< The address mode scale for index register. */
-
-		unsigned am_sc_no_pic_adjust : 1;/**< AM entity can be relative to EIP */
-		unsigned am_tls_segment:1;       /**< addresses are relative to TLS */
-		unsigned use_frame:1;           /**< Indicates whether the operation uses the frame pointer or not. */
-		unsigned has_except_label:1;        /**< Set if this node needs a label because of possible exception. */
-
-		unsigned is_commutative:1;      /**< Indicates whether op is commutative or not. */
-
-		unsigned need_stackent:1;       /**< Set to 1 if node need space on stack. */
-		unsigned need_64bit_stackent:1; /**< needs a 64bit stack entity (see double->unsigned int conv) */
-		unsigned need_32bit_stackent:1; /**< needs a 32bit stack entity */
-		unsigned ins_permuted : 1;      /**< inputs of node have been permuted
-		                                     (for commutative nodes) */
-		unsigned is_reload : 1;         /**< node performs a reload */
-		unsigned is_spill : 1;
-		unsigned is_remat : 1;
-	} data;
+
+	unsigned tp:3;                  /**< ia32 node type. */
+	unsigned am_arity:2;            /**< Indicates the address mode type supported by this node. */
+	unsigned am_scale:2;            /**< The address mode scale for index register. */
+
+	unsigned am_sc_no_pic_adjust:1; /**< AM entity can be relative to EIP */
+	unsigned am_tls_segment:1;      /**< addresses are relative to TLS */
+	unsigned use_frame:1;           /**< Indicates whether the operation uses the frame pointer or not. */
+	unsigned has_except_label:1;        /**< Set if this node needs a label because of possible exception. */
+
+	unsigned is_commutative:1;      /**< Indicates whether op is commutative or not. */
+
+	unsigned need_stackent:1;       /**< Set to 1 if node need space on stack. */
+	unsigned need_64bit_stackent:1; /**< needs a 64bit stack entity (see double->unsigned int conv) */
+	unsigned need_32bit_stackent:1; /**< needs a 32bit stack entity */
+	unsigned ins_permuted:1;        /**< inputs of node have been permuted (for commutative nodes) */
+	unsigned is_reload:1;           /**< node performs a reload */
+	unsigned is_spill:1;
+	unsigned is_remat:1;
 
 	int32_t    am_offs;       /**< offsets for AddrMode */
 	ir_entity *am_ent;        /**< entity for AddrMode */

ir/be/ia32/ia32_optimize.c

@@ -140,7 +140,7 @@ static void peephole_ia32_Cmp(ir_node *const node)
 	ir_node  *const noreg        = ia32_new_NoReg_gp(irg);
 	ir_node  *const nomem        = get_irg_no_mem(irg);
 	ir_node  *const op           = get_irn_n(node, n_ia32_Cmp_left);
-	int       const ins_permuted = get_ia32_attr(node)->data.ins_permuted;
+	int       const ins_permuted = get_ia32_attr(node)->ins_permuted;
 
 	ir_mode *const ls_mode = get_ia32_ls_mode(node);
 	ir_node *const test    = get_mode_size_bits(ls_mode) == 8
@@ -764,7 +764,7 @@ static ir_node *create_immediate_from_am(const ir_node *node)
 	ir_node           *block            = get_nodes_block(node);
 	int                offset           = get_ia32_am_offs_int(node);
 	const ia32_attr_t *attr             = get_ia32_attr_const(node);
-	int                sc_no_pic_adjust = attr->data.am_sc_no_pic_adjust;
+	int                sc_no_pic_adjust = attr->am_sc_no_pic_adjust;
 	ir_entity         *entity           = get_ia32_am_ent(node);
 
 	ir_node *res = new_bd_ia32_Immediate(NULL, block, entity, sc_no_pic_adjust, offset);

ir/be/ia32/ia32_spec.pl

@@ -764,7 +764,7 @@ Cmp => {
 	am        => "source,binary",
 	emit      => "cmp%M %B",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->data.ins_permuted   = ins_permuted;",
+	init_attr => "attr->ins_permuted = ins_permuted;",
 	latency   => 1,
 	mode      => $mode_flags,
 	modified_flags => $status_flags
@@ -792,7 +792,7 @@ Test => {
 	am        => "source,binary",
 	emit      => "test%M %B",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->data.ins_permuted = ins_permuted;",
+	init_attr => "attr->ins_permuted = ins_permuted;",
 	latency   => 1,
 	mode      => $mode_flags,
 	modified_flags => $status_flags
@@ -1629,7 +1629,7 @@ Ucomi => {
 	outs      => [ "flags" ],
 	am        => "source,binary",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->data.ins_permuted = ins_permuted;",
+	init_attr => "attr->ins_permuted = ins_permuted;",
 	emit      => "ucomis%FX %B",
 	latency   => 3,
 	mode      => $mode_flags,
@@ -2039,7 +2039,7 @@ FucomFnstsw => {
 	emit      => "fucom%FP %F0\n".
 	             "fnstsw %%ax",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
+	init_attr => "attr->attr.ins_permuted = ins_permuted;",
 	latency   => 3,
 	attr_type => "ia32_x87_attr_t",
 	mode      => $mode_gp
@@ -2055,7 +2055,7 @@ FucomppFnstsw => {
 	emit      => "fucompp\n".
 	             "fnstsw %%ax",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
+	init_attr => "attr->attr.ins_permuted = ins_permuted;",
 	latency   => 3,
 	attr_type => "ia32_x87_attr_t",
 	mode      => $mode_gp
@@ -2068,7 +2068,7 @@ Fucomi => {
 	outs      => [ "flags" ],
 	emit      => "fucom%FPi %F0",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
+	init_attr => "attr->attr.ins_permuted = ins_permuted;",
 	latency   => 3,
 	attr_type => "ia32_x87_attr_t",
 	mode      => $mode_gp
@@ -2082,7 +2082,7 @@ FtstFnstsw => {
 	emit      => "ftst\n".
 	             "fnstsw %%ax",
 	attr      => "bool ins_permuted",
-	init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
+	init_attr => "attr->attr.ins_permuted = ins_permuted;",
 	latency   => 3,
 	attr_type => "ia32_x87_attr_t",
 	mode      => $mode_gp

ir/be/ia32/ia32_transform.c

@@ -1134,7 +1134,7 @@ static ir_node *gen_binop_x87_float(ir_node *node, ir_node *op1, ir_node *op2,
 	set_am_attributes(new_node, &am);
 
 	ia32_x87_attr_t *attr = get_ia32_x87_attr(new_node);
-	attr->attr.data.ins_permuted = am.ins_permuted;
+	attr->attr.ins_permuted = am.ins_permuted;
 
 	SET_IA32_ORIG_NODE(new_node, node);
 
@@ -2875,7 +2875,7 @@ static ir_node *gen_Switch(ir_node *node)
 	set_ia32_ls_mode(new_node, ia32_mode_gp);
 	SET_IA32_ORIG_NODE(new_node, node);
 	// FIXME This seems wrong. GCC uses PIC for switch on OS X.
-	get_ia32_attr(new_node)->data.am_sc_no_pic_adjust = true;
+	get_ia32_attr(new_node)->am_sc_no_pic_adjust = true;
 
 	return new_node;
 }
@@ -3699,10 +3699,10 @@ static void force_int_stackent(ir_node *node, ir_mode *mode)
 {
 	ia32_attr_t *attr = get_ia32_attr(node);
 	if (get_mode_size_bits(mode) == 64) {
-		attr->data.need_64bit_stackent = true;
+		attr->need_64bit_stackent = true;
 	} else {
 		assert(get_mode_size_bits(mode) == 32);
-		attr->data.need_32bit_stackent = true;
+		attr->need_32bit_stackent = true;
 	}
 }
 
@@ -3842,7 +3842,7 @@ static void store_gp(dbg_info *dbgi, ia32_address_mode_t *am, ir_node *block,
 		set_ia32_ls_mode(zero_store, ia32_mode_gp);
 		arch_add_irn_flags(zero_store, arch_irn_flag_spill);
 		ia32_attr_t *zero_store_attr = get_ia32_attr(zero_store);
-		zero_store_attr->data.need_64bit_stackent = true;
+		zero_store_attr->need_64bit_stackent = true;
 
 		in[0] = zero_store_mem;
 		in[1] = store_mem;

ir/be/ia32/ia32_x87.c

@@ -709,8 +709,8 @@ static void sim_binop(x87_state *const state, ir_node *const n)
 				x87_create_fxch(state, n, op1_idx);
 		}
 
-		op1_idx = attr->attr.data.ins_permuted ? -1 :  0;
-		op2_idx = attr->attr.data.ins_permuted ?  0 : (unsigned)-1;
+		op1_idx = attr->attr.ins_permuted ? -1 :  0;
+		op2_idx = attr->attr.ins_permuted ?  0 : (unsigned)-1;
 		out_idx = 0;
 	}
 	assert(op1_idx == 0       || op2_idx == 0);
@@ -722,10 +722,10 @@ static void sim_binop(x87_state *const state, ir_node *const n)
 
 	/* patch the operation */
 	unsigned const reg_idx = op1_idx != 0 ? op1_idx : op2_idx;
-	attr->reg                    = reg_idx != (unsigned)-1 ? get_st_reg(reg_idx) : NULL;
-	attr->attr.data.ins_permuted = op1_idx != 0;
-	attr->res_in_reg             = out_idx != 0;
-	attr->pop                    = pop;
+	attr->reg               = reg_idx != (unsigned)-1 ? get_st_reg(reg_idx) : NULL;
+	attr->attr.ins_permuted = op1_idx != 0;
+	attr->res_in_reg        = out_idx != 0;
+	attr->pop               = pop;
 
 	DEBUG_ONLY(
 		char const *const l = op1_idx != (unsigned)-1 ? get_st_reg(op1_idx)->name : "[AM]";
@@ -1038,8 +1038,8 @@ static void sim_Fucom(x87_state *state, ir_node *n)
 		if (!is_fp_live(reg_index_1, live))
 			pops = 1;
 
-		op1_idx = attr->attr.data.ins_permuted ? (unsigned)-1 :            0;
-		op2_idx = attr->attr.data.ins_permuted ?            0 : (unsigned)-1;
+		op1_idx = attr->attr.ins_permuted ? (unsigned)-1 :            0;
+		op2_idx = attr->attr.ins_permuted ?            0 : (unsigned)-1;
 	}
 	assert(op1_idx == 0 || op2_idx == 0);
 
@@ -1058,9 +1058,9 @@ static void sim_Fucom(x87_state *state, ir_node *n)
 	}
 
 	unsigned const reg_idx = op1_idx != 0 ? op1_idx : op2_idx;
-	attr->reg                    = reg_idx != (unsigned)-1 ? get_st_reg(reg_idx) : NULL;
-	attr->attr.data.ins_permuted = op1_idx != 0;
-	attr->pop                    = pops != 0;
+	attr->reg               = reg_idx != (unsigned)-1 ? get_st_reg(reg_idx) : NULL;
+	attr->attr.ins_permuted = op1_idx != 0;
+	attr->pop               = pops != 0;
 
 	DEBUG_ONLY(
 		char const *const l = op1_idx != (unsigned)-1 ? get_st_reg(op1_idx)->name : "[AM]";