From patchwork Mon Nov 29 12:01:17 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joern Rennecke X-Patchwork-Id: 73417 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id BA1DFB70E6 for ; Mon, 29 Nov 2010 23:01:38 +1100 (EST) Received: (qmail 18644 invoked by alias); 29 Nov 2010 12:01:33 -0000 Received: (qmail 18626 invoked by uid 22791); 29 Nov 2010 12:01:28 -0000 X-SWARE-Spam-Status: No, hits=-2.4 required=5.0 tests=AWL, BAYES_00, MIME_QP_LONG_LINE, RCVD_IN_DNSWL_LOW, TW_CR, TW_JC X-Spam-Check-By: sourceware.org Received: from c60.cesmail.net (HELO c60.cesmail.net) (216.154.195.49) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Mon, 29 Nov 2010 12:01:20 +0000 Received: from unknown (HELO epsilon2) ([192.168.1.60]) by c60.cesmail.net with ESMTP; 29 Nov 2010 07:01:17 -0500 Received: from 89.241.153.50 ([89.241.153.50]) by webmail.spamcop.net (Horde MIME library) with HTTP; Mon, 29 Nov 2010 07:01:17 -0500 Message-ID: <20101129070117.ar5qwmbkg840ws4o-nzlynne@webmail.spamcop.net> Date: Mon, 29 Nov 2010 07:01:17 -0500 From: Joern Rennecke To: gcc-patches@gcc.gnu.org Subject: RFA: partially hookize POINTER_SIZE MIME-Version: 1.0 User-Agent: Internet Messaging Program (IMP) H3 (4.1.4) Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org This patch replaces uses of POINTER_SIZE in the frontends. as discussed in PR46677, in frontend contexts where ptr_type_node - or in the case of java, size_type - is known to be set, TYPE_PRECISION of this type is used; otherwise, a function pointer_size in targhooks.c is used, which in turn uses targetm.addr_space.pointer_mode, and, if necessary, POINTER_SIZE. bootstrapped & regression tested on i686-pc-linux-gnu cross-tested for: alpha-linux-gnu hppa-linux-gnu mips-elf sh-elf arc-elf ia64-elf mmix-knuth-mmixware sparc-elf arm-eabi iq2000-elf mn10300-elf spu-elf avr-elf lm32-elf moxie-elf v850-elf bfin-elf m32c-elf pdp11-aout vax-linux-gnu cris-elf m32r-elf picochip-elf xstormy16-elf crx-elf m68hc11-elf ppc-elf xtensa-elf fr30-elf m68k-elf rx-elf frv-elf mcore-elf s390-linux-gnu h8300-elf mep-elf score-elf microblaze-elf bootstrapped & Ada regtested on x86_64-linux-gnu. 2010-11-29 Joern Rennecke PR other/46677 gcc: * targhooks.c (pointer_size): New function. * cppbuiltin.c (define_builtin_macros_for_lp64): Use pointer_size. (define_builtin_macros_for_type_sizes): Likewise. * target.h (pointer_size): Declare. * cppbuiltin.c (define_builtin_macros_for_type_sizes): Use TYPE_PRECISION (char_type_node). gcc/c-family: c-common.c (c_common_nodes_and_builtins): Use pointer_size. gcc/java: * decl.c (java_init_decl_processing): Use pointer_size. * java-tree.h (JAVA_POINTER_SIZE): Define. * class.c (make_class_data): Use JAVA_POINTER_SIZE. (emit_register_classes): Likewise. * jcf-parse.c (handle_long_constant): Likewise. * constants.c (build_constants_constructor): Likewise. * builtins.c (UNMARSHAL3, UNMARSHAL4, UNMARSHAL5): Likewise. (compareAndSwapObject_builtin): Likewise. * boehm.c (get_boehm_type_descriptor): Likewise. (mark_reference_fields): Add log2_size parameter. Changed all callers. gcc/cp: * cvt.c (cp_convert_to_pointer): Use TYPE_PRECISION (ptr_type_node). gcc/fortran: * trans-types.c (gfc_init_kinds): Use pointer_size. gcc/lto: * lto-object.c (lto_obj_begin_section): Use pointer_size. ada: * gcc-interface/decl.c (gnat_to_gnu_entity): Replace pointer_size with pointer_size_t. Replace POINTER_SIZE with pointer_size (). (rest_of_type_decl_compilation_no_defer): Use pointer_size. (gnat_to_gnu_param, annotate_rep, make_type_from_size): Likewise. * gcc-interface/utils2.c: Include target.h . (maybe_wrap_malloc, maybe_wrap_free): Use pointer_size. * gcc-interface/targtyps.c: Include target.h . (get_target_pointer_size): Use pointer_size. Index: targhooks.c =================================================================== --- targhooks.c (revision 167235) +++ targhooks.c (working copy) @@ -1362,4 +1362,23 @@ { OPT_LEVELS_NONE, 0, NULL, 0 } }; +/* Return the size of a pointer. This function might be used when + ptr_type_node is not / is not known to be set up, like in the + preprocessor. */ +unsigned +pointer_size (void) +{ + enum machine_mode + mode = targetm.addr_space.pointer_mode (ADDR_SPACE_GENERIC); + + /* If the hook definition uses ptr_mode, and we are called before + init_emit_once, e.g. from the preprocessor, we might see VOIDmode. */ + if (mode == VOIDmode) + { + gcc_assert (mode == ptr_mode); + return POINTER_SIZE; + } + return GET_MODE_BITSIZE (mode); +} + #include "gt-targhooks.h" Index: cppbuiltin.c =================================================================== --- cppbuiltin.c (revision 167235) +++ cppbuiltin.c (working copy) @@ -106,7 +106,7 @@ define_builtin_macros_for_lp64 (cpp_reader *pfile) { if (TYPE_PRECISION (long_integer_type_node) == 64 - && POINTER_SIZE == 64 + && pointer_size () == 64 && TYPE_PRECISION (integer_type_node) == 32) { cpp_define (pfile, "_LP64"); @@ -164,9 +164,13 @@ : "__ORDER_LITTLE_ENDIAN__")); /* ptr_type_node can't be used here since ptr_mode is only set when - toplev calls backend_init which is not done with -E switch. */ + toplev calls backend_init which is not done with -E switch. + In principle we could use + targetm.addr_space.pointer_mode (ADDR_SPACE_GENERIC), but we don't really + want the prepocessor to have to know about machine modes, and most + definitions of the hook also use ptr_mode. */ cpp_define_formatted (pfile, "__SIZEOF_POINTER__=%d", - POINTER_SIZE / BITS_PER_UNIT); + pointer_size () / TYPE_PRECISION (char_type_node)); } Index: c-family/c-common.c =================================================================== --- c-family/c-common.c (revision 167235) +++ c-family/c-common.c (working copy) @@ -4944,7 +4944,7 @@ /* Create the built-in __null node. It is important that this is not shared. */ null_node = make_node (INTEGER_CST); - TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0); + TREE_TYPE (null_node) = c_common_type_for_size (pointer_size (), 0); /* Since builtin_types isn't gc'ed, don't export these nodes. */ memset (builtin_types, 0, sizeof (builtin_types)); Index: java/class.c =================================================================== --- java/class.c (revision 167235) +++ java/class.c (working copy) @@ -1793,7 +1793,7 @@ tree id_class = get_identifier("java.lang.Class"); /** Offset from start of virtual function table declaration to where objects actually point at, following new g++ ABI. */ - tree dtable_start_offset = size_int (2 * POINTER_SIZE / BITS_PER_UNIT); + tree dtable_start_offset = size_int (2 * JAVA_POINTER_SIZE / BITS_PER_UNIT); VEC(int, heap) *field_indexes; tree first_real_field; VEC(constructor_elt,gc) *v1 = NULL, *v2 = NULL; @@ -2234,7 +2234,7 @@ DECL_INITIAL (decl) = cons; /* Hash synchronization requires at least 64-bit alignment. */ - if (flag_hash_synchronization && POINTER_SIZE < 64) + if (flag_hash_synchronization && JAVA_POINTER_SIZE < 64) DECL_ALIGN (decl) = 64; if (flag_indirect_classes) @@ -2831,12 +2831,13 @@ but doesn't have a JCR_SECTION_NAME. */ gcc_unreachable (); #endif - assemble_align (POINTER_SIZE); + assemble_align (JAVA_POINTER_SIZE); FOR_EACH_VEC_ELT (tree, registered_class, i, klass) { t = build_fold_addr_expr (klass); - output_constant (t, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE); + output_constant (t, JAVA_POINTER_SIZE / BITS_PER_UNIT, + JAVA_POINTER_SIZE); } } else Index: java/decl.c =================================================================== --- java/decl.c (revision 167235) +++ java/decl.c (working copy) @@ -606,8 +606,10 @@ /* This is not a java type, however tree-dfa requires a definition for size_type_node. */ - size_type_node = make_unsigned_type (POINTER_SIZE); + size_type_node = make_unsigned_type (pointer_size ()); set_sizetype (size_type_node); + /* Henceforth, we can use TYPE_PRECISION (size_type_node) when we mean + pointer_size () for the current target, to avoid unnecessary overhead. */ /* Define these next since types below may used them. */ integer_type_node = java_type_for_size (INT_TYPE_SIZE, 0); Index: java/jcf-parse.c =================================================================== --- java/jcf-parse.c (revision 167235) +++ java/jcf-parse.c (working copy) @@ -475,7 +475,7 @@ { /* If we're on a 64-bit platform we can fit a long or double into the same space as a jword. */ - if (POINTER_SIZE >= 64) + if (JAVA_POINTER_SIZE >= 64) index = find_constant1 (cpool, kind, JPOOL_LONG (jcf, index)); /* In a compiled program the constant pool is in native word Index: java/constants.c =================================================================== --- java/constants.c (revision 167235) +++ java/constants.c (working copy) @@ -541,7 +541,7 @@ not a scalar but a union, and that's how we should represent it in the compiler. We should fix this. */ if (BYTES_BIG_ENDIAN) - temp <<= ((POINTER_SIZE > 32) ? POINTER_SIZE - 32 : 0); + temp <<= ((JAVA_POINTER_SIZE > 32) ? JAVA_POINTER_SIZE - 32 : 0); CONSTRUCTOR_PREPEND_VALUE (t, get_tag_node (outgoing_cpool->tags[i])); CONSTRUCTOR_PREPEND_VALUE (d, Index: java/builtins.c =================================================================== --- java/builtins.c (revision 167235) +++ java/builtins.c (working copy) @@ -244,7 +244,7 @@ tree orig_method_call = METHOD_CALL; \ this_arg = CALL_EXPR_ARG (orig_method_call, 0); \ obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \ - offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \ + offset_arg = fold_convert (java_type_for_size (JAVA_POINTER_SIZE, 0), \ CALL_EXPR_ARG (orig_method_call, 2)); \ } \ while (0) @@ -256,7 +256,7 @@ tree orig_method_call = METHOD_CALL; \ this_arg = CALL_EXPR_ARG (orig_method_call, 0); \ obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \ - offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \ + offset_arg = fold_convert (java_type_for_size (JAVA_POINTER_SIZE, 0), \ CALL_EXPR_ARG (orig_method_call, 2)); \ value_arg = CALL_EXPR_ARG (orig_method_call, 3); \ value_type = TREE_TYPE (value_arg); \ @@ -270,7 +270,7 @@ tree orig_method_call = METHOD_CALL; \ this_arg = CALL_EXPR_ARG (orig_method_call, 0); \ obj_arg = CALL_EXPR_ARG (orig_method_call, 1); \ - offset_arg = fold_convert (java_type_for_size (POINTER_SIZE, 0), \ + offset_arg = fold_convert (java_type_for_size (JAVA_POINTER_SIZE, 0), \ CALL_EXPR_ARG (orig_method_call, 2)); \ expected_arg = CALL_EXPR_ARG (orig_method_call, 3); \ value_arg = CALL_EXPR_ARG (orig_method_call, 4); \ @@ -378,7 +378,7 @@ int builtin; UNMARSHAL5 (orig_call); - builtin = (POINTER_SIZE == 32 + builtin = (JAVA_POINTER_SIZE == 32 ? BUILT_IN_BOOL_COMPARE_AND_SWAP_4 : BUILT_IN_BOOL_COMPARE_AND_SWAP_8); Index: java/java-tree.h =================================================================== --- java/java-tree.h (revision 167235) +++ java/java-tree.h (working copy) @@ -1516,4 +1516,12 @@ extern FILE *finput; +/* Frontends shouldn't use POINTER_SIZE, since that is a target macro. + We can't use TYPE_PRECISION (ptr_type_node), since that node isn't + available for java. + Luckily, sizetype is set with the precision of pointer_size (), + so we don't have to call pointer_size all the time once sizetype + has been set up. */ +#define JAVA_POINTER_SIZE (TYPE_PRECISION (sizetype)) + #endif /* ! GCC_JAVA_TREE_H */ Index: java/boehm.c =================================================================== --- java/boehm.c (revision 167235) +++ java/boehm.c (working copy) @@ -36,7 +36,8 @@ #include "toplev.h" static void mark_reference_fields (tree, double_int *, unsigned int, - int *, int *, int *, HOST_WIDE_INT *); + int *, int *, int *, HOST_WIDE_INT *, + unsigned int); /* A procedure-based object descriptor. We know that our `kind' is 0, and `env' is likewise 0, so we have a simple @@ -54,7 +55,8 @@ int *pointer_after_end, int *all_bits_set, int *last_set_index, - HOST_WIDE_INT *last_view_index) + HOST_WIDE_INT *last_view_index, + unsigned int log2_size) { /* See if we have fields from our superclass. */ if (DECL_NAME (field) == NULL_TREE) @@ -62,7 +64,7 @@ mark_reference_fields (TYPE_FIELDS (TREE_TYPE (field)), mask, ubit, pointer_after_end, all_bits_set, - last_set_index, last_view_index); + last_set_index, last_view_index, log2_size); field = DECL_CHAIN (field); } @@ -90,15 +92,15 @@ we already covered, then we are doomed. */ gcc_assert (offset > *last_view_index); - if (offset % (HOST_WIDE_INT) (POINTER_SIZE / BITS_PER_UNIT)) + if (offset & ((1 << log2_size) - 1)) { *all_bits_set = -1; *pointer_after_end = 1; break; } - count = offset * BITS_PER_UNIT / POINTER_SIZE; - size_words = size_bytes * BITS_PER_UNIT / POINTER_SIZE; + count = offset >> log2_size; + size_words = size_bytes >> log2_size; *last_set_index = count; @@ -152,7 +154,7 @@ if (int_size_in_bytes (type) == -1) goto procedure_object_descriptor; - bit = POINTER_SIZE / BITS_PER_UNIT; + bit = JAVA_POINTER_SIZE / BITS_PER_UNIT; /* The size of this node has to be known. And, we only support 32 and 64 bit targets, so we need to know that the log2 is one of our values. */ @@ -175,7 +177,7 @@ field = TYPE_FIELDS (type); mark_reference_fields (field, &mask, ubit, &pointer_after_end, &all_bits_set, - &last_set_index, &last_view_index); + &last_set_index, &last_view_index, log2_size); /* If the object is all pointers, or if the part with pointers fits in our bitmap, then we are ok. Otherwise we have to allocate it Index: target.h =================================================================== --- target.h (revision 167235) +++ target.h (working copy) @@ -176,4 +176,8 @@ /* Each target can provide their own. */ extern struct gcc_targetcm targetcm; +/* Functions defined in targhooks.c that use target hooks and/or target + macros that make these values available to frontends / tree optimizers. */ +extern unsigned pointer_size (void); + #endif /* GCC_TARGET_H */ Index: cp/cvt.c =================================================================== --- cp/cvt.c (revision 167235) +++ cp/cvt.c (working copy) @@ -221,9 +221,12 @@ if (INTEGRAL_CODE_P (form)) { - if (TYPE_PRECISION (intype) == POINTER_SIZE) + if (TYPE_PRECISION (intype) == TYPE_PRECISION (ptr_type_node)) return build1 (CONVERT_EXPR, type, expr); - expr = cp_convert (c_common_type_for_size (POINTER_SIZE, 0), expr); + expr + = cp_convert (c_common_type_for_size (TYPE_PRECISION (ptr_type_node), + 0), + expr); /* Modes may be different but sizes should be the same. There is supposed to be some integral type that is the same width as a pointer. */ Index: ada/gcc-interface/decl.c =================================================================== --- ada/gcc-interface/decl.c (revision 167235) +++ ada/gcc-interface/decl.c (working copy) @@ -396,7 +396,7 @@ if (IN (kind, Float_Kind)) max_esize = fp_prec_to_size (LONG_DOUBLE_TYPE_SIZE); else if (IN (kind, Access_Kind)) - max_esize = POINTER_SIZE * 2; + max_esize = pointer_size () * 2; else max_esize = LONG_LONG_TYPE_SIZE; @@ -3714,7 +3714,7 @@ = TYPE_IS_FAT_POINTER_P (gnu_type) ? TYPE_UNCONSTRAINED_ARRAY (gnu_type) : TREE_TYPE (gnu_type); - if (esize == POINTER_SIZE + if (esize == pointer_size () && (got_fat_p || TYPE_IS_FAT_POINTER_P (gnu_type))) gnu_type = build_pointer_type @@ -4853,7 +4853,7 @@ { /* In this mode, the tag and the parent components are not generated by the front-end so the sizes must be adjusted. */ - tree pointer_size = bitsize_int (POINTER_SIZE), offset; + tree pointer_size_t = bitsize_int (pointer_size ()), offset; Uint uint_size; if (Is_Derived_Type (gnat_entity)) @@ -4864,13 +4864,13 @@ Alignment (Etype (Base_Type (gnat_entity)))); } else - offset = pointer_size; + offset = pointer_size_t; gnu_size = size_binop (PLUS_EXPR, gnu_size, offset); - gnu_size = size_binop (MULT_EXPR, pointer_size, + gnu_size = size_binop (MULT_EXPR, pointer_size_t, size_binop (CEIL_DIV_EXPR, gnu_size, - pointer_size)); + pointer_size_t)); uint_size = annotate_value (gnu_size); Set_Esize (gnat_entity, uint_size); Set_RM_Size (gnat_entity, uint_size); @@ -5107,7 +5107,7 @@ finish_fat_pointer_type (tree record_type, tree field_list) { /* Make sure we can put it into a register. */ - TYPE_ALIGN (record_type) = MIN (BIGGEST_ALIGNMENT, 2 * POINTER_SIZE); + TYPE_ALIGN (record_type) = MIN (BIGGEST_ALIGNMENT, 2 * pointer_size ()); /* Show what it really is. */ TYPE_FAT_POINTER_P (record_type) = 1; @@ -5393,7 +5393,7 @@ /* Fat pointers are passed as thin pointers for foreign conventions. */ else if (foreign && TYPE_IS_FAT_POINTER_P (gnu_param_type)) gnu_param_type - = make_type_from_size (gnu_param_type, size_int (POINTER_SIZE), 0); + = make_type_from_size (gnu_param_type, size_int (pointer_size ()), 0); /* If we must pass or were requested to pass by reference, do so. If we were requested to pass by copy, do so. @@ -7520,7 +7520,7 @@ = UI_To_gnu (Esize (Etype (Base_Type (gnat_entity))), bitsizetype); else - parent_offset = bitsize_int (POINTER_SIZE); + parent_offset = bitsize_int (pointer_size ()); } else parent_offset = bitsize_zero_node; @@ -7959,7 +7959,7 @@ case RECORD_TYPE: /* Do something if this is a fat pointer, in which case we may need to return the thin pointer. */ - if (TYPE_FAT_POINTER_P (type) && size < POINTER_SIZE * 2) + if (TYPE_FAT_POINTER_P (type) && size < pointer_size () * 2) { enum machine_mode p_mode = mode_for_size (size, MODE_INT, 0); if (!targetm.valid_pointer_mode (p_mode)) @@ -7974,7 +7974,7 @@ case POINTER_TYPE: /* Only do something if this is a thin pointer, in which case we may need to return the fat pointer. */ - if (TYPE_IS_THIN_POINTER_P (type) && size >= POINTER_SIZE * 2) + if (TYPE_IS_THIN_POINTER_P (type) && size >= pointer_size () * 2) return build_pointer_type (TYPE_UNCONSTRAINED_ARRAY (TREE_TYPE (type))); break; Index: ada/gcc-interface/targtyps.c =================================================================== --- ada/gcc-interface/targtyps.c (revision 167235) +++ ada/gcc-interface/targtyps.c (working copy) @@ -31,6 +31,7 @@ #include "tree.h" #include "tm.h" #include "tm_p.h" +#include "target.h" #include "ada.h" #include "types.h" @@ -131,7 +132,7 @@ Pos get_target_pointer_size (void) { - return POINTER_SIZE; + return pointer_size (); } /* Alignment related values, mapped to attributes for functional and Index: ada/gcc-interface/utils2.c =================================================================== --- ada/gcc-interface/utils2.c (revision 167235) +++ ada/gcc-interface/utils2.c (working copy) @@ -32,6 +32,7 @@ #include "ggc.h" #include "output.h" #include "tree-inline.h" +#include "target.h" #include "ada.h" #include "types.h" @@ -1941,7 +1942,7 @@ = ((data_align > default_allocator_alignment) ? make_aligning_type (data_type, data_align, data_size, default_allocator_alignment, - POINTER_SIZE / BITS_PER_UNIT) + pointer_size () / BITS_PER_UNIT) : NULL_TREE); tree size_to_malloc @@ -1952,7 +1953,7 @@ /* On VMS, if pointers are 64-bit and the allocator size is 32-bit or Convention C, allocate 32-bit memory. */ if (TARGET_ABI_OPEN_VMS - && POINTER_SIZE == 64 + && pointer_size () == 64 && Nkind (gnat_node) == N_Allocator && (UI_To_Int (Esize (Etype (gnat_node))) == 32 || Convention (Etype (gnat_node)) == Convention_C)) @@ -1984,7 +1985,7 @@ tree storage_ptr_slot_addr = build_binary_op (POINTER_PLUS_EXPR, ptr_void_type_node, convert (ptr_void_type_node, aligning_field_addr), - size_int (-(HOST_WIDE_INT) POINTER_SIZE + size_int (-(HOST_WIDE_INT) pointer_size () / BITS_PER_UNIT)); tree storage_ptr_slot @@ -2026,7 +2027,7 @@ = build_binary_op (POINTER_PLUS_EXPR, ptr_void_type_node, convert (ptr_void_type_node, data_ptr), - size_int (-(HOST_WIDE_INT) POINTER_SIZE / BITS_PER_UNIT)); + size_int (-(HOST_WIDE_INT) pointer_size () / BITS_PER_UNIT)); /* FREE_PTR (void *) = *(void **)DATA_FRONT_PTR */ free_ptr Index: fortran/trans-types.c =================================================================== --- fortran/trans-types.c (revision 167235) +++ fortran/trans-types.c (working copy) @@ -566,7 +566,7 @@ gfc_character_storage_size = gfc_default_character_kind * 8; /* Choose the integer kind the same size as "void*" for our index kind. */ - gfc_index_integer_kind = POINTER_SIZE / 8; + gfc_index_integer_kind = pointer_size () / 8; /* Pick a kind the same size as the C "int" type. */ gfc_c_int_kind = INT_TYPE_SIZE / 8; Index: fortran/f95-lang.c =================================================================== --- fortran/f95-lang.c (revision 167235) +++ fortran/f95-lang.c (working copy) @@ -583,7 +583,7 @@ want double_type_node to actually have double precision. */ build_common_tree_nodes (false); - size_type_node = gfc_build_uint_type (POINTER_SIZE); + size_type_node = gfc_build_uint_type (pointer_size ()); set_sizetype (size_type_node); build_common_tree_nodes_2 (0); Index: lto/lto-object.c =================================================================== --- lto/lto-object.c (revision 167235) +++ lto/lto-object.c (working copy) @@ -325,7 +325,7 @@ && lo->sobj_w != NULL && lo->section == NULL); - align = exact_log2 (POINTER_SIZE / BITS_PER_UNIT); + align = exact_log2 (pointer_size () / BITS_PER_UNIT); lo->section = simple_object_write_create_section (lo->sobj_w, name, align, &errmsg, &err); if (lo->section == NULL)