Revert "DWARF and unwind support for AOT assembly output."

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 962 matching lines @@
       Array::Handle(Z, code.inlined_id_to_function());
   for (intptr_t i = 0; i < inlined_functions.Length(); i++) {
     target ^= inlined_functions.At(i);
     AddTypesOf(target);
   }
 }
 
 
 void Precompiler::AddTypesOf(const Class& cls) {
   if (cls.IsNull()) return;
-  if (classes_to_retain_.HasKey(&cls)) return;
+  if (classes_to_retain_.Lookup(&cls) != NULL) return;
   classes_to_retain_.Insert(&Class::ZoneHandle(Z, cls.raw()));
 
   Array& interfaces = Array::Handle(Z, cls.interfaces());
   AbstractType& type = AbstractType::Handle(Z);
   for (intptr_t i = 0; i < interfaces.Length(); i++) {
     type ^= interfaces.At(i);
     AddType(type);
   }
 
   AddTypeArguments(TypeArguments::Handle(Z, cls.type_parameters()));
 
   type = cls.super_type();
   AddType(type);
 
   type = cls.mixin();
   AddType(type);
 
   if (cls.IsTypedefClass()) {
     AddTypesOf(Function::Handle(Z, cls.signature_function()));
   }
 }
 
 
 void Precompiler::AddTypesOf(const Function& function) {
   if (function.IsNull()) return;
   // We don't expect to see a reference to a redicting factory.
   ASSERT(!function.IsRedirectingFactory());
-  if (functions_to_retain_.HasKey(&function)) return;
+  if (functions_to_retain_.Lookup(&function) != NULL) return;
   functions_to_retain_.Insert(&Function::ZoneHandle(Z, function.raw()));
 
   AbstractType& type = AbstractType::Handle(Z);
   type = function.result_type();
   AddType(type);
   for (intptr_t i = 0; i < function.NumParameters(); i++) {
     type = function.ParameterTypeAt(i);
     AddType(type);
   }
   Code& code = Code::Handle(Z, function.CurrentCode());
@@ skipping 21 matching lines @@
   }
   // A class may have all functions inlined except a local function.
   const Class& owner = Class::Handle(Z, function.Owner());
   AddTypesOf(owner);
 }
 
 
 void Precompiler::AddType(const AbstractType& abstype) {
   if (abstype.IsNull()) return;
 
-  if (types_to_retain_.HasKey(&abstype)) return;
+  if (types_to_retain_.Lookup(&abstype) != NULL) return;
   types_to_retain_.Insert(&AbstractType::ZoneHandle(Z, abstype.raw()));
 
   if (abstype.IsType()) {
     const Type& type = Type::Cast(abstype);
     const Class& cls = Class::Handle(Z, type.type_class());
     AddTypesOf(cls);
     const TypeArguments& vector = TypeArguments::Handle(Z, abstype.arguments());
     AddTypeArguments(vector);
     if (type.IsFunctionType()) {
       const Function& func = Function::Handle(Z, type.signature());
@@ skipping 16 matching lines @@
     const Class& cls =
         Class::Handle(Z, TypeParameter::Cast(abstype).parameterized_class());
     AddTypesOf(cls);
   }
 }
 
 
 void Precompiler::AddTypeArguments(const TypeArguments& args) {
   if (args.IsNull()) return;
 
-  if (typeargs_to_retain_.HasKey(&args)) return;
+  if (typeargs_to_retain_.Lookup(&args) != NULL) return;
   typeargs_to_retain_.Insert(&TypeArguments::ZoneHandle(Z, args.raw()));
 
   AbstractType& arg = AbstractType::Handle(Z);
   for (intptr_t i = 0; i < args.Length(); i++) {
     arg = args.TypeAt(i);
     AddType(arg);
   }
 }
 
 
@@ skipping 13 matching lines @@
   }
 
   // Can't ask immediate objects if they're canoncial.
   if (instance.IsSmi()) return;
 
   // Some Instances in the ObjectPool aren't const objects, such as
   // argument descriptors.
   if (!instance.IsCanonical()) return;
 
   // Constants are canonicalized and we avoid repeated processing of them.
-  if (consts_to_retain_.HasKey(&instance)) return;
+  if (consts_to_retain_.Lookup(&instance) != NULL) return;
 
   consts_to_retain_.Insert(&Instance::ZoneHandle(Z, instance.raw()));
 
   if (cls.NumTypeArguments() > 0) {
     AddTypeArguments(TypeArguments::Handle(Z, instance.GetTypeArguments()));
   }
 
   class ConstObjectVisitor : public ObjectPointerVisitor {
    public:
     ConstObjectVisitor(Precompiler* precompiler, Isolate* isolate)
@@ skipping 26 matching lines @@
       Class::Handle(Z, I->object_store()->closure_class());
   const Function& dispatcher = Function::Handle(
       Z, cache_class.GetInvocationDispatcher(
              Symbols::Call(), arguments_descriptor,
              RawFunction::kInvokeFieldDispatcher, true /* create_if_absent */));
   AddFunction(dispatcher);
 }
 
 
 void Precompiler::AddField(const Field& field) {
-  if (fields_to_retain_.HasKey(&field)) return;
+  if (fields_to_retain_.Lookup(&field) != NULL) return;
 
   fields_to_retain_.Insert(&Field::ZoneHandle(Z, field.raw()));
 
   if (field.is_static()) {
     const Object& value = Object::Handle(Z, field.StaticValue());
     if (value.IsInstance()) {
       AddConstObject(Instance::Cast(value));
     }
 
     if (field.has_initializer()) {
@@ skipping 152 matching lines @@
     const Object& result = PassiveObject::Handle(thread->sticky_error());
     thread->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 void Precompiler::AddFunction(const Function& function) {
-  if (enqueued_functions_.HasKey(&function)) return;
+  if (enqueued_functions_.Lookup(&function) != NULL) return;
 
   enqueued_functions_.Insert(&Function::ZoneHandle(Z, function.raw()));
   pending_functions_.Add(function);
   changed_ = true;
 }
 
 
 bool Precompiler::IsSent(const String& selector) {
   if (selector.IsNull()) {
     return false;
   }
-  return sent_selectors_.HasKey(&selector);
+  return sent_selectors_.Lookup(&selector) != NULL;
 }
 
 
 void Precompiler::AddSelector(const String& selector) {
   ASSERT(!selector.IsNull());
 
   if (!IsSent(selector)) {
     sent_selectors_.Insert(&String::ZoneHandle(Z, selector.raw()));
     selector_count_++;
     changed_ = true;
@@ skipping 287 matching lines @@
     ClassDictionaryIterator it(lib, ClassDictionaryIterator::kIteratePrivate);
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
 
       functions = cls.functions();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         function ^= functions.At(j);
-        bool retain = enqueued_functions_.HasKey(&function);
+        bool retain = enqueued_functions_.Lookup(&function) != NULL;
         if (!retain && function.HasImplicitClosureFunction()) {
           // It can happen that all uses of an implicit closure inline their
           // target function, leaving the target function uncompiled. Keep
           // the target function anyway so we can enumerate it to bind its
           // static calls, etc.
           function2 = function.ImplicitClosureFunction();
           retain = function2.HasCode();
         }
         if (retain) {
           function.DropUncompiledImplicitClosureFunction();
           AddTypesOf(function);
         }
       }
     }
   }
 
   closures = isolate()->object_store()->closure_functions();
   for (intptr_t j = 0; j < closures.Length(); j++) {
     function ^= closures.At(j);
-    bool retain = enqueued_functions_.HasKey(&function);
+    bool retain = enqueued_functions_.Lookup(&function) != NULL;
     if (retain) {
       AddTypesOf(function);
 
       cls = function.Owner();
       AddTypesOf(cls);
 
       // It can happen that all uses of a function are inlined, leaving
       // a compiled local function with an uncompiled parent. Retain such
       // parents and their enclosing classes and libraries.
       function = function.parent_function();
@@ skipping 21 matching lines @@
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
 
       functions = cls.functions();
       retained_functions = GrowableObjectArray::New();
       for (intptr_t j = 0; j < functions.Length(); j++) {
         function ^= functions.At(j);
-        bool retain = functions_to_retain_.HasKey(&function);
+        bool retain = functions_to_retain_.Lookup(&function) != NULL;
         function.DropUncompiledImplicitClosureFunction();
         if (retain) {
           retained_functions.Add(function);
         } else {
           bool top_level = cls.IsTopLevel();
           if (top_level &&
               (function.kind() != RawFunction::kImplicitStaticFinalGetter)) {
             // Implicit static final getters are not added to the library
             // dictionary in the first place.
             name = function.DictionaryName();
@@ skipping 14 matching lines @@
       } else {
         cls.SetFunctions(Object::empty_array());
       }
     }
   }
 
   closures = isolate()->object_store()->closure_functions();
   retained_functions = GrowableObjectArray::New();
   for (intptr_t j = 0; j < closures.Length(); j++) {
     function ^= closures.At(j);
-    bool retain = functions_to_retain_.HasKey(&function);
+    bool retain = functions_to_retain_.Lookup(&function) != NULL;
     if (retain) {
       retained_functions.Add(function);
     } else {
       dropped_function_count_++;
       if (FLAG_trace_precompiler) {
         THR_Print("Dropping function %s\n",
                   function.ToLibNamePrefixedQualifiedCString());
       }
     }
   }
@@ skipping 16 matching lines @@
     while (it.HasNext()) {
       cls = it.GetNextClass();
       if (cls.IsDynamicClass()) {
         continue;  // class 'dynamic' is in the read-only VM isolate.
       }
 
       fields = cls.fields();
       retained_fields = GrowableObjectArray::New();
       for (intptr_t j = 0; j < fields.Length(); j++) {
         field ^= fields.At(j);
-        bool retain = fields_to_retain_.HasKey(&field);
+        bool retain = fields_to_retain_.Lookup(&field) != NULL;
         if (retain) {
           retained_fields.Add(field);
           type = field.type();
           AddType(type);
         } else {
           bool top_level = cls.IsTopLevel();
           if (top_level) {
             name = field.DictionaryName();
             lib.RemoveObject(field, name);
           }
@@ skipping 20 matching lines @@
   GrowableObjectArray& retained_types =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   Array& types_array = Array::Handle(Z);
   Type& type = Type::Handle(Z);
   // First drop all the types that are not referenced.
   {
     CanonicalTypeSet types_table(Z, object_store->canonical_types());
     types_array = HashTables::ToArray(types_table, false);
     for (intptr_t i = 0; i < (types_array.Length() - 1); i++) {
       type ^= types_array.At(i);
-      bool retain = types_to_retain_.HasKey(&type);
+      bool retain = types_to_retain_.Lookup(&type) != NULL;
       if (retain) {
         retained_types.Add(type);
       } else {
         dropped_type_count_++;
       }
     }
     types_table.Release();
   }
 
   // Now construct a new type table and save in the object store.
@@ skipping 17 matching lines @@
   GrowableObjectArray& retained_typeargs =
       GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
   TypeArguments& typeargs = TypeArguments::Handle(Z);
   // First drop all the type arguments that are not referenced.
   {
     CanonicalTypeArgumentsSet typeargs_table(
         Z, object_store->canonical_type_arguments());
     typeargs_array = HashTables::ToArray(typeargs_table, false);
     for (intptr_t i = 0; i < (typeargs_array.Length() - 1); i++) {
       typeargs ^= typeargs_array.At(i);
-      bool retain = typeargs_to_retain_.HasKey(&typeargs);
+      bool retain = typeargs_to_retain_.Lookup(&typeargs) != NULL;
       if (retain) {
         retained_typeargs.Add(typeargs);
       } else {
         dropped_typearg_count_++;
       }
     }
     typeargs_table.Release();
   }
 
   // Now construct a new type arguments table and save in the object store.
@@ skipping 65 matching lines @@
       if (cls.is_enum_class()) {
         // Enum classes have live instances, so we cannot unregister
         // them.
         retain = true;
       }
 
       constants = cls.constants();
       retained_constants = GrowableObjectArray::New();
       for (intptr_t j = 0; j < constants.Length(); j++) {
         constant ^= constants.At(j);
-        bool retain = consts_to_retain_.HasKey(&constant);
+        bool retain = consts_to_retain_.Lookup(&constant) != NULL;
         if (retain) {
           retained_constants.Add(constant);
         }
       }
       intptr_t cid = cls.id();
       if ((cid == kMintCid) || (cid == kBigintCid) || (cid == kDoubleCid)) {
         // Constants stored as a plain list, no rehashing needed.
         constants = Array::MakeArray(retained_constants);
         cls.set_constants(constants);
       } else {
@@ skipping 44 matching lines @@
     cls = class_table->At(cid);
     ASSERT(!cls.IsNull());
 
     if (cls.IsTopLevel()) {
       // Top-level classes are referenced directly from their library. They
       // will only be removed as a consequence of an entire library being
       // removed.
       continue;
     }
 
-    bool retain = classes_to_retain_.HasKey(&cls);
+    bool retain = classes_to_retain_.Lookup(&cls) != NULL;
     if (retain) {
       continue;
     }
 
     ASSERT(!cls.is_allocated());
     constants = cls.constants();
     ASSERT(constants.Length() == 0);
 
 #if defined(DEBUG)
     intptr_t instances =
@@ skipping 46 matching lines @@
       retain = true;
     } else if (lib.raw() == root_lib.raw()) {
       // The root library might have no surviving members if it only exports
       // main from another library. It will still be referenced from the object
       // store, so retain it.
       retain = true;
     } else {
       // A type for a top-level class may be referenced from an object pool as
       // part of an error message.
       const Class& top = Class::Handle(Z, lib.toplevel_class());
-      if (classes_to_retain_.HasKey(&top)) {
+      if (classes_to_retain_.Lookup(&top) != NULL) {
         retain = true;
       }
     }
 
     if (retain) {
       lib.set_index(retained_libraries.Length());
       retained_libraries.Add(lib);
     } else {
       dropped_library_count_++;
       lib.set_index(-1);
@@ skipping 1451 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart