Allows turning on checked mode on a per-isolate basis

runtime/vm/intrinsifier_ia32.cc

 // Copyright (c) 2013, 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.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
@@ skipping 15 matching lines @@
 
 DECLARE_FLAG(bool, enable_type_checks);
 
 
 #define __ assembler->
 
 
 intptr_t Intrinsifier::ParameterSlotFromSp() { return 0; }
 
 
+static bool TypeChecksEnabled() {
+  return FLAG_enable_type_checks || Isolate::Current()->checked_mode();
+}
+
+
 static intptr_t ComputeObjectArrayTypeArgumentsOffset() {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Class& cls = Class::Handle(
       core_lib.LookupClassAllowPrivate(Symbols::_List()));
   ASSERT(!cls.IsNull());
   ASSERT(cls.NumTypeArguments() == 1);
   const intptr_t field_offset = cls.type_arguments_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   return field_offset;
 }
 
 
 // Intrinsify only for Smi value and index. Non-smi values need a store buffer
 // update. Array length is always a Smi.
 void Intrinsifier::ObjectArraySetIndexed(Assembler* assembler) {
   Label fall_through;
-  if (FLAG_enable_type_checks) {
+  if (TypeChecksEnabled()) {
     const intptr_t type_args_field_offset =
         ComputeObjectArrayTypeArgumentsOffset();
     // Inline simple tests (Smi, null), fallthrough if not positive.
     const Immediate& raw_null =
         Immediate(reinterpret_cast<intptr_t>(Object::null()));
     Label checked_ok;
     __ movl(EDI, Address(ESP, + 1 * kWordSize));  // Value.
     // Null value is valid for any type.
     __ cmpl(EDI, raw_null);
     __ j(EQUAL, &checked_ok, Assembler::kNearJump);
@@ skipping 80 matching lines @@
 
   __ Bind(&fall_through);
 }
 
 
 // Add an element to growable array if it doesn't need to grow, otherwise
 // call into regular code.
 // On stack: growable array (+2), value (+1), return-address (+0).
 void Intrinsifier::GrowableArray_add(Assembler* assembler) {
   // In checked mode we need to type-check the incoming argument.
-  if (FLAG_enable_type_checks) return;
+  if (TypeChecksEnabled()) return;
 
   Label fall_through;
   __ movl(EAX, Address(ESP, + 2 * kWordSize));  // Array.
   __ movl(EBX, FieldAddress(EAX, GrowableObjectArray::length_offset()));
   // EBX: length.
   __ movl(EDI, FieldAddress(EAX, GrowableObjectArray::data_offset()));
   // EDI: data.
   // Compare length with capacity.
   __ cmpl(EBX, FieldAddress(EDI, Array::length_offset()));
   __ j(EQUAL, &fall_through);  // Must grow data.
@@ skipping 1889 matching lines @@
                         Isolate::current_tag_offset());
   // Set return value to Isolate::current_tag_.
   __ movl(EAX, current_tag_addr);
   __ ret();
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32