compiler: use builtin memset for non-pointer memclr

    For zeroing a range of memory that doesn't contain pointer, we
    can use builtin memset directly.

    Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/184438

	* go-gcc.cc (Gcc_backend::Gcc_backend): Define __builtin_memset.

From-SVN: r272944

diff --git a/gcc/go/ChangeLog b/gcc/go/ChangeLog
index 9842c85925ef0590b04053929f762fef70b6685b..60d11875ed3df7f49d28c6218c0391b123b4dfdc 100644 (file)
--- a/gcc/go/ChangeLog
+++ b/gcc/go/ChangeLog
@@ -1,3 +1,7 @@
+2019-07-02  Cherry Zhang  <cherryyz@google.com>
+
+       * go-gcc.cc (Gcc_backend::Gcc_backend): Define __builtin_memset.
+
 2019-06-21  Cherry Zhang  <cherryyz@google.com>
 
        * go-gcc.cc (Gcc_backend::Gcc_backend): Define math/bits

diff --git a/gcc/go/go-gcc.cc b/gcc/go/go-gcc.cc
index 879149eb22f4f3460265336bddaacfd89b86e519..d9fc1a733402357287df8559c9d88d7471c42f64 100644 (file)
--- a/gcc/go/go-gcc.cc
+++ b/gcc/go/go-gcc.cc
@@ -613,6 +613,15 @@ Gcc_backend::Gcc_backend()
                                                NULL_TREE),
                       false, false);
 
+  // We use __builtin_memset for zeroing data.
+  this->define_builtin(BUILT_IN_MEMSET, "__builtin_memset", "memset",
+                      build_function_type_list(void_type_node,
+                                               ptr_type_node,
+                                               integer_type_node,
+                                               size_type_node,
+                                               NULL_TREE),
+                      false, false);
+
   // Used by runtime/internal/sys and math/bits.
   this->define_builtin(BUILT_IN_CTZ, "__builtin_ctz", "ctz",
                       build_function_type_list(integer_type_node,

diff --git a/gcc/go/gofrontend/MERGE b/gcc/go/gofrontend/MERGE
index 7ee3e11df447150c15ef6ed472f4574a6089a89a..11cba0fa8910f6e44fdff42e335e76c91f7e91b0 100644 (file)
--- a/gcc/go/gofrontend/MERGE
+++ b/gcc/go/gofrontend/MERGE
@@ -1,4 +1,4 @@
-1e042a49d6f2e95d371301aa7b911522dc5877f4
+7f753feb8df400d6ed17cdbdfb364f7f3a42fb31
 
 The first line of this file holds the git revision number of the last
 merge done from the gofrontend repository.

diff --git a/gcc/go/gofrontend/expressions.cc b/gcc/go/gofrontend/expressions.cc
index 2f33deeb4a1baaa0bd8e3d165c98a994214bf7ae..d52155183c624f83efa8e4cff25abeba1b7fee14 100644 (file)
--- a/gcc/go/gofrontend/expressions.cc
+++ b/gcc/go/gofrontend/expressions.cc
@@ -8910,10 +8910,16 @@ Builtin_call_expression::flatten_append(Gogo* gogo, Named_object* function,
           a2 = Expression::make_type_info(element_type, TYPE_INFO_SIZE);
           a2 = Expression::make_binary(OPERATOR_MULT, a2, ref, loc);
 
-          Runtime::Function code = (element_type->has_pointer()
-                                    ? Runtime::MEMCLRHASPTR
-                                    : Runtime::MEMCLRNOPTR);
-          call = Runtime::make_call(code, loc, 2, a1, a2);
+          if (element_type->has_pointer())
+            call = Runtime::make_call(Runtime::MEMCLRHASPTR, loc, 2, a1, a2);
+          else
+            {
+              Type* int32_type = Type::lookup_integer_type("int32");
+              Expression* zero =
+                Expression::make_integer_ul(0, int32_type, loc);
+              call = Runtime::make_call(Runtime::BUILTIN_MEMSET, loc, 3, a1,
+                                        zero, a2);
+            }
 
           if (element_type->has_pointer())
             {

diff --git a/gcc/go/gofrontend/runtime.def b/gcc/go/gofrontend/runtime.def
index ec7ec769048d0726c9f542a555b3e70bb209bd24..f510a65e7b73e008069a5f9e07e5b5cac4b67a31 100644 (file)
--- a/gcc/go/gofrontend/runtime.def
+++ b/gcc/go/gofrontend/runtime.def
@@ -351,10 +351,6 @@ DEF_GO_RUNTIME(GCWRITEBARRIER, "runtime.gcWriteBarrier",
 DEF_GO_RUNTIME(TYPEDMEMMOVE, "runtime.typedmemmove",
               P3(TYPE, POINTER, POINTER), R0())
 
-// Clear memory that contains no pointer.
-DEF_GO_RUNTIME(MEMCLRNOPTR, "runtime.memclrNoHeapPointers",
-               P2(POINTER, UINTPTR), R0())
-
 // Clear memory that contains pointer.
 DEF_GO_RUNTIME(MEMCLRHASPTR, "runtime.memclrHasPointers",
                P2(POINTER, UINTPTR), R0())
@@ -414,6 +410,10 @@ DEF_GO_RUNTIME(UNREACHABLE, "__builtin_unreachable", P0(), R0())
 DEF_GO_RUNTIME(BUILTIN_MEMMOVE, "__builtin_memmove",
                P3(POINTER, POINTER, UINTPTR), R0())
 
+// Memset, used for zeroing memory.
+DEF_GO_RUNTIME(BUILTIN_MEMSET, "__builtin_memset",
+               P3(POINTER, INT32, UINTPTR), R0())
+
 // Various intrinsics.
 
 // Get the caller's PC, used for runtime.getcallerpc.

diff --git a/gcc/go/gofrontend/statements.cc b/gcc/go/gofrontend/statements.cc
index c0955888b549375e5005fa3e28464f578518c1bd..968c8a01b5787a1726b6779696047f0052896a07 100644 (file)
--- a/gcc/go/gofrontend/statements.cc
+++ b/gcc/go/gofrontend/statements.cc
@@ -6882,12 +6882,18 @@ For_range_statement::lower_array_range_clear(Gogo* gogo,
   Temporary_statement* ts2 = Statement::make_temporary(NULL, e2, loc);
   b->add_statement(ts2);
 
-  Expression* arg1 = Expression::make_temporary_reference(ts1, loc);
-  Expression* arg2 = Expression::make_temporary_reference(ts2, loc);
-  Runtime::Function code = (elem_type->has_pointer()
-                            ? Runtime::MEMCLRHASPTR
-                            : Runtime::MEMCLRNOPTR);
-  Expression* call = Runtime::make_call(code, loc, 2, arg1, arg2);
+  Expression* ptr_arg = Expression::make_temporary_reference(ts1, loc);
+  Expression* sz_arg = Expression::make_temporary_reference(ts2, loc);
+  Expression* call;
+  if (elem_type->has_pointer())
+    call = Runtime::make_call(Runtime::MEMCLRHASPTR, loc, 2, ptr_arg, sz_arg);
+  else
+    {
+      Type* int32_type = Type::lookup_integer_type("int32");
+      Expression* zero = Expression::make_integer_ul(0, int32_type, loc);
+      call = Runtime::make_call(Runtime::BUILTIN_MEMSET, loc, 3, ptr_arg,
+                                zero, sz_arg);
+    }
   Statement* cs3 = Statement::make_statement(call, true);
   b->add_statement(cs3);