Fix issue 27062764 (AddressSanitizer: initialization-order-fiasco)

runtime/vm/regexp_assembler_ir.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/regexp_assembler_ir.h"
 
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/flow_graph_builder.h"
@@ skipping 18 matching lines @@
         String::Handle(String::New(__FUNCTION__)), Heap::kOld))))));
 
 #define PRINT(arg) if (FLAG_trace_irregexp) { Print(arg); }
 
 namespace dart {
 
 DEFINE_FLAG(bool, trace_irregexp, false, "Trace irregexps");
 
 
 static const intptr_t kInvalidTryIndex = CatchClauseNode::kInvalidTryIndex;
-static const TokenPosition kNoSourcePos = TokenPosition::kNoSource;
 static const intptr_t kMinStackSize = 512;
 
 
 void PrintUtf16(uint16_t c) {
   const char* format = (0x20 <= c && c <= 0x7F) ?
         "%c" : (c <= 0xff) ? "\\x%02x" : "\\u%04x";
   OS::Print(format, c);
 }
 
 
@@ skipping 189 matching lines @@
 }
 
 
 void IRRegExpMacroAssembler::GenerateSuccessBlock() {
   set_current_instruction(success_block_);
   TAG();
 
   Value* type = Bind(new(Z) ConstantInstr(
       TypeArguments::ZoneHandle(Z, TypeArguments::null())));
   Value* length = Bind(Uint64Constant(saved_registers_count_));
-  Value* array = Bind(new(Z) CreateArrayInstr(kNoSourcePos, type, length));
+  Value* array = Bind(new(Z) CreateArrayInstr(
+      TokenPosition::kNoSource, type, length));
   StoreLocal(result_, array);
 
   // Store captured offsets in the `matches` parameter.
   for (intptr_t i = 0; i < saved_registers_count_; i++) {
     PushArgumentInstr* matches_push = PushLocal(result_);
     PushArgumentInstr* index_push = PushArgument(Bind(Uint64Constant(i)));
 
     // Convert negative offsets from the end of the string to string indices.
     // TODO(zerny): use positive offsets from the get-go.
     PushArgumentInstr* offset_push = PushArgument(LoadRegister(i));
     PushArgumentInstr* len_push = PushLocal(string_param_length_);
     PushArgumentInstr* value_push =
         PushArgument(Bind(Add(offset_push, len_push)));
 
     Do(InstanceCall(InstanceCallDescriptor::FromToken(Token::kASSIGN_INDEX),
                     matches_push,
                     index_push,
                     value_push));
   }
 
   // Print the result if tracing.
   PRINT(PushLocal(result_));
 
   // Return true on success.
-  AppendInstruction(new(Z) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
+  AppendInstruction(new(Z) ReturnInstr(
+      TokenPosition::kNoSource, Bind(LoadLocal(result_))));
 }
 
 
 void IRRegExpMacroAssembler::GenerateExitBlock() {
   set_current_instruction(exit_block_);
   TAG();
 
   // Return false on failure.
-  AppendInstruction(new(Z) ReturnInstr(kNoSourcePos, Bind(LoadLocal(result_))));
+  AppendInstruction(new(Z) ReturnInstr(
+      TokenPosition::kNoSource, Bind(LoadLocal(result_))));
 }
 
 
 void IRRegExpMacroAssembler::FinalizeRegistersArray() {
   ASSERT(registers_count_ >= saved_registers_count_);
   registers_array_ =
       TypedData::New(kTypedDataInt32ArrayCid, registers_count_, Heap::kOld);
 }
 
 
@@ skipping 81 matching lines @@
 }
 
 
 DEFINE_RAW_LEAF_RUNTIME_ENTRY(
     CaseInsensitiveCompareUC16, 4, false /* is_float */,
     reinterpret_cast<RuntimeFunction>(&CaseInsensitiveCompareUC16));
 
 
 LocalVariable* IRRegExpMacroAssembler::Parameter(const String& name,
                                                  intptr_t index) const {
-  LocalVariable* local =
-      new(Z) LocalVariable(kNoSourcePos, name, Object::dynamic_type());
+  LocalVariable* local = new(Z) LocalVariable(
+      TokenPosition::kNoSource, name, Object::dynamic_type());
 
   intptr_t param_frame_index = kParamEndSlotFromFp + kParamCount - index;
   local->set_index(param_frame_index);
 
   return local;
 }
 
 
 LocalVariable* IRRegExpMacroAssembler::Local(const String& name) {
-  LocalVariable* local =
-      new(Z) LocalVariable(kNoSourcePos, name, Object::dynamic_type());
+  LocalVariable* local = new(Z) LocalVariable(
+      TokenPosition::kNoSource, name, Object::dynamic_type());
   local->set_index(GetNextLocalIndex());
 
   return local;
 }
 
 
 ConstantInstr* IRRegExpMacroAssembler::Int64Constant(int64_t value) const {
   return new(Z) ConstantInstr(
         Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
@@ skipping 65 matching lines @@
   ASSERT(intermediate_operator != Token::kILLEGAL);
 
   Value* lhs_value =
       Bind(InstanceCall(
              InstanceCallDescriptor::FromToken(intermediate_operator),
              lhs,
              rhs));
   Value* rhs_value = Bind(BoolConstant(true));
 
   return new(Z) StrictCompareInstr(
-      kNoSourcePos, strict_comparison, lhs_value, rhs_value, true);
+      TokenPosition::kNoSource, strict_comparison, lhs_value, rhs_value, true);
 }
 
 ComparisonInstr* IRRegExpMacroAssembler::Comparison(
     ComparisonKind kind, Definition* lhs, Definition* rhs) {
   PushArgumentInstr* lhs_push = PushArgument(Bind(lhs));
   PushArgumentInstr* rhs_push = PushArgument(Bind(rhs));
   return Comparison(kind, lhs_push, rhs_push);
 }
 
 
@@ skipping 25 matching lines @@
   arguments->Add(arg1);
   arguments->Add(arg2);
 
   return StaticCall(function, arguments);
 }
 
 
 StaticCallInstr* IRRegExpMacroAssembler::StaticCall(
     const Function& function,
     ZoneGrowableArray<PushArgumentInstr*>* arguments) const {
-  return new(Z) StaticCallInstr(kNoSourcePos,
+  return new(Z) StaticCallInstr(TokenPosition::kNoSource,
                                 function,
                                 Object::null_array(),
                                 arguments,
                                 ic_data_array_);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     PushArgumentInstr* arg1) const {
@@ skipping 30 matching lines @@
   arguments->Add(arg3);
 
   return InstanceCall(desc, arguments);
 }
 
 
 InstanceCallInstr* IRRegExpMacroAssembler::InstanceCall(
     const InstanceCallDescriptor& desc,
     ZoneGrowableArray<PushArgumentInstr*> *arguments) const {
   return
-    new(Z) InstanceCallInstr(kNoSourcePos,
+    new(Z) InstanceCallInstr(TokenPosition::kNoSource,
                              desc.name,
                              desc.token_kind,
                              arguments,
                              Object::null_array(),
                              desc.checked_argument_count,
                              ic_data_array_);
 }
 
 
 LoadLocalInstr* IRRegExpMacroAssembler::LoadLocal(LocalVariable* local) const {
-  return new(Z) LoadLocalInstr(*local, kNoSourcePos);
+  return new(Z) LoadLocalInstr(*local, TokenPosition::kNoSource);
 }
 
 
 void IRRegExpMacroAssembler::StoreLocal(LocalVariable* local,
                                         Value* value) {
-  Do(new(Z) StoreLocalInstr(*local, value, kNoSourcePos));
+  Do(new(Z) StoreLocalInstr(*local, value, TokenPosition::kNoSource));
 }
 
 
 void IRRegExpMacroAssembler::set_current_instruction(Instruction* instruction) {
   current_instruction_ = instruction;
 }
 
 
 Value* IRRegExpMacroAssembler::Bind(Definition* definition) {
   AppendInstruction(definition);
   definition->set_temp_index(temp_id_.Alloc());
 
   return new(Z) Value(definition);
 }
 
 
 void IRRegExpMacroAssembler::Do(Definition* definition) {
   AppendInstruction(definition);
 }
 
 
 Value* IRRegExpMacroAssembler::BindLoadLocal(const LocalVariable& local) {
   if (local.IsConst()) {
     return Bind(new(Z) ConstantInstr(*local.ConstValue()));
   }
   ASSERT(!local.is_captured());
-  return Bind(new(Z) LoadLocalInstr(local, kNoSourcePos));
+  return Bind(new(Z) LoadLocalInstr(local, TokenPosition::kNoSource));
 }
 
 
 // In some cases, the V8 irregexp engine generates unreachable code by emitting
 // a jmp not followed by a bind. We cannot do the same, since it is impossible
 // to append to a block following a jmp. In such cases, assume that we are doing
 // the correct thing, but output a warning when tracing.
 #define HANDLE_DEAD_CODE_EMISSION() \
   if (current_instruction_ == NULL) { \
     if (FLAG_trace_irregexp) { \
@@ skipping 1192 matching lines @@
   blocks_.Add(target);
 
   target->AppendInstruction(new(Z) GotoInstr(dst));
 
   return target;
 }
 
 
 void IRRegExpMacroAssembler::CheckPreemption() {
   TAG();
-  AppendInstruction(new(Z) CheckStackOverflowInstr(kNoSourcePos, 0));
+  AppendInstruction(new(Z) CheckStackOverflowInstr(
+      TokenPosition::kNoSource, 0));
 }
 
 
 Definition* IRRegExpMacroAssembler::Add(
     PushArgumentInstr* lhs,
     PushArgumentInstr* rhs) {
   return InstanceCall(InstanceCallDescriptor::FromToken(Token::kADD), lhs, rhs);
 }
 
 
@@ skipping 69 matching lines @@
   }
 
   // Here pattern_val might be untagged so this must not trigger a GC.
   Value* index_val = BindLoadLocal(*index);
 
   return Bind(new(Z) LoadCodeUnitsInstr(
       pattern_val,
       index_val,
       characters,
       specialization_cid_,
-      kNoSourcePos));
+      TokenPosition::kNoSource));
 }
 
 
 #undef __
 
 }  // namespace dart