[vm] Fix gcc build.

Change-Id: I8a0a9a695403dc6d048dccb9f33642d70cc5d588
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/121866
Reviewed-by: Liam Appelbe <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

build/config/linux/BUILD.gn

@@ -5,19 +5,21 @@
 import("//build/config/sysroot.gni")
 
 config("sdk") {
-  # Don't allow visible symbols from libc++ to be re-exported.
-  ldflags = [
-    "-nodefaultlibs",
-    "-lc++",
-    "-lc",
-    "-lm",
-    "-lpthread",
-    "-lclang_rt.builtins",
-    "-Wl,--exclude-libs=libc++.a",
-  ]
+  ldflags = []
 
   if (is_asan || is_lsan || is_msan || is_tsan || is_ubsan) {
     ldflags += [ "-lrt" ]
+  } else if (is_clang) {
+    # Don't allow visible symbols from libc++ to be re-exported.
+    ldflags = [
+      "-nodefaultlibs",
+      "-lc++",
+      "-lc",
+      "-lm",
+      "-lpthread",
+      "-lclang_rt.builtins",
+      "-Wl,--exclude-libs=libc++.a",
+    ]
   }
 
   if (sysroot != "") {

runtime/BUILD.gn

@@ -168,6 +168,9 @@ config("dart_config") {
       "-fno-exceptions",
       "-Wimplicit-fallthrough",
     ]
+    if (!is_clang) {
+      cflags += [ "-Wno-cast-function-type" ]
+    }
 
     ldflags = []
     if (is_clang && dart_vm_code_coverage) {

runtime/bin/ffi_test/ffi_test_functions.cc

@@ -16,6 +16,9 @@
 #include <unistd.h>
 
 // Only OK to use here because this is test code.
+#include <condition_variable>  // NOLINT(build/c++11)
+#include <functional>          // NOLINT(build/c++11)
+#include <mutex>               // NOLINT(build/c++11)
 #include <thread>  // NOLINT(build/c++11)
 #endif
 

runtime/vm/class_table.cc

@@ -252,9 +252,12 @@ void SharedClassTable::Grow(intptr_t new_capacity) {
   memmove(new_table, table_, top_ * sizeof(intptr_t));
   memset(new_table + top_, 0, (new_capacity - top_) * sizeof(intptr_t));
 #ifndef PRODUCT
-  auto new_stats_table = static_cast<ClassHeapStats*>(
-      realloc(class_heap_stats_table_,
-              new_capacity * sizeof(ClassHeapStats)));  // NOLINT
+  auto new_stats_table = reinterpret_cast<ClassHeapStats*>(
+      malloc(new_capacity * sizeof(ClassHeapStats)));
+  for (intptr_t i = 0; i < capacity_; i++) {
+    new_stats_table[i] = class_heap_stats_table_[i];
+  }
+  free(class_heap_stats_table_);
 #endif
   for (intptr_t i = capacity_; i < new_capacity; i++) {
     new_table[i] = 0;

runtime/vm/compiler/aot/precompiler.cc

@@ -2274,13 +2274,12 @@ void PrecompileParsedFunctionHelper::FinalizeCompilation(
 // to install code.
 bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
   ASSERT(FLAG_precompiled_mode);
-  const Function& function = parsed_function()->function();
-  if (optimized() && !function.IsOptimizable()) {
+  if (optimized() && !parsed_function()->function().IsOptimizable()) {
     // All functions compiled by precompiler must be optimizable.
     UNREACHABLE();
     return false;
   }
-  bool is_compiled = false;
+  volatile bool is_compiled = false;
   Zone* const zone = thread()->zone();
   HANDLESCOPE(thread());
 
@@ -2301,6 +2300,7 @@ bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
     if (val == 0) {
       FlowGraph* flow_graph = nullptr;
       ZoneGrowableArray<const ICData*>* ic_data_array = nullptr;
+      const Function& function = parsed_function()->function();
 
       CompilerState compiler_state(thread());
 
@@ -2314,7 +2314,7 @@ bool PrecompileParsedFunctionHelper::Compile(CompilationPipeline* pipeline) {
       }
 
       if (optimized()) {
-        flow_graph->PopulateWithICData(parsed_function()->function());
+        flow_graph->PopulateWithICData(function);
       }
 
       const bool print_flow_graph =

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -2270,7 +2270,7 @@ void FlowGraphCompiler::GenerateCidRangesCheck(
 
   int bias = 0;
   for (intptr_t i = 0; i < cid_ranges.length(); ++i) {
-    const CidRange& range = cid_ranges[i];
+    const CidRangeValue& range = cid_ranges[i];
     RELEASE_ASSERT(!range.IsIllegalRange());
     const bool last_round = i == (cid_ranges.length() - 1);
 

runtime/vm/compiler/backend/flow_graph_compiler.h

@@ -872,7 +872,7 @@ class FlowGraphCompiler : public ValueObject {
   static int EmitTestAndCallCheckCid(compiler::Assembler* assembler,
                                      compiler::Label* label,
                                      Register class_id_reg,
-                                     const CidRange& range,
+                                     const CidRangeValue& range,
                                      int bias,
                                      bool jump_on_miss = true);
 

runtime/vm/compiler/backend/flow_graph_compiler_arm.cc

@@ -1330,7 +1330,7 @@ void FlowGraphCompiler::EmitTestAndCallLoadCid(Register class_id_reg) {
 int FlowGraphCompiler::EmitTestAndCallCheckCid(compiler::Assembler* assembler,
                                                compiler::Label* label,
                                                Register class_id_reg,
-                                               const CidRange& range,
+                                               const CidRangeValue& range,
                                                int bias,
                                                bool jump_on_miss) {
   intptr_t cid_start = range.cid_start;

runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc

@@ -1297,7 +1297,7 @@ void FlowGraphCompiler::EmitTestAndCallLoadCid(Register class_id_reg) {
 int FlowGraphCompiler::EmitTestAndCallCheckCid(compiler::Assembler* assembler,
                                                compiler::Label* label,
                                                Register class_id_reg,
-                                               const CidRange& range,
+                                               const CidRangeValue& range,
                                                int bias,
                                                bool jump_on_miss) {
   const intptr_t cid_start = range.cid_start;

runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc

@@ -1185,7 +1185,7 @@ void FlowGraphCompiler::EmitTestAndCallLoadCid(Register class_id_reg) {
 int FlowGraphCompiler::EmitTestAndCallCheckCid(compiler::Assembler* assembler,
                                                compiler::Label* label,
                                                Register class_id_reg,
-                                               const CidRange& range,
+                                               const CidRangeValue& range,
                                                int bias,
                                                bool jump_on_miss) {
   intptr_t cid_start = range.cid_start;

runtime/vm/compiler/backend/flow_graph_compiler_x64.cc

@@ -1302,7 +1302,7 @@ void FlowGraphCompiler::EmitTestAndCallLoadCid(Register class_id_reg) {
 int FlowGraphCompiler::EmitTestAndCallCheckCid(compiler::Assembler* assembler,
                                                compiler::Label* label,
                                                Register class_id_reg,
-                                               const CidRange& range,
+                                               const CidRangeValue& range,
                                                int bias,
                                                bool jump_on_miss) {
   // Note of WARNING: Due to smaller instruction encoding we use the 32-bit

runtime/vm/compiler/backend/il.cc

@@ -466,7 +466,7 @@ bool HierarchyInfo::InstanceOfHasClassRange(const AbstractType& type,
                               /*include_abstract=*/false,
                               /*exclude_null=*/true);
     if (ranges.length() == 1) {
-      const CidRange& range = ranges[0];
+      const CidRangeValue& range = ranges[0];
       if (!range.IsIllegalRange()) {
         *lower_limit = range.cid_start;
         *upper_limit = range.cid_end;

runtime/vm/compiler/backend/il.h

@@ -177,18 +177,33 @@ class Value : public ZoneAllocated {
 // Represents a range of class-ids for use in class checks and polymorphic
 // dispatches.  The range includes both ends, i.e. it is [cid_start, cid_end].
 struct CidRange : public ZoneAllocated {
-  CidRange(const CidRange& o)
-      : ZoneAllocated(), cid_start(o.cid_start), cid_end(o.cid_end) {}
   CidRange(intptr_t cid_start_arg, intptr_t cid_end_arg)
       : cid_start(cid_start_arg), cid_end(cid_end_arg) {}
   CidRange() : cid_start(kIllegalCid), cid_end(kIllegalCid) {}
 
-  const CidRange& operator=(const CidRange& other) {
-    cid_start = other.cid_start;
-    cid_end = other.cid_end;
-    return *this;
+  bool IsSingleCid() const { return cid_start == cid_end; }
+  bool Contains(intptr_t cid) { return cid_start <= cid && cid <= cid_end; }
+  int32_t Extent() const { return cid_end - cid_start; }
+
+  // The number of class ids this range covers.
+  intptr_t size() const { return cid_end - cid_start + 1; }
+
+  bool IsIllegalRange() const {
+    return cid_start == kIllegalCid && cid_end == kIllegalCid;
   }
 
+  intptr_t cid_start;
+  intptr_t cid_end;
+
+  DISALLOW_COPY_AND_ASSIGN(CidRange);
+};
+
+struct CidRangeValue {
+  CidRangeValue(intptr_t cid_start_arg, intptr_t cid_end_arg)
+      : cid_start(cid_start_arg), cid_end(cid_end_arg) {}
+  CidRangeValue(const CidRange& other)  // NOLINT
+      : cid_start(other.cid_start), cid_end(other.cid_end) {}
+
   bool IsSingleCid() const { return cid_start == cid_end; }
   bool Contains(intptr_t cid) { return cid_start <= cid && cid <= cid_end; }
   int32_t Extent() const { return cid_end - cid_start; }
@@ -204,7 +219,7 @@ struct CidRange : public ZoneAllocated {
   intptr_t cid_end;
 };
 
-typedef MallocGrowableArray<CidRange> CidRangeVector;
+typedef MallocGrowableArray<CidRangeValue> CidRangeVector;
 
 class HierarchyInfo : public ThreadStackResource {
  public:
@@ -576,6 +591,8 @@ struct TargetInfo : public CidRange {
   const Function* target;
   intptr_t count;
   StaticTypeExactnessState exactness;
+
+  DISALLOW_COPY_AND_ASSIGN(TargetInfo);
 };
 
 // A set of class-ids, arranged in ranges. Used for the CheckClass
@@ -3716,7 +3733,7 @@ class InstanceCallInstr : public TemplateDartCall<0> {
   const CallTargets& Targets();
   void SetTargets(const CallTargets* targets) { targets_ = targets; }
 
-  const BinaryFeedback& BinaryFeedback();
+  const class BinaryFeedback& BinaryFeedback();
   void SetBinaryFeedback(const class BinaryFeedback* binary) {
     binary_ = binary;
   }
@@ -4248,7 +4265,7 @@ class StaticCallInstr : public TemplateDartCall<0> {
   virtual void SetIdentity(AliasIdentity identity) { identity_ = identity; }
 
   const CallTargets& Targets();
-  const BinaryFeedback& BinaryFeedback();
+  const class BinaryFeedback& BinaryFeedback();
 
   PRINT_OPERANDS_TO_SUPPORT
   ADD_OPERANDS_TO_S_EXPRESSION_SUPPORT
@@ -7810,13 +7827,13 @@ class CheckNullInstr : public TemplateDefinition<1, Throws, Pure> {
 
 class CheckClassIdInstr : public TemplateInstruction<1, NoThrow> {
  public:
-  CheckClassIdInstr(Value* value, CidRange cids, intptr_t deopt_id)
+  CheckClassIdInstr(Value* value, CidRangeValue cids, intptr_t deopt_id)
       : TemplateInstruction(deopt_id), cids_(cids) {
     SetInputAt(0, value);
   }
 
   Value* value() const { return inputs_[0]; }
-  const CidRange& cids() const { return cids_; }
+  const CidRangeValue& cids() const { return cids_; }
 
   DECLARE_INSTRUCTION(CheckClassId)
 
@@ -7834,7 +7851,7 @@ class CheckClassIdInstr : public TemplateInstruction<1, NoThrow> {
  private:
   bool Contains(intptr_t cid) const;
 
-  CidRange cids_;
+  CidRangeValue cids_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckClassIdInstr);
 };

runtime/vm/compiler/backend/il_deserializer.cc

@@ -1768,7 +1768,7 @@ bool FlowGraphDeserializer::ParseType(SExpression* sexp, Object* out) {
   // This isn't necessary the hash value we will have in the new FlowGraph, but
   // it will be how this type is referred to by TypeRefs in the serialized one.
   auto const old_hash = is_recursive ? hash_sexp->value() : 0;
-  ZoneGrowableArray<TypeRef*>* pending_typerefs;
+  ZoneGrowableArray<TypeRef*>* pending_typerefs = nullptr;
   if (is_recursive) {
     if (pending_typeref_map_.LookupValue(old_hash) != nullptr) {
       StoreError(sexp, "already parsing a type with hash %" Pd64 "",