From patchwork Sat Sep 4 15:55:00 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tobias Burnus X-Patchwork-Id: 63796 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 AE151B7147 for ; Sun, 5 Sep 2010 01:55:41 +1000 (EST) Received: (qmail 17952 invoked by alias); 4 Sep 2010 15:55:34 -0000 Received: (qmail 17925 invoked by uid 22791); 4 Sep 2010 15:55:19 -0000 X-SWARE-Spam-Status: No, hits=-0.9 required=5.0 tests=AWL, BAYES_20, RCVD_IN_DNSWL_NONE, TW_TM X-Spam-Check-By: sourceware.org Received: from mx02.qsc.de (HELO mx02.qsc.de) (213.148.130.14) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Sat, 04 Sep 2010 15:55:05 +0000 Received: from [192.168.178.22] (port-92-204-40-202.dynamic.qsc.de [92.204.40.202]) by mx02.qsc.de (Postfix) with ESMTP id 15F2E1E173; Sat, 4 Sep 2010 17:55:00 +0200 (CEST) Message-ID: <4C826BD4.80700@net-b.de> Date: Sat, 04 Sep 2010 17:55:00 +0200 From: Tobias Burnus User-Agent: Mozilla/5.0 (X11; U; Linux x86_64; de; rv:1.9.2.7) Gecko/20100714 SUSE/3.1.1 Thunderbird/3.1.1 MIME-Version: 1.0 To: gcc patches , gfortran Subject: [Patch, Fortran] PR45186 - Part 3: gfortran 4.6 emits wrong line numbers 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 converts trans-intrinsic.c, f95-lang.c and convert.c from fold_build[0-9] to fold_build[0-9]_loc. Build and regtested on x86-64-linux. OK for the trunk? Todo: a) gcc/fortran/trans-array.c:198 b) Location fixes where input_location is the wrong location. Tobias PS: Unfortunately, it does not fix "gfortran.dg/pr25923.f90" with -m32, cf. PR 45505 2010-09-04 Tobias Burnus PR fortran/45186 * f95-lang.c (gfc_truthvalue_conversion): Use fold_build[0-9]_loc instead of fold_build[0-9]. * convert.c (convert): Ditto. * trans-intrinsic.c (gfc_conv_intrinsic_conversion, build_fixbound_expr, build_fix_expr, gfc_conv_intrinsic_aint, gfc_conv_intrinsic_int, gfc_conv_intrinsic_imagpart, gfc_conv_intrinsic_conjg, gfc_trans_same_strlen_check, gfc_conv_intrinsic_bound, gfc_conv_intrinsic_abs, gfc_conv_intrinsic_cmplx, gfc_conv_intrinsic_mod, gfc_conv_intrinsic_dim, gfc_conv_intrinsic_sign, gfc_conv_intrinsic_dprod, gfc_conv_intrinsic_char, gfc_conv_intrinsic_ctime, gfc_conv_intrinsic_fdate, gfc_conv_intrinsic_ttynam, gfc_conv_intrinsic_minmax, gfc_conv_intrinsic_minmax_char, gfc_conv_intrinsic_anyall, gfc_conv_intrinsic_count, gfc_conv_intrinsic_arith, gfc_conv_intrinsic_dot_product, gfc_conv_intrinsic_minmaxloc, gfc_conv_intrinsic_minmaxval, gfc_conv_intrinsic_btest, gfc_conv_intrinsic_bitop, gfc_conv_intrinsic_not, gfc_conv_intrinsic_singlebitop, gfc_conv_intrinsic_ibits, gfc_conv_intrinsic_rlshift, gfc_conv_intrinsic_ishft, gfc_conv_intrinsic_ishftc, gfc_conv_intrinsic_leadz, gfc_conv_intrinsic_trailz, gfc_conv_intrinsic_popcnt_poppar, gfc_conv_intrinsic_ichar, gfc_conv_has_intvalue, gfc_conv_intrinsic_merge, gfc_conv_intrinsic_spacing, gfc_conv_intrinsic_rrspacing, gfc_conv_intrinsic_size, size_of_string_in_bytes, gfc_conv_intrinsic_sizeof, gfc_conv_intrinsic_storage_size, gfc_conv_intrinsic_strcmp, gfc_conv_intrinsic_transfer, gfc_conv_allocated, gfc_conv_associated, gfc_conv_same_type_as, gfc_conv_intrinsic_trim, gfc_conv_intrinsic_repeat): Ditto. Index: gcc/fortran/trans-intrinsic.c =================================================================== --- gcc/fortran/trans-intrinsic.c (Revision 163859) +++ gcc/fortran/trans-intrinsic.c (Arbeitskopie) @@ -331,7 +331,8 @@ gfc_conv_intrinsic_conversion (gfc_se * tree artype; artype = TREE_TYPE (TREE_TYPE (args[0])); - args[0] = fold_build1 (REALPART_EXPR, artype, args[0]); + args[0] = fold_build1_loc (input_location, REALPART_EXPR, artype, + args[0]); } se->expr = convert (type, args[0]); @@ -357,11 +358,12 @@ build_fixbound_expr (stmtblock_t * pbloc intval = gfc_evaluate_now (intval, pblock); tmp = convert (argtype, intval); - cond = fold_build2 (up ? GE_EXPR : LE_EXPR, boolean_type_node, tmp, arg); + cond = fold_build2_loc (input_location, up ? GE_EXPR : LE_EXPR, + boolean_type_node, tmp, arg); - tmp = fold_build2 (up ? PLUS_EXPR : MINUS_EXPR, type, intval, - build_int_cst (type, 1)); - tmp = fold_build3 (COND_EXPR, type, cond, intval, tmp); + tmp = fold_build2_loc (input_location, up ? PLUS_EXPR : MINUS_EXPR, type, + intval, build_int_cst (type, 1)); + tmp = fold_build3_loc (input_location, COND_EXPR, type, cond, intval, tmp); return tmp; } @@ -424,7 +426,7 @@ build_fix_expr (stmtblock_t * pblock, tr break; case RND_TRUNC: - return fold_build1 (FIX_TRUNC_EXPR, type, arg); + return fold_build1_loc (input_location, FIX_TRUNC_EXPR, type, arg); break; default: @@ -496,17 +498,21 @@ gfc_conv_intrinsic_aint (gfc_se * se, gf n = gfc_validate_kind (BT_INTEGER, kind, false); mpfr_set_z (huge, gfc_integer_kinds[n].huge, GFC_RND_MODE); tmp = gfc_conv_mpfr_to_tree (huge, kind, 0); - cond = fold_build2 (LT_EXPR, boolean_type_node, arg[0], tmp); + cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, arg[0], + tmp); mpfr_neg (huge, huge, GFC_RND_MODE); tmp = gfc_conv_mpfr_to_tree (huge, kind, 0); - tmp = fold_build2 (GT_EXPR, boolean_type_node, arg[0], tmp); - cond = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, cond, tmp); + tmp = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, arg[0], + tmp); + cond = fold_build2_loc (input_location, TRUTH_AND_EXPR, boolean_type_node, + cond, tmp); itype = gfc_get_int_type (kind); tmp = build_fix_expr (&se->pre, arg[0], itype, op); tmp = convert (type, tmp); - se->expr = fold_build3 (COND_EXPR, type, cond, tmp, arg[0]); + se->expr = fold_build3_loc (input_location, COND_EXPR, type, cond, tmp, + arg[0]); mpfr_clear (huge); } @@ -544,7 +550,8 @@ gfc_conv_intrinsic_int (gfc_se * se, gfc tree artype; artype = TREE_TYPE (TREE_TYPE (args[0])); - args[0] = fold_build1 (REALPART_EXPR, artype, args[0]); + args[0] = fold_build1_loc (input_location, REALPART_EXPR, artype, + args[0]); } se->expr = build_fix_expr (&se->pre, args[0], type, op); @@ -560,7 +567,8 @@ gfc_conv_intrinsic_imagpart (gfc_se * se tree arg; gfc_conv_intrinsic_function_args (se, expr, &arg, 1); - se->expr = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); + se->expr = fold_build1_loc (input_location, IMAGPART_EXPR, + TREE_TYPE (TREE_TYPE (arg)), arg); } @@ -572,7 +580,7 @@ gfc_conv_intrinsic_conjg (gfc_se * se, g tree arg; gfc_conv_intrinsic_function_args (se, expr, &arg, 1); - se->expr = fold_build1 (CONJ_EXPR, TREE_TYPE (arg), arg); + se->expr = fold_build1_loc (input_location, CONJ_EXPR, TREE_TYPE (arg), arg); } @@ -875,7 +883,7 @@ gfc_trans_same_strlen_check (const char* return; /* Compare the two string lengths. */ - cond = fold_build2 (NE_EXPR, boolean_type_node, a, b); + cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, a, b); /* Output the runtime-check. */ name = gfc_build_cstring_const (intr_name); @@ -942,8 +950,9 @@ gfc_conv_intrinsic_bound (gfc_se * se, g gcc_assert (se->ss->expr == expr); gfc_advance_se_ss_chain (se); bound = se->loop->loopvar[0]; - bound = fold_build2 (MINUS_EXPR, gfc_array_index_type, bound, - se->loop->from[0]); + bound = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, bound, + se->loop->from[0]); } else { @@ -954,8 +963,9 @@ gfc_conv_intrinsic_bound (gfc_se * se, g gfc_add_block_to_block (&se->pre, &argse.pre); bound = argse.expr; /* Convert from one based to zero based. */ - bound = fold_build2 (MINUS_EXPR, gfc_array_index_type, bound, - gfc_index_one_node); + bound = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, bound, + gfc_index_one_node); } /* TODO: don't re-evaluate the descriptor on each iteration. */ @@ -985,11 +995,13 @@ gfc_conv_intrinsic_bound (gfc_se * se, g if (gfc_option.rtcheck & GFC_RTCHECK_BOUNDS) { bound = gfc_evaluate_now (bound, &se->pre); - cond = fold_build2 (LT_EXPR, boolean_type_node, - bound, build_int_cst (TREE_TYPE (bound), 0)); + cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, + bound, build_int_cst (TREE_TYPE (bound), 0)); tmp = gfc_rank_cst[GFC_TYPE_ARRAY_RANK (TREE_TYPE (desc))]; - tmp = fold_build2 (GE_EXPR, boolean_type_node, bound, tmp); - cond = fold_build2 (TRUTH_ORIF_EXPR, boolean_type_node, cond, tmp); + tmp = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, + bound, tmp); + cond = fold_build2_loc (input_location, TRUTH_ORIF_EXPR, + boolean_type_node, cond, tmp); gfc_trans_runtime_check (true, false, cond, &se->pre, &expr->where, gfc_msg_fault); } @@ -1025,53 +1037,63 @@ gfc_conv_intrinsic_bound (gfc_se * se, g { tree stride = gfc_conv_descriptor_stride_get (desc, bound); - cond1 = fold_build2 (GE_EXPR, boolean_type_node, ubound, lbound); - - cond3 = fold_build2 (GE_EXPR, boolean_type_node, stride, - gfc_index_zero_node); - cond3 = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, cond3, cond1); - - cond4 = fold_build2 (LT_EXPR, boolean_type_node, stride, - gfc_index_zero_node); + cond1 = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, + ubound, lbound); + cond3 = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, + stride, gfc_index_zero_node); + cond3 = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, cond3, cond1); + cond4 = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, + stride, gfc_index_zero_node); if (upper) { tree cond5; - cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond3, cond4); - - cond5 = fold_build2 (EQ_EXPR, boolean_type_node, gfc_index_one_node, lbound); - cond5 = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, cond4, cond5); - - cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond, cond5); - - se->expr = fold_build3 (COND_EXPR, gfc_array_index_type, cond, - ubound, gfc_index_zero_node); + cond = fold_build2_loc (input_location, TRUTH_OR_EXPR, + boolean_type_node, cond3, cond4); + cond5 = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + gfc_index_one_node, lbound); + cond5 = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, cond4, cond5); + + cond = fold_build2_loc (input_location, TRUTH_OR_EXPR, + boolean_type_node, cond, cond5); + + se->expr = fold_build3_loc (input_location, COND_EXPR, + gfc_array_index_type, cond, + ubound, gfc_index_zero_node); } else { if (as->type == AS_ASSUMED_SIZE) - cond = fold_build2 (EQ_EXPR, boolean_type_node, bound, - build_int_cst (TREE_TYPE (bound), - arg->expr->rank - 1)); + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + bound, build_int_cst (TREE_TYPE (bound), + arg->expr->rank - 1)); else cond = boolean_false_node; - cond1 = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond3, cond4); - cond = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, cond, cond1); - - se->expr = fold_build3 (COND_EXPR, gfc_array_index_type, cond, - lbound, gfc_index_one_node); + cond1 = fold_build2_loc (input_location, TRUTH_OR_EXPR, + boolean_type_node, cond3, cond4); + cond = fold_build2_loc (input_location, TRUTH_OR_EXPR, + boolean_type_node, cond, cond1); + + se->expr = fold_build3_loc (input_location, COND_EXPR, + gfc_array_index_type, cond, + lbound, gfc_index_one_node); } } else { if (upper) { - size = fold_build2 (MINUS_EXPR, gfc_array_index_type, ubound, lbound); - se->expr = fold_build2 (PLUS_EXPR, gfc_array_index_type, size, + size = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, ubound, lbound); + se->expr = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, size, gfc_index_one_node); - se->expr = fold_build2 (MAX_EXPR, gfc_array_index_type, se->expr, - gfc_index_zero_node); + se->expr = fold_build2_loc (input_location, MAX_EXPR, + gfc_array_index_type, se->expr, + gfc_index_zero_node); } else se->expr = gfc_index_one_node; @@ -1093,7 +1115,8 @@ gfc_conv_intrinsic_abs (gfc_se * se, gfc { case BT_INTEGER: case BT_REAL: - se->expr = fold_build1 (ABS_EXPR, TREE_TYPE (arg), arg); + se->expr = fold_build1_loc (input_location, ABS_EXPR, TREE_TYPE (arg), + arg); break; case BT_COMPLEX: @@ -1128,14 +1151,14 @@ gfc_conv_intrinsic_cmplx (gfc_se * se, g imag = convert (TREE_TYPE (type), args[1]); else if (TREE_CODE (TREE_TYPE (args[0])) == COMPLEX_TYPE) { - imag = fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (args[0])), - args[0]); + imag = fold_build1_loc (input_location, IMAGPART_EXPR, + TREE_TYPE (TREE_TYPE (args[0])), args[0]); imag = convert (TREE_TYPE (type), imag); } else imag = build_real_from_int_cst (TREE_TYPE (type), integer_zero_node); - se->expr = fold_build2 (COMPLEX_EXPR, type, real, imag); + se->expr = fold_build2_loc (input_location, COMPLEX_EXPR, type, real, imag); } /* Remainder function MOD(A, P) = A - INT(A / P) * P @@ -1164,9 +1187,11 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc type = TREE_TYPE (args[0]); if (modulo) - se->expr = fold_build2 (FLOOR_MOD_EXPR, type, args[0], args[1]); + se->expr = fold_build2_loc (input_location, FLOOR_MOD_EXPR, type, + args[0], args[1]); else - se->expr = fold_build2 (TRUNC_MOD_EXPR, type, args[0], args[1]); + se->expr = fold_build2_loc (input_location, TRUNC_MOD_EXPR, type, + args[0], args[1]); break; case BT_REAL: @@ -1201,21 +1226,26 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc { tree zero = gfc_build_const (type, integer_zero_node); tmp = gfc_evaluate_now (se->expr, &se->pre); - test = fold_build2 (LT_EXPR, boolean_type_node, args[0], zero); - test2 = fold_build2 (LT_EXPR, boolean_type_node, args[1], zero); - test2 = fold_build2 (TRUTH_XOR_EXPR, boolean_type_node, test, test2); - test = fold_build2 (NE_EXPR, boolean_type_node, tmp, zero); - test = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, test, test2); + test = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, + args[0], zero); + test2 = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, + args[1], zero); + test2 = fold_build2_loc (input_location, TRUTH_XOR_EXPR, + boolean_type_node, test, test2); + test = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, + tmp, zero); + test = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, test, test2); test = gfc_evaluate_now (test, &se->pre); - se->expr = fold_build3 (COND_EXPR, type, test, - fold_build2 (PLUS_EXPR, type, tmp, args[1]), - tmp); + se->expr = fold_build3_loc (input_location, COND_EXPR, type, test, + fold_build2_loc (input_location, PLUS_EXPR, + type, tmp, args[1]), tmp); return; } /* If we do not have a built_in fmod, the calculation is going to have to be done longhand. */ - tmp = fold_build2 (RDIV_EXPR, type, args[0], args[1]); + tmp = fold_build2_loc (input_location, RDIV_EXPR, type, args[0], args[1]); /* Test if the value is too large to handle sensibly. */ gfc_set_model_kind (expr->ts.kind); @@ -1229,12 +1259,15 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc } mpfr_set_z (huge, gfc_integer_kinds[n].huge, GFC_RND_MODE); test = gfc_conv_mpfr_to_tree (huge, expr->ts.kind, 0); - test2 = fold_build2 (LT_EXPR, boolean_type_node, tmp, test); + test2 = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, + tmp, test); mpfr_neg (huge, huge, GFC_RND_MODE); test = gfc_conv_mpfr_to_tree (huge, expr->ts.kind, 0); - test = fold_build2 (GT_EXPR, boolean_type_node, tmp, test); - test2 = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, test, test2); + test = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, tmp, + test); + test2 = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, test, test2); itype = gfc_get_int_type (ikind); if (modulo) @@ -1242,9 +1275,11 @@ gfc_conv_intrinsic_mod (gfc_se * se, gfc else tmp = build_fix_expr (&se->pre, tmp, itype, RND_TRUNC); tmp = convert (type, tmp); - tmp = fold_build3 (COND_EXPR, type, test2, tmp, args[0]); - tmp = fold_build2 (MULT_EXPR, type, tmp, args[1]); - se->expr = fold_build2 (MINUS_EXPR, type, args[0], tmp); + tmp = fold_build3_loc (input_location, COND_EXPR, type, test2, tmp, + args[0]); + tmp = fold_build2_loc (input_location, MULT_EXPR, type, tmp, args[1]); + se->expr = fold_build2_loc (input_location, MINUS_EXPR, type, args[0], + tmp); mpfr_clear (huge); break; @@ -1267,12 +1302,12 @@ gfc_conv_intrinsic_dim (gfc_se * se, gfc gfc_conv_intrinsic_function_args (se, expr, args, 2); type = TREE_TYPE (args[0]); - val = fold_build2 (MINUS_EXPR, type, args[0], args[1]); + val = fold_build2_loc (input_location, MINUS_EXPR, type, args[0], args[1]); val = gfc_evaluate_now (val, &se->pre); zero = gfc_build_const (type, integer_zero_node); - tmp = fold_build2 (LE_EXPR, boolean_type_node, val, zero); - se->expr = fold_build3 (COND_EXPR, type, tmp, zero, val); + tmp = fold_build2_loc (input_location, LE_EXPR, boolean_type_node, val, zero); + se->expr = fold_build3_loc (input_location, COND_EXPR, type, tmp, zero, val); } @@ -1304,8 +1339,10 @@ gfc_conv_intrinsic_sign (gfc_se * se, gf { tree cond, zero; zero = build_real_from_int_cst (TREE_TYPE (args[1]), integer_zero_node); - cond = fold_build2 (EQ_EXPR, boolean_type_node, args[1], zero); - se->expr = fold_build3 (COND_EXPR, TREE_TYPE (args[0]), cond, + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + args[1], zero); + se->expr = fold_build3_loc (input_location, COND_EXPR, + TREE_TYPE (args[0]), cond, build_call_expr_loc (input_location, abs, 1, args[0]), build_call_expr_loc (input_location, tmp, 2, @@ -1326,16 +1363,16 @@ gfc_conv_intrinsic_sign (gfc_se * se, gf /* Construct (A ^ B) >> 31, which generates a bit mask of all zeros if the signs of A and B are the same, and of all ones if they differ. */ - tmp = fold_build2 (BIT_XOR_EXPR, type, args[0], args[1]); - tmp = fold_build2 (RSHIFT_EXPR, type, tmp, - build_int_cst (type, TYPE_PRECISION (type) - 1)); + tmp = fold_build2_loc (input_location, BIT_XOR_EXPR, type, args[0], args[1]); + tmp = fold_build2_loc (input_location, RSHIFT_EXPR, type, tmp, + build_int_cst (type, TYPE_PRECISION (type) - 1)); tmp = gfc_evaluate_now (tmp, &se->pre); /* Construct (A + tmp) ^ tmp, which is A if tmp is zero, and -A if tmp] is all ones (i.e. -1). */ - se->expr = fold_build2 (BIT_XOR_EXPR, type, - fold_build2 (PLUS_EXPR, type, args[0], tmp), - tmp); + se->expr = fold_build2_loc (input_location, BIT_XOR_EXPR, type, + fold_build2_loc (input_location, PLUS_EXPR, + type, args[0], tmp), tmp); } @@ -1367,7 +1404,8 @@ gfc_conv_intrinsic_dprod (gfc_se * se, g type = gfc_typenode_for_spec (&expr->ts); args[0] = convert (type, args[0]); args[1] = convert (type, args[1]); - se->expr = fold_build2 (MULT_EXPR, type, args[0], args[1]); + se->expr = fold_build2_loc (input_location, MULT_EXPR, type, args[0], + args[1]); } @@ -1387,7 +1425,7 @@ gfc_conv_intrinsic_char (gfc_se * se, gf type = gfc_get_char_type (expr->ts.kind); var = gfc_create_var (type, "char"); - arg[0] = fold_build1 (NOP_EXPR, type, arg[0]); + arg[0] = fold_build1_loc (input_location, NOP_EXPR, type, arg[0]); gfc_add_modify (&se->pre, var, arg[0]); se->expr = gfc_build_addr_expr (build_pointer_type (type), var); se->string_length = integer_one_node; @@ -1422,8 +1460,8 @@ gfc_conv_intrinsic_ctime (gfc_se * se, g gfc_add_expr_to_block (&se->pre, tmp); /* Free the temporary afterwards, if necessary. */ - cond = fold_build2 (GT_EXPR, boolean_type_node, - len, build_int_cst (TREE_TYPE (len), 0)); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + len, build_int_cst (TREE_TYPE (len), 0)); tmp = gfc_call_free (var); tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location)); gfc_add_expr_to_block (&se->post, tmp); @@ -1461,8 +1499,8 @@ gfc_conv_intrinsic_fdate (gfc_se * se, g gfc_add_expr_to_block (&se->pre, tmp); /* Free the temporary afterwards, if necessary. */ - cond = fold_build2 (GT_EXPR, boolean_type_node, - len, build_int_cst (TREE_TYPE (len), 0)); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + len, build_int_cst (TREE_TYPE (len), 0)); tmp = gfc_call_free (var); tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location)); gfc_add_expr_to_block (&se->post, tmp); @@ -1502,8 +1540,8 @@ gfc_conv_intrinsic_ttynam (gfc_se * se, gfc_add_expr_to_block (&se->pre, tmp); /* Free the temporary afterwards, if necessary. */ - cond = fold_build2 (GT_EXPR, boolean_type_node, - len, build_int_cst (TREE_TYPE (len), 0)); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + len, build_int_cst (TREE_TYPE (len), 0)); tmp = gfc_call_free (var); tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location)); gfc_add_expr_to_block (&se->post, tmp); @@ -1580,7 +1618,8 @@ gfc_conv_intrinsic_minmax (gfc_se * se, thencase = build2_v (MODIFY_EXPR, mvar, convert (type, val)); - tmp = fold_build2 (op, boolean_type_node, convert (type, val), mvar); + tmp = fold_build2_loc (input_location, op, boolean_type_node, + convert (type, val), mvar); /* FIXME: When the IEEE_ARITHMETIC module is implemented, the call to __builtin_isnan might be made dependent on that module being loaded, @@ -1589,8 +1628,9 @@ gfc_conv_intrinsic_minmax (gfc_se * se, { isnan = build_call_expr_loc (input_location, built_in_decls[BUILT_IN_ISNAN], 1, mvar); - tmp = fold_build2 (TRUTH_OR_EXPR, boolean_type_node, tmp, - fold_convert (boolean_type_node, isnan)); + tmp = fold_build2_loc (input_location, TRUTH_OR_EXPR, + boolean_type_node, tmp, + fold_convert (boolean_type_node, isnan)); } tmp = build3_v (COND_EXPR, tmp, thencase, build_empty_stmt (input_location)); @@ -1642,8 +1682,8 @@ gfc_conv_intrinsic_minmax_char (gfc_se * gfc_add_expr_to_block (&se->pre, tmp); /* Free the temporary afterwards, if necessary. */ - cond = fold_build2 (GT_EXPR, boolean_type_node, - len, build_int_cst (TREE_TYPE (len), 0)); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + len, build_int_cst (TREE_TYPE (len), 0)); tmp = gfc_call_free (var); tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location)); gfc_add_expr_to_block (&se->post, tmp); @@ -1841,8 +1881,8 @@ gfc_conv_intrinsic_anyall (gfc_se * se, gfc_conv_expr_val (&arrayse, actual->expr); gfc_add_block_to_block (&body, &arrayse.pre); - tmp = fold_build2 (op, boolean_type_node, arrayse.expr, - build_int_cst (TREE_TYPE (arrayse.expr), 0)); + tmp = fold_build2_loc (input_location, op, boolean_type_node, arrayse.expr, + build_int_cst (TREE_TYPE (arrayse.expr), 0)); tmp = build3_v (COND_EXPR, tmp, found, build_empty_stmt (input_location)); gfc_add_expr_to_block (&body, tmp); gfc_add_block_to_block (&body, &arrayse.post); @@ -1902,8 +1942,8 @@ gfc_conv_intrinsic_count (gfc_se * se, g /* Generate the loop body. */ gfc_start_scalarized_body (&loop, &body); - tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (resvar), - resvar, build_int_cst (TREE_TYPE (resvar), 1)); + tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (resvar), + resvar, build_int_cst (TREE_TYPE (resvar), 1)); tmp = build2_v (MODIFY_EXPR, resvar, tmp); gfc_init_se (&arrayse, NULL); @@ -2059,43 +2099,48 @@ gfc_conv_intrinsic_arith (gfc_se * se, g absX = gfc_create_var (type, "absX"); gfc_add_modify (&ifblock1, absX, - fold_build1 (ABS_EXPR, type, arrayse.expr)); + fold_build1_loc (input_location, ABS_EXPR, type, + arrayse.expr)); val = gfc_create_var (type, "val"); gfc_add_expr_to_block (&ifblock1, val); gfc_init_block (&ifblock2); gfc_add_modify (&ifblock2, val, - fold_build2 (RDIV_EXPR, type, scale, absX)); - res1 = fold_build2 (MULT_EXPR, type, val, val); - res1 = fold_build2 (MULT_EXPR, type, resvar, res1); - res1 = fold_build2 (PLUS_EXPR, type, res1, - gfc_build_const (type, integer_one_node)); + fold_build2_loc (input_location, RDIV_EXPR, type, scale, + absX)); + res1 = fold_build2_loc (input_location, MULT_EXPR, type, val, val); + res1 = fold_build2_loc (input_location, MULT_EXPR, type, resvar, res1); + res1 = fold_build2_loc (input_location, PLUS_EXPR, type, res1, + gfc_build_const (type, integer_one_node)); gfc_add_modify (&ifblock2, resvar, res1); gfc_add_modify (&ifblock2, scale, absX); res1 = gfc_finish_block (&ifblock2); gfc_init_block (&ifblock3); gfc_add_modify (&ifblock3, val, - fold_build2 (RDIV_EXPR, type, absX, scale)); - res2 = fold_build2 (MULT_EXPR, type, val, val); - res2 = fold_build2 (PLUS_EXPR, type, resvar, res2); + fold_build2_loc (input_location, RDIV_EXPR, type, absX, + scale)); + res2 = fold_build2_loc (input_location, MULT_EXPR, type, val, val); + res2 = fold_build2_loc (input_location, PLUS_EXPR, type, resvar, res2); gfc_add_modify (&ifblock3, resvar, res2); res2 = gfc_finish_block (&ifblock3); - cond = fold_build2 (GT_EXPR, boolean_type_node, absX, scale); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + absX, scale); tmp = build3_v (COND_EXPR, cond, res1, res2); gfc_add_expr_to_block (&ifblock1, tmp); tmp = gfc_finish_block (&ifblock1); - cond = fold_build2 (NE_EXPR, boolean_type_node, arrayse.expr, - gfc_build_const (type, integer_zero_node)); + cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, + arrayse.expr, + gfc_build_const (type, integer_zero_node)); tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location)); gfc_add_expr_to_block (&block, tmp); } else { - tmp = fold_build2 (op, type, resvar, arrayse.expr); + tmp = fold_build2_loc (input_location, op, type, resvar, arrayse.expr); gfc_add_modify (&block, resvar, tmp); } @@ -2145,7 +2190,7 @@ gfc_conv_intrinsic_arith (gfc_se * se, g sqrt = gfc_builtin_decl_for_float_kind (BUILT_IN_SQRT, expr->ts.kind); resvar = build_call_expr_loc (input_location, sqrt, 1, resvar); - resvar = fold_build2 (MULT_EXPR, type, scale, resvar); + resvar = fold_build2_loc (input_location, MULT_EXPR, type, scale, resvar); } se->expr = resvar; @@ -2213,7 +2258,8 @@ gfc_conv_intrinsic_dot_product (gfc_se * arrayse1.ss = arrayss1; gfc_conv_expr_val (&arrayse1, arrayexpr1); if (expr->ts.type == BT_COMPLEX) - arrayse1.expr = fold_build1 (CONJ_EXPR, type, arrayse1.expr); + arrayse1.expr = fold_build1_loc (input_location, CONJ_EXPR, type, + arrayse1.expr); gfc_add_block_to_block (&block, &arrayse1.pre); /* Make the tree expression for array2. */ @@ -2226,13 +2272,15 @@ gfc_conv_intrinsic_dot_product (gfc_se * /* Do the actual product and sum. */ if (expr->ts.type == BT_LOGICAL) { - tmp = fold_build2 (TRUTH_AND_EXPR, type, arrayse1.expr, arrayse2.expr); - tmp = fold_build2 (TRUTH_OR_EXPR, type, resvar, tmp); + tmp = fold_build2_loc (input_location, TRUTH_AND_EXPR, type, + arrayse1.expr, arrayse2.expr); + tmp = fold_build2_loc (input_location, TRUTH_OR_EXPR, type, resvar, tmp); } else { - tmp = fold_build2 (MULT_EXPR, type, arrayse1.expr, arrayse2.expr); - tmp = fold_build2 (PLUS_EXPR, type, resvar, tmp); + tmp = fold_build2_loc (input_location, MULT_EXPR, type, arrayse1.expr, + arrayse2.expr); + tmp = fold_build2_loc (input_location, PLUS_EXPR, type, resvar, tmp); } gfc_add_modify (&block, resvar, tmp); @@ -2375,8 +2423,9 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s { nonempty = gfc_conv_mpz_to_tree (asize, gfc_index_integer_kind); mpz_clear (asize); - nonempty = fold_build2 (GT_EXPR, boolean_type_node, nonempty, - gfc_index_zero_node); + nonempty = fold_build2_loc (input_location, GT_EXPR, + boolean_type_node, nonempty, + gfc_index_zero_node); } maskss = NULL; } @@ -2411,10 +2460,10 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s -HUGE for BT_REAL and (-HUGE - 1) for BT_INTEGER; the most positive possible value is HUGE in both cases. */ if (op == GT_EXPR) - tmp = fold_build1 (NEGATE_EXPR, TREE_TYPE (tmp), tmp); + tmp = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (tmp), tmp); if (op == GT_EXPR && expr->ts.type == BT_INTEGER) - tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), tmp, - build_int_cst (type, 1)); + tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (tmp), tmp, + build_int_cst (type, 1)); gfc_add_modify (&se->pre, limit, tmp); @@ -2430,8 +2479,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s gcc_assert (loop.dimen == 1); if (nonempty == NULL && maskss == NULL && loop.from[0] && loop.to[0]) - nonempty = fold_build2 (LE_EXPR, boolean_type_node, loop.from[0], - loop.to[0]); + nonempty = fold_build2_loc (input_location, LE_EXPR, boolean_type_node, + loop.from[0], loop.to[0]); lab1 = NULL; lab2 = NULL; @@ -2442,9 +2491,10 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s the inner loop. */ if (nonempty != NULL && !HONOR_NANS (DECL_MODE (limit))) gfc_add_modify (&loop.pre, pos, - fold_build3 (COND_EXPR, gfc_array_index_type, - nonempty, gfc_index_one_node, - gfc_index_zero_node)); + fold_build3_loc (input_location, COND_EXPR, + gfc_array_index_type, + nonempty, gfc_index_one_node, + gfc_index_zero_node)); else { gfc_add_modify (&loop.pre, pos, gfc_index_zero_node); @@ -2490,8 +2540,8 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s /* Remember where we are. An offset must be added to the loop counter to obtain the required position. */ if (loop.from[0]) - tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, - gfc_index_one_node, loop.from[0]); + tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type, + gfc_index_one_node, loop.from[0]); else tmp = gfc_index_one_node; @@ -2503,19 +2553,19 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s tree ifbody2; gfc_start_block (&ifblock2); - tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (pos), - loop.loopvar[0], offset); + tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (pos), + loop.loopvar[0], offset); gfc_add_modify (&ifblock2, pos, tmp); ifbody2 = gfc_finish_block (&ifblock2); - cond = fold_build2 (EQ_EXPR, boolean_type_node, pos, - gfc_index_zero_node); + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, pos, + gfc_index_zero_node); tmp = build3_v (COND_EXPR, cond, ifbody2, build_empty_stmt (input_location)); gfc_add_expr_to_block (&block, tmp); } - tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (pos), - loop.loopvar[0], offset); + tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (pos), + loop.loopvar[0], offset); gfc_add_modify (&ifblock, pos, tmp); if (lab1) @@ -2526,10 +2576,12 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s if (!lab1 || HONOR_NANS (DECL_MODE (limit))) { if (lab1) - cond = fold_build2 (op == GT_EXPR ? GE_EXPR : LE_EXPR, - boolean_type_node, arrayse.expr, limit); + cond = fold_build2_loc (input_location, + op == GT_EXPR ? GE_EXPR : LE_EXPR, + boolean_type_node, arrayse.expr, limit); else - cond = fold_build2 (op, boolean_type_node, arrayse.expr, limit); + cond = fold_build2_loc (input_location, op, boolean_type_node, + arrayse.expr, limit); ifbody = build3_v (COND_EXPR, cond, ifbody, build_empty_stmt (input_location)); @@ -2597,20 +2649,21 @@ gfc_conv_intrinsic_minmaxloc (gfc_se * s /* Remember where we are. An offset must be added to the loop counter to obtain the required position. */ if (loop.from[0]) - tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, - gfc_index_one_node, loop.from[0]); + tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type, + gfc_index_one_node, loop.from[0]); else tmp = gfc_index_one_node; gfc_add_modify (&block, offset, tmp); - tmp = fold_build2 (PLUS_EXPR, TREE_TYPE (pos), - loop.loopvar[0], offset); + tmp = fold_build2_loc (input_location, PLUS_EXPR, TREE_TYPE (pos), + loop.loopvar[0], offset); gfc_add_modify (&ifblock, pos, tmp); ifbody = gfc_finish_block (&ifblock); - cond = fold_build2 (op, boolean_type_node, arrayse.expr, limit); + cond = fold_build2_loc (input_location, op, boolean_type_node, + arrayse.expr, limit); tmp = build3_v (COND_EXPR, cond, ifbody, build_empty_stmt (input_location)); @@ -2830,14 +2883,15 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s possible value is HUGE in both cases. */ if (op == GT_EXPR) { - tmp = fold_build1 (NEGATE_EXPR, TREE_TYPE (tmp), tmp); + tmp = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (tmp), tmp); if (huge_cst) - huge_cst = fold_build1 (NEGATE_EXPR, TREE_TYPE (huge_cst), huge_cst); + huge_cst = fold_build1_loc (input_location, NEGATE_EXPR, + TREE_TYPE (huge_cst), huge_cst); } if (op == GT_EXPR && expr->ts.type == BT_INTEGER) - tmp = fold_build2 (MINUS_EXPR, TREE_TYPE (tmp), - tmp, build_int_cst (type, 1)); + tmp = fold_build2_loc (input_location, MINUS_EXPR, TREE_TYPE (tmp), + tmp, build_int_cst (type, 1)); gfc_add_modify (&se->pre, limit, tmp); @@ -2863,8 +2917,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s { nonempty = gfc_conv_mpz_to_tree (asize, gfc_index_integer_kind); mpz_clear (asize); - nonempty = fold_build2 (GT_EXPR, boolean_type_node, nonempty, - gfc_index_zero_node); + nonempty = fold_build2_loc (input_location, GT_EXPR, + boolean_type_node, nonempty, + gfc_index_zero_node); } maskss = NULL; } @@ -2881,8 +2936,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s if (nonempty == NULL && maskss == NULL && loop.dimen == 1 && loop.from[0] && loop.to[0]) - nonempty = fold_build2 (LE_EXPR, boolean_type_node, loop.from[0], - loop.to[0]); + nonempty = fold_build2_loc (input_location, LE_EXPR, boolean_type_node, + loop.from[0], loop.to[0]); nonempty_var = NULL; if (nonempty == NULL && (HONOR_INFINITIES (DECL_MODE (limit)) @@ -2942,8 +2997,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s if (HONOR_NANS (DECL_MODE (limit))) { - tmp = fold_build2 (op == GT_EXPR ? GE_EXPR : LE_EXPR, - boolean_type_node, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, op == GT_EXPR ? GE_EXPR : LE_EXPR, + boolean_type_node, arrayse.expr, limit); if (lab) ifbody = build1_v (GOTO_EXPR, lab); else @@ -2965,7 +3020,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s signed zeros. */ if (HONOR_SIGNED_ZEROS (DECL_MODE (limit))) { - tmp = fold_build2 (op, boolean_type_node, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, op, boolean_type_node, + arrayse.expr, limit); ifbody = build2_v (MODIFY_EXPR, limit, arrayse.expr); tmp = build3_v (COND_EXPR, tmp, ifbody, build_empty_stmt (input_location)); @@ -2973,8 +3029,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s } else { - tmp = fold_build2 (op == GT_EXPR ? MAX_EXPR : MIN_EXPR, - type, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, + op == GT_EXPR ? MAX_EXPR : MIN_EXPR, + type, arrayse.expr, limit); gfc_add_modify (&block2, limit, tmp); } } @@ -2988,15 +3045,17 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s if (HONOR_NANS (DECL_MODE (limit)) || HONOR_SIGNED_ZEROS (DECL_MODE (limit))) { - tmp = fold_build2 (op, boolean_type_node, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, op, boolean_type_node, + arrayse.expr, limit); ifbody = build2_v (MODIFY_EXPR, limit, arrayse.expr); ifbody = build3_v (COND_EXPR, tmp, ifbody, build_empty_stmt (input_location)); } else { - tmp = fold_build2 (op == GT_EXPR ? MAX_EXPR : MIN_EXPR, - type, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, + op == GT_EXPR ? MAX_EXPR : MIN_EXPR, + type, arrayse.expr, limit); ifbody = build2_v (MODIFY_EXPR, limit, tmp); } tmp = build3_v (COND_EXPR, fast, ifbody, elsebody); @@ -3018,7 +3077,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s { gfc_trans_scalarized_loop_end (&loop, 0, &body); - tmp = fold_build3 (COND_EXPR, type, nonempty, nan_cst, huge_cst); + tmp = fold_build3_loc (input_location, COND_EXPR, type, nonempty, + nan_cst, huge_cst); gfc_add_modify (&loop.code[0], limit, tmp); gfc_add_expr_to_block (&loop.code[0], build1_v (LABEL_EXPR, lab)); @@ -3050,7 +3110,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s if (HONOR_NANS (DECL_MODE (limit)) || HONOR_SIGNED_ZEROS (DECL_MODE (limit))) { - tmp = fold_build2 (op, boolean_type_node, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, op, boolean_type_node, + arrayse.expr, limit); ifbody = build2_v (MODIFY_EXPR, limit, arrayse.expr); tmp = build3_v (COND_EXPR, tmp, ifbody, build_empty_stmt (input_location)); @@ -3058,8 +3119,9 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s } else { - tmp = fold_build2 (op == GT_EXPR ? MAX_EXPR : MIN_EXPR, - type, arrayse.expr, limit); + tmp = fold_build2_loc (input_location, + op == GT_EXPR ? MAX_EXPR : MIN_EXPR, + type, arrayse.expr, limit); gfc_add_modify (&block, limit, tmp); } @@ -3079,7 +3141,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s if (fast) { - tmp = fold_build3 (COND_EXPR, type, nonempty, nan_cst, huge_cst); + tmp = fold_build3_loc (input_location, COND_EXPR, type, nonempty, + nan_cst, huge_cst); ifbody = build2_v (MODIFY_EXPR, limit, tmp); tmp = build3_v (COND_EXPR, fast, build_empty_stmt (input_location), ifbody); @@ -3087,7 +3150,8 @@ gfc_conv_intrinsic_minmaxval (gfc_se * s } else if (HONOR_INFINITIES (DECL_MODE (limit)) && !lab) { - tmp = fold_build3 (COND_EXPR, type, nonempty, limit, huge_cst); + tmp = fold_build3_loc (input_location, COND_EXPR, type, nonempty, limit, + huge_cst); gfc_add_modify (&loop.pre, limit, tmp); } @@ -3133,10 +3197,11 @@ gfc_conv_intrinsic_btest (gfc_se * se, g gfc_conv_intrinsic_function_args (se, expr, args, 2); type = TREE_TYPE (args[0]); - tmp = fold_build2 (LSHIFT_EXPR, type, build_int_cst (type, 1), args[1]); - tmp = fold_build2 (BIT_AND_EXPR, type, args[0], tmp); - tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp, - build_int_cst (type, 0)); + tmp = fold_build2_loc (input_location, LSHIFT_EXPR, type, + build_int_cst (type, 1), args[1]); + tmp = fold_build2_loc (input_location, BIT_AND_EXPR, type, args[0], tmp); + tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, tmp, + build_int_cst (type, 0)); type = gfc_typenode_for_spec (&expr->ts); se->expr = convert (type, tmp); } @@ -3148,7 +3213,8 @@ gfc_conv_intrinsic_bitop (gfc_se * se, g tree args[2]; gfc_conv_intrinsic_function_args (se, expr, args, 2); - se->expr = fold_build2 (op, TREE_TYPE (args[0]), args[0], args[1]); + se->expr = fold_build2_loc (input_location, op, TREE_TYPE (args[0]), + args[0], args[1]); } /* Bitwise not. */ @@ -3158,7 +3224,8 @@ gfc_conv_intrinsic_not (gfc_se * se, gfc tree arg; gfc_conv_intrinsic_function_args (se, expr, &arg, 1); - se->expr = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg), arg); + se->expr = fold_build1_loc (input_location, BIT_NOT_EXPR, + TREE_TYPE (arg), arg); } /* Set or clear a single bit. */ @@ -3173,15 +3240,16 @@ gfc_conv_intrinsic_singlebitop (gfc_se * gfc_conv_intrinsic_function_args (se, expr, args, 2); type = TREE_TYPE (args[0]); - tmp = fold_build2 (LSHIFT_EXPR, type, build_int_cst (type, 1), args[1]); + tmp = fold_build2_loc (input_location, LSHIFT_EXPR, type, + build_int_cst (type, 1), args[1]); if (set) op = BIT_IOR_EXPR; else { op = BIT_AND_EXPR; - tmp = fold_build1 (BIT_NOT_EXPR, type, tmp); + tmp = fold_build1_loc (input_location, BIT_NOT_EXPR, type, tmp); } - se->expr = fold_build2 (op, type, args[0], tmp); + se->expr = fold_build2_loc (input_location, op, type, args[0], tmp); } /* Extract a sequence of bits. @@ -3198,12 +3266,12 @@ gfc_conv_intrinsic_ibits (gfc_se * se, g type = TREE_TYPE (args[0]); mask = build_int_cst (type, -1); - mask = fold_build2 (LSHIFT_EXPR, type, mask, args[2]); - mask = fold_build1 (BIT_NOT_EXPR, type, mask); + mask = fold_build2_loc (input_location, LSHIFT_EXPR, type, mask, args[2]); + mask = fold_build1_loc (input_location, BIT_NOT_EXPR, type, mask); - tmp = fold_build2 (RSHIFT_EXPR, type, args[0], args[1]); + tmp = fold_build2_loc (input_location, RSHIFT_EXPR, type, args[0], args[1]); - se->expr = fold_build2 (BIT_AND_EXPR, type, tmp, mask); + se->expr = fold_build2_loc (input_location, BIT_AND_EXPR, type, tmp, mask); } /* RSHIFT (I, SHIFT) = I >> SHIFT @@ -3215,8 +3283,9 @@ gfc_conv_intrinsic_rlshift (gfc_se * se, gfc_conv_intrinsic_function_args (se, expr, args, 2); - se->expr = fold_build2 (right_shift ? RSHIFT_EXPR : LSHIFT_EXPR, - TREE_TYPE (args[0]), args[0], args[1]); + se->expr = fold_build2_loc (input_location, + right_shift ? RSHIFT_EXPR : LSHIFT_EXPR, + TREE_TYPE (args[0]), args[0], args[1]); } /* ISHFT (I, SHIFT) = (abs (shift) >= BIT_SIZE (i)) @@ -3244,31 +3313,32 @@ gfc_conv_intrinsic_ishft (gfc_se * se, g type = TREE_TYPE (args[0]); utype = unsigned_type_for (type); - width = fold_build1 (ABS_EXPR, TREE_TYPE (args[1]), args[1]); + width = fold_build1_loc (input_location, ABS_EXPR, TREE_TYPE (args[1]), + args[1]); /* Left shift if positive. */ - lshift = fold_build2 (LSHIFT_EXPR, type, args[0], width); + lshift = fold_build2_loc (input_location, LSHIFT_EXPR, type, args[0], width); /* Right shift if negative. We convert to an unsigned type because we want a logical shift. The standard doesn't define the case of shifting negative numbers, and we try to be compatible with other compilers, most notably g77, here. */ - rshift = fold_convert (type, fold_build2 (RSHIFT_EXPR, utype, - convert (utype, args[0]), width)); + rshift = fold_convert (type, fold_build2_loc (input_location, RSHIFT_EXPR, + utype, convert (utype, args[0]), width)); - tmp = fold_build2 (GE_EXPR, boolean_type_node, args[1], - build_int_cst (TREE_TYPE (args[1]), 0)); - tmp = fold_build3 (COND_EXPR, type, tmp, lshift, rshift); + tmp = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, args[1], + build_int_cst (TREE_TYPE (args[1]), 0)); + tmp = fold_build3_loc (input_location, COND_EXPR, type, tmp, lshift, rshift); /* The Fortran standard allows shift widths <= BIT_SIZE(I), whereas gcc requires a shift width < BIT_SIZE(I), so we have to catch this special case. */ num_bits = build_int_cst (TREE_TYPE (args[1]), TYPE_PRECISION (type)); - cond = fold_build2 (GE_EXPR, boolean_type_node, width, num_bits); - - se->expr = fold_build3 (COND_EXPR, type, cond, - build_int_cst (type, 0), tmp); + cond = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, width, + num_bits); + se->expr = fold_build3_loc (input_location, COND_EXPR, type, cond, + build_int_cst (type, 0), tmp); } @@ -3341,19 +3411,23 @@ gfc_conv_intrinsic_ishftc (gfc_se * se, args[1] = gfc_evaluate_now (args[1], &se->pre); /* Rotate left if positive. */ - lrot = fold_build2 (LROTATE_EXPR, type, args[0], args[1]); + lrot = fold_build2_loc (input_location, LROTATE_EXPR, type, args[0], args[1]); /* Rotate right if negative. */ - tmp = fold_build1 (NEGATE_EXPR, TREE_TYPE (args[1]), args[1]); - rrot = fold_build2 (RROTATE_EXPR, type, args[0], tmp); + tmp = fold_build1_loc (input_location, NEGATE_EXPR, TREE_TYPE (args[1]), + args[1]); + rrot = fold_build2_loc (input_location,RROTATE_EXPR, type, args[0], tmp); zero = build_int_cst (TREE_TYPE (args[1]), 0); - tmp = fold_build2 (GT_EXPR, boolean_type_node, args[1], zero); - rrot = fold_build3 (COND_EXPR, type, tmp, lrot, rrot); + tmp = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, args[1], + zero); + rrot = fold_build3_loc (input_location, COND_EXPR, type, tmp, lrot, rrot); /* Do nothing if shift == 0. */ - tmp = fold_build2 (EQ_EXPR, boolean_type_node, args[1], zero); - se->expr = fold_build3 (COND_EXPR, type, tmp, args[0], rrot); + tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, args[1], + zero); + se->expr = fold_build3_loc (input_location, COND_EXPR, type, tmp, args[0], + rrot); } /* LEADZ (i) = (i == 0) ? BIT_SIZE (i) @@ -3416,15 +3490,16 @@ gfc_conv_intrinsic_leadz (gfc_se * se, g s = TYPE_PRECISION (arg_type) - argsize; tmp = fold_convert (result_type, build_call_expr_loc (input_location, func, 1, arg)); - leadz = fold_build2 (MINUS_EXPR, result_type, - tmp, build_int_cst (result_type, s)); + leadz = fold_build2_loc (input_location, MINUS_EXPR, result_type, + tmp, build_int_cst (result_type, s)); /* Build BIT_SIZE. */ bit_size = build_int_cst (result_type, argsize); - cond = fold_build2 (EQ_EXPR, boolean_type_node, - arg, build_int_cst (arg_type, 0)); - se->expr = fold_build3 (COND_EXPR, result_type, cond, bit_size, leadz); + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + arg, build_int_cst (arg_type, 0)); + se->expr = fold_build3_loc (input_location, COND_EXPR, result_type, cond, + bit_size, leadz); } /* TRAILZ(i) = (i == 0) ? BIT_SIZE (i) : __builtin_ctz(i) @@ -3485,9 +3560,10 @@ gfc_conv_intrinsic_trailz (gfc_se * se, /* Build BIT_SIZE. */ bit_size = build_int_cst (result_type, argsize); - cond = fold_build2 (EQ_EXPR, boolean_type_node, - arg, build_int_cst (arg_type, 0)); - se->expr = fold_build3 (COND_EXPR, result_type, cond, bit_size, trailz); + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + arg, build_int_cst (arg_type, 0)); + se->expr = fold_build3_loc (input_location, COND_EXPR, result_type, cond, + bit_size, trailz); } /* Using __builtin_popcount for POPCNT and __builtin_parity for POPPAR; @@ -3546,17 +3622,19 @@ gfc_conv_intrinsic_popcnt_poppar (gfc_se fold_convert (long_long_unsigned_type_node, arg)); - arg2 = fold_build2 (RSHIFT_EXPR, utype, arg, - build_int_cst (utype, LONG_LONG_TYPE_SIZE)); + arg2 = fold_build2_loc (input_location, RSHIFT_EXPR, utype, arg, + build_int_cst (utype, LONG_LONG_TYPE_SIZE)); call2 = build_call_expr_loc (input_location, func, 1, fold_convert (long_long_unsigned_type_node, arg2)); /* Combine the results. */ if (parity) - se->expr = fold_build2 (BIT_XOR_EXPR, result_type, call1, call2); + se->expr = fold_build2_loc (input_location, BIT_XOR_EXPR, result_type, + call1, call2); else - se->expr = fold_build2 (PLUS_EXPR, result_type, call1, call2); + se->expr = fold_build2_loc (input_location, PLUS_EXPR, result_type, + call1, call2); return; } @@ -3767,7 +3845,7 @@ gfc_conv_intrinsic_ichar (gfc_se * se, g gfc_conv_intrinsic_function_args (se, expr, args, 2); gcc_assert (POINTER_TYPE_P (TREE_TYPE (args[1]))); pchartype = gfc_get_pchar_type (expr->value.function.actual->expr->ts.kind); - args[1] = fold_build1 (NOP_EXPR, pchartype, args[1]); + args[1] = fold_build1_loc (input_location, NOP_EXPR, pchartype, args[1]); type = gfc_typenode_for_spec (&expr->ts); se->expr = build_fold_indirect_ref_loc (input_location, @@ -3800,8 +3878,9 @@ gfc_conv_has_intvalue (gfc_se * se, gfc_ tree arg; gfc_conv_intrinsic_function_args (se, expr, &arg, 1); - se->expr = fold_build2 (EQ_EXPR, gfc_typenode_for_spec (&expr->ts), - arg, build_int_cst (TREE_TYPE (arg), value)); + se->expr = fold_build2_loc (input_location, EQ_EXPR, + gfc_typenode_for_spec (&expr->ts), + arg, build_int_cst (TREE_TYPE (arg), value)); } @@ -3845,8 +3924,8 @@ gfc_conv_intrinsic_merge (gfc_se * se, g se->string_length = len; } type = TREE_TYPE (tsource); - se->expr = fold_build3 (COND_EXPR, type, mask, tsource, - fold_convert (type, fsource)); + se->expr = fold_build3_loc (input_location, COND_EXPR, type, mask, tsource, + fold_convert (type, fsource)); } @@ -3939,17 +4018,18 @@ gfc_conv_intrinsic_spacing (gfc_se * se, gfc_build_addr_expr (NULL_TREE, e)); gfc_add_expr_to_block (&block, tmp); - tmp = fold_build2 (MINUS_EXPR, integer_type_node, e, prec); - gfc_add_modify (&block, e, fold_build2 (MAX_EXPR, integer_type_node, - tmp, emin)); + tmp = fold_build2_loc (input_location, MINUS_EXPR, integer_type_node, e, + prec); + gfc_add_modify (&block, e, fold_build2_loc (input_location, MAX_EXPR, + integer_type_node, tmp, emin)); tmp = build_call_expr_loc (input_location, scalbn, 2, build_real_from_int_cst (type, integer_one_node), e); gfc_add_modify (&block, res, tmp); /* Finish by building the IF statement. */ - cond = fold_build2 (EQ_EXPR, boolean_type_node, arg, - build_real_from_int_cst (type, integer_zero_node)); + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, arg, + build_real_from_int_cst (type, integer_zero_node)); tmp = build3_v (COND_EXPR, cond, build2_v (MODIFY_EXPR, res, tiny), gfc_finish_block (&block)); @@ -4000,14 +4080,14 @@ gfc_conv_intrinsic_rrspacing (gfc_se * s gfc_build_addr_expr (NULL_TREE, e)); gfc_add_expr_to_block (&block, tmp); - tmp = fold_build2 (MINUS_EXPR, integer_type_node, - build_int_cst (NULL_TREE, prec), e); + tmp = fold_build2_loc (input_location, MINUS_EXPR, integer_type_node, + build_int_cst (NULL_TREE, prec), e); tmp = build_call_expr_loc (input_location, scalbn, 2, x, tmp); gfc_add_modify (&block, x, tmp); stmt = gfc_finish_block (&block); - cond = fold_build2 (NE_EXPR, boolean_type_node, x, - build_real_from_int_cst (type, integer_zero_node)); + cond = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, x, + build_real_from_int_cst (type, integer_zero_node)); tmp = build3_v (COND_EXPR, cond, stmt, build_empty_stmt (input_location)); gfc_add_expr_to_block (&se->pre, tmp); @@ -4108,17 +4188,18 @@ gfc_conv_intrinsic_size (gfc_se * se, gf argse.data_not_needed = 1; gfc_conv_expr (&argse, actual->expr); gfc_add_block_to_block (&se->pre, &argse.pre); - tmp = fold_build2 (NE_EXPR, boolean_type_node, - argse.expr, null_pointer_node); + tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, + argse.expr, null_pointer_node); tmp = gfc_evaluate_now (tmp, &se->pre); - se->expr = fold_build3 (COND_EXPR, pvoid_type_node, - tmp, fncall1, fncall0); + se->expr = fold_build3_loc (input_location, COND_EXPR, + pvoid_type_node, tmp, fncall1, fncall0); } else { se->expr = NULL_TREE; - argse.expr = fold_build2 (MINUS_EXPR, gfc_array_index_type, - argse.expr, gfc_index_one_node); + argse.expr = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, + argse.expr, gfc_index_one_node); } } else if (expr->value.function.actual->expr->rank == 1) @@ -4137,12 +4218,14 @@ gfc_conv_intrinsic_size (gfc_se * se, gf arg1); ubound = gfc_conv_descriptor_ubound_get (arg1, argse.expr); lbound = gfc_conv_descriptor_lbound_get (arg1, argse.expr); - se->expr = fold_build2 (MINUS_EXPR, gfc_array_index_type, - ubound, lbound); - se->expr = fold_build2 (PLUS_EXPR, gfc_array_index_type, se->expr, - gfc_index_one_node); - se->expr = fold_build2 (MAX_EXPR, gfc_array_index_type, se->expr, - gfc_index_zero_node); + se->expr = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, ubound, lbound); + se->expr = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, + se->expr, gfc_index_one_node); + se->expr = fold_build2_loc (input_location, MAX_EXPR, + gfc_array_index_type, se->expr, + gfc_index_zero_node); } type = gfc_typenode_for_spec (&expr->ts); @@ -4163,8 +4246,9 @@ size_of_string_in_bytes (int kind, tree bytesize = build_int_cst (gfc_array_index_type, gfc_character_kinds[i].bit_size / 8); - return fold_build2 (MULT_EXPR, gfc_array_index_type, bytesize, - fold_convert (gfc_array_index_type, string_length)); + return fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type, + bytesize, + fold_convert (gfc_array_index_type, string_length)); } @@ -4225,12 +4309,12 @@ gfc_conv_intrinsic_sizeof (gfc_se *se, g idx = gfc_rank_cst[n]; lower = gfc_conv_descriptor_lbound_get (argse.expr, idx); upper = gfc_conv_descriptor_ubound_get (argse.expr, idx); - tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, - upper, lower); - tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type, - tmp, gfc_index_one_node); - tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, - tmp, source_bytes); + tmp = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, upper, lower); + tmp = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, tmp, gfc_index_one_node); + tmp = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, tmp, source_bytes); gfc_add_modify (&argse.pre, source_bytes, tmp); } se->expr = source_bytes; @@ -4285,7 +4369,8 @@ gfc_conv_intrinsic_storage_size (gfc_se tmp = fold_convert (result_type, size_in_bytes (type)); done: - se->expr = fold_build2 (MULT_EXPR, result_type, tmp, eight.expr); + se->expr = fold_build2_loc (input_location, MULT_EXPR, result_type, tmp, + eight.expr); gfc_add_block_to_block (&se->pre, &argse.pre); } @@ -4303,8 +4388,9 @@ gfc_conv_intrinsic_strcmp (gfc_se * se, = gfc_build_compare_string (args[0], args[1], args[2], args[3], expr->value.function.actual->expr->ts.kind, op); - se->expr = fold_build2 (op, gfc_typenode_for_spec (&expr->ts), se->expr, - build_int_cst (TREE_TYPE (se->expr), 0)); + se->expr = fold_build2_loc (input_location, op, + gfc_typenode_for_spec (&expr->ts), se->expr, + build_int_cst (TREE_TYPE (se->expr), 0)); } /* Generate a call to the adjustl/adjustr library function. */ @@ -4442,7 +4528,8 @@ gfc_conv_intrinsic_transfer (gfc_se * se /* Clean up if it was repacked. */ gfc_init_block (&block); tmp = gfc_conv_array_data (argse.expr); - tmp = fold_build2 (NE_EXPR, boolean_type_node, source, tmp); + tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, + source, tmp); tmp = build3_v (COND_EXPR, tmp, stmt, build_empty_stmt (input_location)); gfc_add_expr_to_block (&block, tmp); @@ -4468,13 +4555,14 @@ gfc_conv_intrinsic_transfer (gfc_se * se gfc_add_modify (&argse.pre, source_bytes, tmp); lower = gfc_conv_descriptor_lbound_get (argse.expr, idx); upper = gfc_conv_descriptor_ubound_get (argse.expr, idx); - tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, - upper, lower); + tmp = fold_build2_loc (input_location, MINUS_EXPR, + gfc_array_index_type, upper, lower); gfc_add_modify (&argse.pre, extent, tmp); - tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type, - extent, gfc_index_one_node); - tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, - tmp, source_bytes); + tmp = fold_build2_loc (input_location, PLUS_EXPR, + gfc_array_index_type, extent, + gfc_index_one_node); + tmp = fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, tmp, source_bytes); } } @@ -4552,15 +4640,16 @@ gfc_conv_intrinsic_transfer (gfc_se * se size_bytes = gfc_create_var (gfc_array_index_type, NULL); if (tmp != NULL_TREE) - tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, - tmp, dest_word_len); + tmp = fold_build2_loc (input_location, MULT_EXPR, gfc_array_index_type, + tmp, dest_word_len); else tmp = source_bytes; gfc_add_modify (&se->pre, size_bytes, tmp); gfc_add_modify (&se->pre, size_words, - fold_build2 (CEIL_DIV_EXPR, gfc_array_index_type, - size_bytes, dest_word_len)); + fold_build2_loc (input_location, CEIL_DIV_EXPR, + gfc_array_index_type, + size_bytes, dest_word_len)); /* Evaluate the bounds of the result. If the loop range exists, we have to check if it is too large. If so, we modify loop->to be consistent @@ -4569,25 +4658,26 @@ gfc_conv_intrinsic_transfer (gfc_se * se n = se->loop->order[0]; if (se->loop->to[n] != NULL_TREE) { - tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, - se->loop->to[n], se->loop->from[n]); - tmp = fold_build2 (PLUS_EXPR, gfc_array_index_type, - tmp, gfc_index_one_node); - tmp = fold_build2 (MIN_EXPR, gfc_array_index_type, + tmp = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type, + se->loop->to[n], se->loop->from[n]); + tmp = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type, + tmp, gfc_index_one_node); + tmp = fold_build2_loc (input_location, MIN_EXPR, gfc_array_index_type, tmp, size_words); gfc_add_modify (&se->pre, size_words, tmp); gfc_add_modify (&se->pre, size_bytes, - fold_build2 (MULT_EXPR, gfc_array_index_type, - size_words, dest_word_len)); - upper = fold_build2 (PLUS_EXPR, gfc_array_index_type, - size_words, se->loop->from[n]); - upper = fold_build2 (MINUS_EXPR, gfc_array_index_type, - upper, gfc_index_one_node); + fold_build2_loc (input_location, MULT_EXPR, + gfc_array_index_type, + size_words, dest_word_len)); + upper = fold_build2_loc (input_location, PLUS_EXPR, gfc_array_index_type, + size_words, se->loop->from[n]); + upper = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type, + upper, gfc_index_one_node); } else { - upper = fold_build2 (MINUS_EXPR, gfc_array_index_type, - size_words, gfc_index_one_node); + upper = fold_build2_loc (input_location, MINUS_EXPR, gfc_array_index_type, + size_words, gfc_index_one_node); se->loop->from[n] = gfc_index_zero_node; } @@ -4609,8 +4699,9 @@ gfc_conv_intrinsic_transfer (gfc_se * se 3, tmp, fold_convert (pvoid_type_node, source), - fold_build2 (MIN_EXPR, gfc_array_index_type, - size_bytes, source_bytes)); + fold_build2_loc (input_location, MIN_EXPR, + gfc_array_index_type, + size_bytes, source_bytes)); gfc_add_expr_to_block (&se->pre, tmp); se->expr = info->descriptor; @@ -4621,10 +4712,10 @@ gfc_conv_intrinsic_transfer (gfc_se * se /* Deal with scalar results. */ scalar_transfer: - extent = fold_build2 (MIN_EXPR, gfc_array_index_type, - dest_word_len, source_bytes); - extent = fold_build2 (MAX_EXPR, gfc_array_index_type, - extent, gfc_index_zero_node); + extent = fold_build2_loc (input_location, MIN_EXPR, gfc_array_index_type, + dest_word_len, source_bytes); + extent = fold_build2_loc (input_location, MAX_EXPR, gfc_array_index_type, + extent, gfc_index_zero_node); if (expr->ts.type == BT_CHARACTER) { @@ -4657,8 +4748,8 @@ scalar_transfer: indirect = gfc_finish_block (&block); /* Wrap it up with the condition. */ - tmp = fold_build2 (LE_EXPR, boolean_type_node, - dest_word_len, source_bytes); + tmp = fold_build2_loc (input_location, LE_EXPR, boolean_type_node, + dest_word_len, source_bytes); tmp = build3_v (COND_EXPR, tmp, direct, indirect); gfc_add_expr_to_block (&se->pre, tmp); @@ -4717,8 +4808,8 @@ gfc_conv_allocated (gfc_se *se, gfc_expr tmp = gfc_conv_descriptor_data_get (arg1se.expr); } - tmp = fold_build2 (NE_EXPR, boolean_type_node, - tmp, fold_convert (TREE_TYPE (tmp), null_pointer_node)); + tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, tmp, + fold_convert (TREE_TYPE (tmp), null_pointer_node)); se->expr = convert (gfc_typenode_for_spec (&expr->ts), tmp); } @@ -4768,8 +4859,8 @@ gfc_conv_associated (gfc_se *se, gfc_exp } gfc_add_block_to_block (&se->pre, &arg1se.pre); gfc_add_block_to_block (&se->post, &arg1se.post); - tmp = fold_build2 (NE_EXPR, boolean_type_node, tmp2, - fold_convert (TREE_TYPE (tmp2), null_pointer_node)); + tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, tmp2, + fold_convert (TREE_TYPE (tmp2), null_pointer_node)); se->expr = tmp; } else @@ -4781,9 +4872,10 @@ gfc_conv_associated (gfc_se *se, gfc_exp nonzero_charlen = NULL_TREE; if (arg1->expr->ts.type == BT_CHARACTER) - nonzero_charlen = fold_build2 (NE_EXPR, boolean_type_node, - arg1->expr->ts.u.cl->backend_decl, - integer_zero_node); + nonzero_charlen = fold_build2_loc (input_location, NE_EXPR, + boolean_type_node, + arg1->expr->ts.u.cl->backend_decl, + integer_zero_node); if (ss1 == gfc_ss_terminator) { @@ -4795,12 +4887,12 @@ gfc_conv_associated (gfc_se *se, gfc_exp gfc_conv_expr (&arg2se, arg2->expr); gfc_add_block_to_block (&se->pre, &arg1se.pre); gfc_add_block_to_block (&se->post, &arg1se.post); - tmp = fold_build2 (EQ_EXPR, boolean_type_node, - arg1se.expr, arg2se.expr); - tmp2 = fold_build2 (NE_EXPR, boolean_type_node, - arg1se.expr, null_pointer_node); - se->expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, - tmp, tmp2); + tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + arg1se.expr, arg2se.expr); + tmp2 = fold_build2_loc (input_location, NE_EXPR, boolean_type_node, + arg1se.expr, null_pointer_node); + se->expr = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, tmp, tmp2); } else { @@ -4810,8 +4902,9 @@ gfc_conv_associated (gfc_se *se, gfc_exp gfc_conv_expr_lhs (&arg1se, arg1->expr); tmp = gfc_conv_descriptor_stride_get (arg1se.expr, gfc_rank_cst[arg1->expr->rank - 1]); - nonzero_arraylen = fold_build2 (NE_EXPR, boolean_type_node, tmp, - build_int_cst (TREE_TYPE (tmp), 0)); + nonzero_arraylen = fold_build2_loc (input_location, NE_EXPR, + boolean_type_node, tmp, + build_int_cst (TREE_TYPE (tmp), 0)); /* A pointer to an array, call library function _gfor_associated. */ gcc_assert (ss2 != gfc_ss_terminator); @@ -4826,15 +4919,17 @@ gfc_conv_associated (gfc_se *se, gfc_exp gfor_fndecl_associated, 2, arg1se.expr, arg2se.expr); se->expr = convert (boolean_type_node, se->expr); - se->expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, - se->expr, nonzero_arraylen); + se->expr = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, se->expr, + nonzero_arraylen); } /* If target is present zero character length pointers cannot be associated. */ if (nonzero_charlen != NULL_TREE) - se->expr = fold_build2 (TRUTH_AND_EXPR, boolean_type_node, - se->expr, nonzero_charlen); + se->expr = fold_build2_loc (input_location, TRUTH_AND_EXPR, + boolean_type_node, + se->expr, nonzero_charlen); } se->expr = convert (gfc_typenode_for_spec (&expr->ts), se->expr); @@ -4878,8 +4973,8 @@ gfc_conv_same_type_as (gfc_se *se, gfc_e gfc_conv_expr (&se1, a); gfc_conv_expr (&se2, b); - tmp = fold_build2 (EQ_EXPR, boolean_type_node, - se1.expr, fold_convert (TREE_TYPE (se1.expr), se2.expr)); + tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, + se1.expr, fold_convert (TREE_TYPE (se1.expr), se2.expr)); se->expr = convert (gfc_typenode_for_spec (&expr->ts), tmp); } @@ -5004,8 +5099,8 @@ gfc_conv_intrinsic_trim (gfc_se * se, gf gfc_add_expr_to_block (&se->pre, tmp); /* Free the temporary afterwards, if necessary. */ - cond = fold_build2 (GT_EXPR, boolean_type_node, - len, build_int_cst (TREE_TYPE (len), 0)); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + len, build_int_cst (TREE_TYPE (len), 0)); tmp = gfc_call_free (var); tmp = build3_v (COND_EXPR, cond, tmp, build_empty_stmt (input_location)); gfc_add_expr_to_block (&se->post, tmp); @@ -5038,8 +5133,8 @@ gfc_conv_intrinsic_repeat (gfc_se * se, ncopies_type = TREE_TYPE (ncopies); /* Check that NCOPIES is not negative. */ - cond = fold_build2 (LT_EXPR, boolean_type_node, ncopies, - build_int_cst (ncopies_type, 0)); + cond = fold_build2_loc (input_location, LT_EXPR, boolean_type_node, ncopies, + build_int_cst (ncopies_type, 0)); gfc_trans_runtime_check (true, false, cond, &se->pre, &expr->where, "Argument NCOPIES of REPEAT intrinsic is negative " "(its value is %lld)", @@ -5048,10 +5143,10 @@ gfc_conv_intrinsic_repeat (gfc_se * se, /* If the source length is zero, any non negative value of NCOPIES is valid, and nothing happens. */ n = gfc_create_var (ncopies_type, "ncopies"); - cond = fold_build2 (EQ_EXPR, boolean_type_node, slen, - build_int_cst (size_type_node, 0)); - tmp = fold_build3 (COND_EXPR, ncopies_type, cond, - build_int_cst (ncopies_type, 0), ncopies); + cond = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, slen, + build_int_cst (size_type_node, 0)); + tmp = fold_build3_loc (input_location, COND_EXPR, ncopies_type, cond, + build_int_cst (ncopies_type, 0), ncopies); gfc_add_modify (&se->pre, n, tmp); ncopies = n; @@ -5061,24 +5156,24 @@ gfc_conv_intrinsic_repeat (gfc_se * se, case to avoid the division by zero. */ i = gfc_validate_kind (BT_INTEGER, gfc_charlen_int_kind, false); max = gfc_conv_mpz_to_tree (gfc_integer_kinds[i].huge, gfc_charlen_int_kind); - max = fold_build2 (TRUNC_DIV_EXPR, size_type_node, - fold_convert (size_type_node, max), slen); + max = fold_build2_loc (input_location, TRUNC_DIV_EXPR, size_type_node, + fold_convert (size_type_node, max), slen); largest = TYPE_PRECISION (size_type_node) > TYPE_PRECISION (ncopies_type) ? size_type_node : ncopies_type; - cond = fold_build2 (GT_EXPR, boolean_type_node, - fold_convert (largest, ncopies), - fold_convert (largest, max)); - tmp = fold_build2 (EQ_EXPR, boolean_type_node, slen, - build_int_cst (size_type_node, 0)); - cond = fold_build3 (COND_EXPR, boolean_type_node, tmp, boolean_false_node, - cond); + cond = fold_build2_loc (input_location, GT_EXPR, boolean_type_node, + fold_convert (largest, ncopies), + fold_convert (largest, max)); + tmp = fold_build2_loc (input_location, EQ_EXPR, boolean_type_node, slen, + build_int_cst (size_type_node, 0)); + cond = fold_build3_loc (input_location, COND_EXPR, boolean_type_node, tmp, + boolean_false_node, cond); gfc_trans_runtime_check (true, false, cond, &se->pre, &expr->where, "Argument NCOPIES of REPEAT intrinsic is too large"); /* Compute the destination length. */ - dlen = fold_build2 (MULT_EXPR, gfc_charlen_type_node, - fold_convert (gfc_charlen_type_node, slen), - fold_convert (gfc_charlen_type_node, ncopies)); + dlen = fold_build2_loc (input_location, MULT_EXPR, gfc_charlen_type_node, + fold_convert (gfc_charlen_type_node, slen), + fold_convert (gfc_charlen_type_node, ncopies)); type = gfc_get_character_type (expr->ts.kind, expr->ts.u.cl); dest = gfc_conv_string_tmp (se, build_pointer_type (type), dlen); @@ -5094,31 +5189,34 @@ gfc_conv_intrinsic_repeat (gfc_se * se, gfc_start_block (&body); /* Exit the loop if count >= ncopies. */ - cond = fold_build2 (GE_EXPR, boolean_type_node, count, ncopies); + cond = fold_build2_loc (input_location, GE_EXPR, boolean_type_node, count, + ncopies); tmp = build1_v (GOTO_EXPR, exit_label); TREE_USED (exit_label) = 1; - tmp = fold_build3 (COND_EXPR, void_type_node, cond, tmp, - build_empty_stmt (input_location)); + tmp = fold_build3_loc (input_location, COND_EXPR, void_type_node, cond, tmp, + build_empty_stmt (input_location)); gfc_add_expr_to_block (&body, tmp); /* Call memmove (dest + (i*slen*size), src, slen*size). */ - tmp = fold_build2 (MULT_EXPR, gfc_charlen_type_node, - fold_convert (gfc_charlen_type_node, slen), - fold_convert (gfc_charlen_type_node, count)); - tmp = fold_build2 (MULT_EXPR, gfc_charlen_type_node, - tmp, fold_convert (gfc_charlen_type_node, size)); - tmp = fold_build2 (POINTER_PLUS_EXPR, pvoid_type_node, - fold_convert (pvoid_type_node, dest), - fold_convert (sizetype, tmp)); + tmp = fold_build2_loc (input_location, MULT_EXPR, gfc_charlen_type_node, + fold_convert (gfc_charlen_type_node, slen), + fold_convert (gfc_charlen_type_node, count)); + tmp = fold_build2_loc (input_location, MULT_EXPR, gfc_charlen_type_node, + tmp, fold_convert (gfc_charlen_type_node, size)); + tmp = fold_build2_loc (input_location, POINTER_PLUS_EXPR, pvoid_type_node, + fold_convert (pvoid_type_node, dest), + fold_convert (sizetype, tmp)); tmp = build_call_expr_loc (input_location, - built_in_decls[BUILT_IN_MEMMOVE], 3, tmp, src, - fold_build2 (MULT_EXPR, size_type_node, slen, - fold_convert (size_type_node, size))); + built_in_decls[BUILT_IN_MEMMOVE], 3, tmp, src, + fold_build2_loc (input_location, MULT_EXPR, + size_type_node, slen, + fold_convert (size_type_node, + size))); gfc_add_expr_to_block (&body, tmp); /* Increment count. */ - tmp = fold_build2 (PLUS_EXPR, ncopies_type, - count, build_int_cst (TREE_TYPE (count), 1)); + tmp = fold_build2_loc (input_location, PLUS_EXPR, ncopies_type, + count, build_int_cst (TREE_TYPE (count), 1)); gfc_add_modify (&body, count, tmp); /* Build the loop. */ Index: gcc/fortran/convert.c =================================================================== --- gcc/fortran/convert.c (Revision 163859) +++ gcc/fortran/convert.c (Arbeitskopie) @@ -80,7 +80,7 @@ convert (tree type, tree expr) return expr; if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr))) - return fold_build1 (NOP_EXPR, type, expr); + return fold_build1_loc (input_location, NOP_EXPR, type, expr); if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK) return error_mark_node; if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE) @@ -89,7 +89,7 @@ convert (tree type, tree expr) return error_mark_node; } if (code == VOID_TYPE) - return fold_build1 (CONVERT_EXPR, type, e); + return fold_build1_loc (input_location, CONVERT_EXPR, type, e); #if 0 /* This is incorrect. A truncation can't be stripped this way. Extensions will be stripped by the use of get_unwidened. */ @@ -105,9 +105,10 @@ convert (tree type, tree expr) /* If we have a NOP_EXPR, we must fold it here to avoid infinite recursion between fold () and convert (). */ if (TREE_CODE (e) == NOP_EXPR) - return fold_build1 (NOP_EXPR, type, TREE_OPERAND (e, 0)); + return fold_build1_loc (input_location, NOP_EXPR, type, + TREE_OPERAND (e, 0)); else - return fold_build1 (NOP_EXPR, type, e); + return fold_build1_loc (input_location, NOP_EXPR, type, e); } if (code == POINTER_TYPE || code == REFERENCE_TYPE) return fold (convert_to_pointer (type, e)); Index: gcc/fortran/f95-lang.c =================================================================== --- gcc/fortran/f95-lang.c (Revision 163859) +++ gcc/fortran/f95-lang.c (Arbeitskopie) @@ -200,17 +200,18 @@ gfc_truthvalue_conversion (tree expr) return expr; } else if (TREE_CODE (expr) == NOP_EXPR) - return fold_build1 (NOP_EXPR, + return fold_build1_loc (input_location, NOP_EXPR, boolean_type_node, TREE_OPERAND (expr, 0)); else - return fold_build1 (NOP_EXPR, boolean_type_node, expr); + return fold_build1_loc (input_location, NOP_EXPR, boolean_type_node, + expr); case INTEGER_TYPE: if (TREE_CODE (expr) == INTEGER_CST) return integer_zerop (expr) ? boolean_false_node : boolean_true_node; else - return fold_build2 (NE_EXPR, boolean_type_node, expr, - build_int_cst (TREE_TYPE (expr), 0)); + return fold_build2_loc (input_location, NE_EXPR, boolean_type_node, + expr, build_int_cst (TREE_TYPE (expr), 0)); default: internal_error ("Unexpected type in truthvalue_conversion");