{ "__builtin_counted_by_ref", RID_BUILTIN_COUNTED_BY_REF, D_CONLY },
{ "__builtin_has_attribute", RID_BUILTIN_HAS_ATTRIBUTE, 0 },
{ "__builtin_launder", RID_BUILTIN_LAUNDER, D_CXXONLY },
+ { "__builtin_operator_new", RID_BUILTIN_OPERATOR_NEW, D_CXXONLY },
+ { "__builtin_operator_delete", RID_BUILTIN_OPERATOR_DELETE, D_CXXONLY },
{ "__builtin_shuffle", RID_BUILTIN_SHUFFLE, 0 },
{ "__builtin_shufflevector", RID_BUILTIN_SHUFFLEVECTOR, 0 },
{ "__builtin_stdc_bit_ceil", RID_BUILTIN_STDC, D_CONLY },
RID_ADDRESSOF,
RID_BUILTIN_LAUNDER,
RID_BUILTIN_BIT_CAST,
+ RID_BUILTIN_OPERATOR_NEW, RID_BUILTIN_OPERATOR_DELETE,
/* C++11 */
RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
extern const char *c_addr_space_name (addr_space_t as);
extern tree identifier_global_value (tree);
extern tree identifier_global_tag (tree);
-extern bool names_builtin_p (const char *);
+extern int names_builtin_p (const char *);
extern tree c_linkage_bindings (tree);
extern void record_builtin_type (enum rid, const char *, tree);
extern void start_fname_decls (void);
return NULL_TREE;
}
-/* Returns true if NAME refers to a built-in function or function-like
- operator. */
+/* Returns non-zero (result of __has_builtin) if NAME refers to a built-in
+ function or function-like operator. */
-bool
+int
names_builtin_p (const char *name)
{
tree id = get_identifier (name);
case RID_CHOOSE_EXPR:
case RID_OFFSETOF:
case RID_TYPES_COMPATIBLE_P:
- return true;
+ return 1;
default:
break;
}
- return false;
+ return 0;
}
/* In C, the only C-linkage public declaration is at file scope. */
return ret;
}
-/* Returns true if NAME refers to a built-in function or function-like
- operator. */
+/* Returns non-zero (result of __has_builtin) if NAME refers to a built-in
+ function or function-like operator. */
-bool
+int
names_builtin_p (const char *name)
{
tree id = get_identifier (name);
{
if (TREE_CODE (binding) == FUNCTION_DECL
&& DECL_IS_UNDECLARED_BUILTIN (binding))
- return true;
+ return 1;
/* Handle the case when an overload for a built-in name exists. */
if (TREE_CODE (binding) != OVERLOAD)
- return false;
+ return 0;
for (ovl_iterator it (binding); it; ++it)
{
tree decl = *it;
if (DECL_IS_UNDECLARED_BUILTIN (decl))
- return true;
+ return 1;
}
}
/* Check for built-in traits. */
if (IDENTIFIER_TRAIT_P (id))
- return true;
+ return 1;
/* Also detect common reserved C++ words that aren't strictly built-in
functions. */
case RID_BUILTIN_ASSOC_BARRIER:
case RID_BUILTIN_BIT_CAST:
case RID_OFFSETOF:
- return true;
+ return 1;
+ case RID_BUILTIN_OPERATOR_NEW:
+ case RID_BUILTIN_OPERATOR_DELETE:
+ return 201802L;
default:
break;
}
- return false;
+ return 0;
}
/* Register c++-specific dumps. */
case RID_BUILTIN_SHUFFLEVECTOR:
case RID_BUILTIN_LAUNDER:
case RID_BUILTIN_ASSOC_BARRIER:
+ case RID_BUILTIN_OPERATOR_NEW:
+ case RID_BUILTIN_OPERATOR_DELETE:
{
vec<tree, va_gc> *vec;
}
break;
+ case RID_BUILTIN_OPERATOR_NEW:
+ case RID_BUILTIN_OPERATOR_DELETE:
+ tree fn;
+ fn = ovl_op_identifier (keyword == RID_BUILTIN_OPERATOR_NEW
+ ? NEW_EXPR : DELETE_EXPR);
+ fn = lookup_qualified_name (global_namespace, fn);
+ postfix_expression = finish_call_expr (fn, &vec, true, false,
+ tf_warning_or_error);
+ if (postfix_expression != error_mark_node)
+ {
+ tree call = extract_call_expr (postfix_expression);
+ fn = cp_get_callee_fndecl_nofold (call);
+ if (fn ? !DECL_IS_REPLACEABLE_OPERATOR (fn)
+ : !processing_template_decl)
+ {
+ auto_diagnostic_group d;
+ if (keyword == RID_BUILTIN_OPERATOR_NEW)
+ error_at (loc, "call to %<__builtin_operator_new%> "
+ "does not select replaceable global "
+ "allocation function");
+ else
+ error_at (loc, "call to %<__builtin_operator_delete%> "
+ "does not select replaceable global "
+ "deallocation function");
+ if (fn)
+ inform (DECL_SOURCE_LOCATION (fn),
+ "selected function declared here");
+ }
+ else if (call && TREE_CODE (call) == CALL_EXPR)
+ CALL_FROM_NEW_OR_DELETE_P (call) = 1;
+ }
+ break;
+
default:
gcc_unreachable ();
}
else if (TREE_CODE (call) == AGGR_INIT_EXPR)
AGGR_INIT_EXPR_MUST_TAIL (call) = mtc;
}
+ if (CALL_FROM_NEW_OR_DELETE_P (t))
+ {
+ tree call = extract_call_expr (ret);
+ tree fn = cp_get_callee_fndecl_nofold (call);
+ if (fn ? !DECL_IS_REPLACEABLE_OPERATOR (fn)
+ : !processing_template_decl)
+ {
+ auto_diagnostic_group d;
+ location_t loc = cp_expr_loc_or_input_loc (t);
+ if (!fn || IDENTIFIER_NEW_OP_P (DECL_NAME (fn)))
+ error_at (loc, "call to %<__builtin_operator_new%> "
+ "does not select replaceable global "
+ "allocation function");
+ else
+ error_at (loc, "call to %<__builtin_operator_delete%> "
+ "does not select replaceable global "
+ "deallocation function");
+ if (fn)
+ inform (DECL_SOURCE_LOCATION (fn),
+ "selected function declared here");
+ }
+ else if (call && TREE_CODE (call) == CALL_EXPR)
+ CALL_FROM_NEW_OR_DELETE_P (call) = 1;
+ }
if (warning_suppressed_p (t, OPT_Wpessimizing_move))
/* This also suppresses -Wredundant-move. */
suppress_warning (ret, OPT_Wpessimizing_move);
* x86 specific memory model extensions for transactional memory:: x86 memory models.
* Object Size Checking:: Built-in functions for limited buffer overflow
checking.
+* New/Delete Builtins:: Built-in functions for C++ allocations and deallocations.
* Other Builtins:: Other built-in functions.
* Target Builtins:: Built-in functions specific to particular targets.
* Target Format Checks:: Format checks specific to particular targets.
is called and the @var{flag} argument passed to it.
@enddefbuiltin
+@node New/Delete Builtins
+@section Built-in functions for C++ allocations and deallocations
+@findex __builtin_operator_new
+@findex __builtin_operator_delete
+Calling these C++ built-in functions is similar to calling
+@code{::operator new} or @code{::operator delete} with the same arguments,
+except that it is an error if the selected @code{::operator new} or
+@code{::operator delete} overload is not a replaceable global operator
+and for optimization purposes calls to pairs of these functions can be
+omitted if access to the allocation is optimized out, or could be replaced
+with implementation provided buffer on the stack, or multiple allocation
+calls can be merged into a single allocation. In C++ such optimizations
+are normally allowed just for calls to such replaceable global operators
+from @code{new} and @code{delete} expressions.
+
+@smallexample
+void foo () @{
+ int *a = new int;
+ delete a; // This pair of allocation/deallocation operators can be omitted
+ // or replaced with int _temp; int *a = &_temp; etc.@:
+ void *b = ::operator new (32);
+ ::operator delete (b); // This one cannnot.
+ void *c = __builtin_operator_new (32);
+ __builtin_operator_delete (c); // This one can.
+@}
+@end smallexample
+
@node Other Builtins
@section Other Built-in Functions Provided by GCC
@cindex built-in functions
--- /dev/null
+// { dg-do compile }
+// { dg-options "-O2 -fdump-tree-gimple -fdump-tree-optimized" }
+// { dg-final { scan-tree-dump " = operator new \\\(" "gimple" } }
+// { dg-final { scan-tree-dump "operator delete \\\(" "gimple" } }
+// { dg-final { scan-tree-dump-not "operator new \\\(" "optimized" } }
+// { dg-final { scan-tree-dump-not "operator delete \\\(" "optimized" } }
+
+#include <new>
+
+#if __has_builtin (__builtin_operator_new) != 201802L
+#error "Unexpected value of __has_builtin (__builtin_operator_new)"
+#endif
+#if __has_builtin (__builtin_operator_delete) != 201802L
+#error "Unexpected value of __has_builtin (__builtin_operator_delete)"
+#endif
+
+void
+foo ()
+{
+ void *a = __builtin_operator_new (32);
+ __builtin_operator_delete (a);
+#if __cpp_sized_deallocation
+ a = __builtin_operator_new (32);
+ __builtin_operator_delete (a, 32);
+#endif
+#if __cpp_aligned_new
+ void *b = __builtin_operator_new (32, std::align_val_t(32));
+ __builtin_operator_delete (b, std::align_val_t(32));
+#if __cpp_sized_deallocation
+ b = __builtin_operator_new (32, std::align_val_t(32));
+ __builtin_operator_delete (b, 32, std::align_val_t(32));
+#endif
+#endif
+ void *c = __builtin_operator_new (32, std::nothrow);
+ __builtin_operator_delete (c, std::nothrow);
+#if __cpp_aligned_new
+ void *d = __builtin_operator_new (32, std::align_val_t(32), std::nothrow);
+ __builtin_operator_delete (d, std::align_val_t(32), std::nothrow);
+#endif
+ void *e = __builtin_operator_new (1.f);
+ __builtin_operator_delete (e);
+}
+
+template <int N>
+void
+bar ()
+{
+ void *a = __builtin_operator_new (32);
+ __builtin_operator_delete (a);
+#if __cpp_sized_deallocation
+ a = __builtin_operator_new (32);
+ __builtin_operator_delete (a, 32);
+#endif
+#if __cpp_aligned_new
+ void *b = __builtin_operator_new (32, std::align_val_t(32));
+ __builtin_operator_delete (b, std::align_val_t(32));
+#if __cpp_sized_deallocation
+ b = __builtin_operator_new (32, std::align_val_t(32));
+ __builtin_operator_delete (b, 32, std::align_val_t(32));
+#endif
+#endif
+ void *c = __builtin_operator_new (32, std::nothrow);
+ __builtin_operator_delete (c, std::nothrow);
+#if __cpp_aligned_new
+ void *d = __builtin_operator_new (32, std::align_val_t(32), std::nothrow);
+ __builtin_operator_delete (d, std::align_val_t(32), std::nothrow);
+#endif
+ void *e = __builtin_operator_new (1.f);
+ __builtin_operator_delete (e);
+}
+
+template <typename T, typename U, typename V, typename W>
+void
+baz (T sz, V v, W w)
+{
+ U a = __builtin_operator_new (sz);
+ __builtin_operator_delete (a);
+#if __cpp_sized_deallocation
+ a = __builtin_operator_new (sz);
+ __builtin_operator_delete (a, sz);
+#endif
+#if __cpp_aligned_new
+ U b = __builtin_operator_new (sz, std::align_val_t(sz));
+ __builtin_operator_delete (b, std::align_val_t(sz));
+#if __cpp_sized_deallocation
+ b = __builtin_operator_new (sz, std::align_val_t(sz));
+ __builtin_operator_delete (b, sz, std::align_val_t(sz));
+#endif
+#endif
+ U c = __builtin_operator_new (sz, v);
+ __builtin_operator_delete (c, v);
+#if __cpp_aligned_new
+ U d = __builtin_operator_new (sz, std::align_val_t(sz), v);
+ __builtin_operator_delete (d, std::align_val_t(sz), v);
+#endif
+ U e = __builtin_operator_new (w);
+ __builtin_operator_delete (e);
+}
+
+void
+qux ()
+{
+ bar <0> ();
+ baz <std::size_t, void *, const std::nothrow_t &, float> (32, std::nothrow,
+ 1.f);
+}
--- /dev/null
+// { dg-do compile }
+
+#include <new>
+
+void *operator new (std::size_t, float, double); // { dg-message "selected function declared here" }
+void operator delete (void *, float, double); // { dg-message "selected function declared here" }
+
+void
+foo (void *x)
+{
+ void *a = __builtin_operator_new (32, 1.f, 32.); // { dg-error "call to '__builtin_operator_new' does not select replaceable global allocation function" }
+ __builtin_operator_delete (a, 1.f, 32.); // { dg-error "call to '__builtin_operator_delete' does not select replaceable global deallocation function" }
+ void *b = __builtin_operator_new (32, x); // { dg-error "call to '__builtin_operator_new' does not select replaceable global allocation function" }
+ void *c = __builtin_operator_new (32, 1LL, 1L, 1); // { dg-error "no matching function for call to 'operator new\\\(int, long long int, long int, int\\\)'" }
+ __builtin_operator_delete (c, 1LL, 1L, 1); // { dg-error "no matching function for call to 'operator delete\\\(void\\\*&, long long int, long int, int\\\)'" }
+ void *d = __builtin_operator_new (); // { dg-error "no matching function for call to 'operator new\\\(\\\)'" }
+ __builtin_operator_delete (); // { dg-error "no matching function for call to 'operator delete\\\(\\\)'" }
+}
+
+template <int N>
+void
+bar (void *x)
+{
+ void *a = __builtin_operator_new (32, 1.f, 32.); // { dg-error "call to '__builtin_operator_new' does not select replaceable global allocation function" }
+ __builtin_operator_delete (a, 1.f, 32.); // { dg-error "call to '__builtin_operator_delete' does not select replaceable global deallocation function" }
+ void *b = __builtin_operator_new (32, x); // { dg-error "call to '__builtin_operator_new' does not select replaceable global allocation function" }
+ void *c = __builtin_operator_new (32, 1LL, 1L, 1); // { dg-error "no matching function for call to 'operator new\\\(int, long long int, long int, int\\\)'" }
+ __builtin_operator_delete (c, 1LL, 1L, 1); // { dg-error "no matching function for call to 'operator delete\\\(void\\\*&, long long int, long int, int\\\)'" }
+ void *d = __builtin_operator_new (); // { dg-error "no matching function for call to 'operator new\\\(\\\)'" }
+ __builtin_operator_delete (); // { dg-error "no matching function for call to 'operator delete\\\(\\\)'" }
+}
+
+template <typename T, typename U, typename V>
+void
+baz (void *x, T sz, V v)
+{
+ U a = __builtin_operator_new (sz, 1.f, 32.); // { dg-error "call to '__builtin_operator_new' does not select replaceable global allocation function" }
+ __builtin_operator_delete (a, 1.f, 32.); // { dg-error "call to '__builtin_operator_delete' does not select replaceable global deallocation function" }
+ U b = __builtin_operator_new (sz, x); // { dg-error "call to '__builtin_operator_new' does not select replaceable global allocation function" }
+ U c = __builtin_operator_new (sz, v, 1L, 1); // { dg-error "no matching function for call to 'operator new\\\(int&, long long int&, long int, int\\\)'" }
+ __builtin_operator_delete (c, v, 1L, 1); // { dg-error "no matching function for call to 'operator delete\\\(void\\\*&, long long int&, long int, int\\\)'" }
+}
+
+void
+qux (void *x, void *y)
+{
+ bar <0> (x);
+ baz <int, void *, long long> (y, 32, 1LL);
+}
--- /dev/null
+// { dg-do run }
+
+#include <new>
+
+void
+use (void *p)
+{
+ int *volatile q = new (p) int;
+ *q = 42;
+ (*q)++;
+ if (*q != 43)
+ __builtin_abort ();
+}
+
+int
+main ()
+{
+ void *volatile a = __builtin_operator_new (sizeof (int));
+ use (a);
+ __builtin_operator_delete (a);
+#if __cpp_sized_deallocation
+ a = __builtin_operator_new (sizeof (int));
+ use (a);
+ __builtin_operator_delete (a, sizeof (int));
+#endif
+#if __cpp_aligned_new
+ void *volatile b = __builtin_operator_new (sizeof (int), std::align_val_t(alignof (int) * 4));
+ use (b);
+ __builtin_operator_delete (b, std::align_val_t(alignof (int) * 4));
+#if __cpp_sized_deallocation
+ b = __builtin_operator_new (sizeof (int), std::align_val_t(alignof (int) * 4));
+ use (b);
+ __builtin_operator_delete (b, sizeof (int), std::align_val_t(alignof (int) * 4));
+#endif
+#endif
+ void *volatile c = __builtin_operator_new (sizeof (int), std::nothrow);
+ use (c);
+ __builtin_operator_delete (c, std::nothrow);
+#if __cpp_aligned_new
+ void *volatile d = __builtin_operator_new (sizeof (int), std::align_val_t(alignof (int) * 4), std::nothrow);
+ use (d);
+ __builtin_operator_delete (d, std::align_val_t(sizeof (int)), std::nothrow);
+#endif
+ void *volatile e = __builtin_operator_new (1.f);
+ use (e);
+ __builtin_operator_delete (e);
+}
projects / thirdparty / gcc.git / commitdiff
