https://gcc.gnu.org/g:eae644638908427b11f8d791f718851e25bece01
commit r17-2389-geae644638908427b11f8d791f718851e25bece01 Author: Naveen <[email protected]> Date: Tue Jul 14 01:42:06 2026 -0700 tree-optimization: Fold length-one memset through arbitrary pointers [PR102202] gimple_fold_builtin_memset currently folds constant-length memset calls into scalar stores only when the destination is an ADDR_EXPR. Calls through an arbitrary pointer, such as a function parameter are left as library calls and non-constant fill values are rejected even for the length-one case where byte replication is unnecessary. Add a dedicated folding path for length-one memset calls through arbitrary pointer destinations. Since the access is exactly one byte, use unsigned_char_type_node for the store. This supports both constant and non-constant fill values: constant fills are converted with fold_convert while non-constant fills use gimple_convert. Volatile qualification is preserved from the pointed-to type and the store is emitted as a MEM_REF at offset zero using the usual ref-all character pointer type. Defer this new arbitrary-pointer fold until after object-size analysis has run so that the original memset remains available to object-size based diagnostics. The existing ADDR_EXPR-based folding path for other constant lengths is unchanged. gcc/ChangeLog: PR tree-optimization/102202 * gimple-fold.cc (gimple_fold_builtin_memset): Hoist tree_to_uhwi (len) before the INTEGER_CST guard. Fold length-one memset calls through arbitrary pointer destinations. Build a ref-all MEM_REF at offset zero and preserve the call result when it is used. gcc/testsuite/ChangeLog: PR tree-optimization/102202 * gcc.dg/pr102202-fold.c: New test. Signed-off-by: Naveen <[email protected]> Diff: --- gcc/gimple-fold.cc | 63 ++++++++++++++++++++++++++++++++++-- gcc/testsuite/gcc.dg/pr102202-fold.c | 35 ++++++++++++++++++++ 2 files changed, 96 insertions(+), 2 deletions(-) diff --git a/gcc/gimple-fold.cc b/gcc/gimple-fold.cc index 4422a48383d5..fdb9b4197662 100644 --- a/gcc/gimple-fold.cc +++ b/gcc/gimple-fold.cc @@ -1478,10 +1478,70 @@ gimple_fold_builtin_memset (gimple_stmt_iterator *gsi, tree c, tree len) if (! tree_fits_uhwi_p (len)) return false; + length = tree_to_uhwi (len); + + tree dest = gimple_call_arg (stmt, 0); + if (length == 1 + && POINTER_TYPE_P (TREE_TYPE (dest))) + { + /* Keep the original call until object-size analysis has inspected it. */ + if (!(cfun->curr_properties & PROP_objsz)) + return false; + + /* Detect out-of-bounds accesses without issuing warnings. + Avoid folding out-of-bounds accesses but to avoid false + positives for unreachable code defer warning until after + DCE has worked its magic. + -Wrestrict is still diagnosed. */ + if (int warning = check_bounds_or_overlap (as_a <gcall *>(stmt), + dest, NULL_TREE, len, + NULL_TREE, false, false)) + if (warning != OPT_Wrestrict) + return false; + + etype = unsigned_char_type_node; + tree ptype = TREE_TYPE (TREE_TYPE (dest)); + if (TYPE_VOLATILE (ptype)) + etype = build_qualified_type (etype, TYPE_QUAL_VOLATILE); + + location_t loc = gimple_location (stmt); + tree cval_tree; + if (TREE_CODE (c) == INTEGER_CST) + cval_tree = fold_convert (etype, c); + else + cval_tree = gimple_convert (gsi, true, GSI_SAME_STMT, loc, etype, c); + + /* Build accesses at offset zero with a ref-all character type. */ + tree off0 + = build_int_cst (build_pointer_type_for_mode (char_type_node, + ptr_mode, true), 0); + tree var = fold_build2_loc (loc, MEM_REF, etype, dest, off0); + gimple *store = gimple_build_assign (var, cval_tree); + gimple_move_vops (store, stmt); + gimple_set_location (store, loc); + copy_warning (store, stmt); + + tree lhs = gimple_call_lhs (stmt); + if (!lhs) + { + gsi_replace (gsi, store, false); + return true; + } + + gsi_insert_before (gsi, store, GSI_SAME_STMT); + tree ret = dest; + if (!useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (dest))) + ret = gimple_convert (gsi, true, GSI_SAME_STMT, loc, + TREE_TYPE (lhs), dest); + gimple *asgn = gimple_build_assign (lhs, ret); + gsi_replace (gsi, asgn, false); + + return true; + } + if (TREE_CODE (c) != INTEGER_CST) return false; - tree dest = gimple_call_arg (stmt, 0); tree var = dest; if (TREE_CODE (var) != ADDR_EXPR) return false; @@ -1502,7 +1562,6 @@ gimple_fold_builtin_memset (gimple_stmt_iterator *gsi, tree c, tree len) if (! var_decl_component_p (var)) return false; - length = tree_to_uhwi (len); if (GET_MODE_SIZE (SCALAR_INT_TYPE_MODE (etype)) != length || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (etype)) != GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE (etype))) diff --git a/gcc/testsuite/gcc.dg/pr102202-fold.c b/gcc/testsuite/gcc.dg/pr102202-fold.c new file mode 100644 index 000000000000..5e2e58193c96 --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr102202-fold.c @@ -0,0 +1,35 @@ +/* PR tree-optimization/102202 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-optimized" } */ + +/* A constant-length-one memset is folded to a single byte store, even for a + store through an arbitrary pointer. */ + +void * +g1 (char *d, int c) +{ + return __builtin_memset (d, c, 1); +} + +void +g2 (char *d, int c) +{ + __builtin_memset (d, c, 1); +} + +void * +g3 (int *p, int c) +{ + return __builtin_memset (p, c, 1); +} + +void * +g4 (char *d) +{ + return __builtin_memset (d, 7, 1); +} + +/* { dg-final { scan-tree-dump-not "__builtin_memset" "optimized" } } */ +/* { dg-final { scan-tree-dump-times {\(unsigned char\) c_[0-9]+\(D\)} 3 "optimized" } } */ +/* { dg-final { scan-tree-dump-times {MEM[^;\n\r]*= _[0-9]+;} 3 "optimized" } } */ +/* { dg-final { scan-tree-dump-times {MEM[^;\n\r]*= 7;} 1 "optimized" } } */
