VM: Re-format to use at most one newline between functions

runtime/vm/native_entry.cc

 // Copyright (c) 2011, 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/native_entry.h"
 
 #include "include/dart_api.h"
 
 #include "vm/bootstrap.h"
 #include "vm/code_patcher.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
 #include "vm/native_symbol.h"
 #include "vm/object_store.h"
 #include "vm/reusable_handles.h"
 #include "vm/safepoint.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 #include "vm/tags.h"
 
-
 namespace dart {
 
 DEFINE_FLAG(bool,
             trace_natives,
             false,
             "Trace invocation of natives (debug mode only)");
 
-
 void DartNativeThrowArgumentException(const Instance& instance) {
   const Array& __args__ = Array::Handle(Array::New(1));
   __args__.SetAt(0, instance);
   Exceptions::ThrowByType(Exceptions::kArgument, __args__);
 }
 
-
 NativeFunction NativeEntry::ResolveNative(const Library& library,
                                           const String& function_name,
                                           int number_of_arguments,
                                           bool* auto_setup_scope) {
   // Now resolve the native function to the corresponding native entrypoint.
   if (library.native_entry_resolver() == 0) {
     // Native methods are not allowed in the library to which this
     // class belongs in.
     return NULL;
   }
   Dart_NativeFunction native_function = NULL;
   {
     Thread* T = Thread::Current();
     TransitionVMToNative transition(T);
     Dart_EnterScope();  // Enter a new Dart API scope as we invoke API entries.
     Dart_NativeEntryResolver resolver = library.native_entry_resolver();
     native_function = resolver(Api::NewHandle(T, function_name.raw()),
                                number_of_arguments, auto_setup_scope);
     Dart_ExitScope();  // Exit the Dart API scope.
   }
   return reinterpret_cast<NativeFunction>(native_function);
 }
 
-
 const uint8_t* NativeEntry::ResolveSymbolInLibrary(const Library& library,
                                                    uword pc) {
   Dart_NativeEntrySymbol symbol_resolver =
       library.native_entry_symbol_resolver();
   if (symbol_resolver == 0) {
     // Cannot reverse lookup native entries.
     return NULL;
   }
   return symbol_resolver(reinterpret_cast<Dart_NativeFunction>(pc));
 }
 
-
 const uint8_t* NativeEntry::ResolveSymbol(uword pc) {
   Thread* thread = Thread::Current();
   REUSABLE_GROWABLE_OBJECT_ARRAY_HANDLESCOPE(thread);
   GrowableObjectArray& libs = reused_growable_object_array_handle.Handle();
   libs ^= thread->isolate()->object_store()->libraries();
   ASSERT(!libs.IsNull());
   intptr_t num_libs = libs.Length();
   for (intptr_t i = 0; i < num_libs; i++) {
     REUSABLE_LIBRARY_HANDLESCOPE(thread);
     Library& lib = reused_library_handle.Handle();
     lib ^= libs.At(i);
     ASSERT(!lib.IsNull());
     const uint8_t* r = ResolveSymbolInLibrary(lib, pc);
     if (r != NULL) {
       return r;
     }
   }
   return NULL;
 }
 
-
 bool NativeEntry::ReturnValueIsError(NativeArguments* arguments) {
   RawObject* retval = arguments->ReturnValue();
   return (retval->IsHeapObject() &&
           RawObject::IsErrorClassId(retval->GetClassId()));
 }
 
-
 void NativeEntry::PropagateErrors(NativeArguments* arguments) {
   Thread* thread = arguments->thread();
   thread->UnwindScopes(thread->top_exit_frame_info());
 
   // The thread->zone() is different here than before we unwound.
   const Object& error =
       Object::Handle(thread->zone(), arguments->ReturnValue());
   Exceptions::PropagateError(Error::Cast(error));
   UNREACHABLE();
 }
 
-
 uword NativeEntry::NoScopeNativeCallWrapperEntry() {
   uword entry = reinterpret_cast<uword>(NativeEntry::NoScopeNativeCallWrapper);
 #if defined(USING_SIMULATOR) && !defined(TARGET_ARCH_DBC)
   // DBC does not use redirections unlike other simulators.
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
 #endif
   return entry;
 }
 
-
 void NativeEntry::NoScopeNativeCallWrapper(Dart_NativeArguments args,
                                            Dart_NativeFunction func) {
   CHECK_STACK_ALIGNMENT;
   NoScopeNativeCallWrapperNoStackCheck(args, func);
 }
 
-
 void NativeEntry::NoScopeNativeCallWrapperNoStackCheck(
     Dart_NativeArguments args,
     Dart_NativeFunction func) {
   VERIFY_ON_TRANSITION;
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   /* Tell MemorySanitizer 'arguments' is initialized by generated code. */
   MSAN_UNPOISON(arguments, sizeof(*arguments));
   Thread* thread = arguments->thread();
   ASSERT(thread->execution_state() == Thread::kThreadInGenerated);
   {
     TransitionGeneratedToNative transition(thread);
     func(args);
     if (ReturnValueIsError(arguments)) {
       PropagateErrors(arguments);
     }
   }
   ASSERT(thread->execution_state() == Thread::kThreadInGenerated);
   VERIFY_ON_TRANSITION;
 }
 
-
 uword NativeEntry::AutoScopeNativeCallWrapperEntry() {
   uword entry =
       reinterpret_cast<uword>(NativeEntry::AutoScopeNativeCallWrapper);
 #if defined(USING_SIMULATOR) && !defined(TARGET_ARCH_DBC)
   // DBC does not use redirections unlike other simulators.
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kNativeCall, NativeEntry::kNumCallWrapperArguments);
 #endif
   return entry;
 }
 
-
 void NativeEntry::AutoScopeNativeCallWrapper(Dart_NativeArguments args,
                                              Dart_NativeFunction func) {
   CHECK_STACK_ALIGNMENT;
   AutoScopeNativeCallWrapperNoStackCheck(args, func);
 }
 
-
 void NativeEntry::AutoScopeNativeCallWrapperNoStackCheck(
     Dart_NativeArguments args,
     Dart_NativeFunction func) {
   VERIFY_ON_TRANSITION;
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   /* Tell MemorySanitizer 'arguments' is initialized by generated code. */
   MSAN_UNPOISON(arguments, sizeof(*arguments));
   Thread* thread = arguments->thread();
   ASSERT(thread->execution_state() == Thread::kThreadInGenerated);
   {
@@ skipping 27 matching lines @@
     } else {
       ASSERT(thread->api_reusable_scope() != scope);
       delete scope;
     }
     DEOPTIMIZE_ALOT;
   }
   ASSERT(thread->execution_state() == Thread::kThreadInGenerated);
   VERIFY_ON_TRANSITION;
 }
 
-
 // DBC does not support lazy native call linking.
 #if !defined(TARGET_ARCH_DBC)
 static NativeFunction ResolveNativeFunction(Zone* zone,
                                             const Function& func,
                                             bool* is_bootstrap_native,
                                             bool* is_auto_scope) {
   const Class& cls = Class::Handle(zone, func.Owner());
   const Library& library = Library::Handle(zone, cls.library());
 
   *is_bootstrap_native =
       Bootstrap::IsBootstapResolver(library.native_entry_resolver());
 
   const String& native_name = String::Handle(zone, func.native_name());
   ASSERT(!native_name.IsNull());
 
   const int num_params = NativeArguments::ParameterCountForResolution(func);
   return NativeEntry::ResolveNative(library, native_name, num_params,
                                     is_auto_scope);
 }
 
-
 uword NativeEntry::LinkNativeCallEntry() {
   uword entry = reinterpret_cast<uword>(NativeEntry::LinkNativeCall);
 #if defined(USING_SIMULATOR)
   entry = Simulator::RedirectExternalReference(
       entry, Simulator::kBootstrapNativeCall, NativeEntry::kNumArguments);
 #endif
   return entry;
 }
 
-
 void NativeEntry::LinkNativeCall(Dart_NativeArguments args) {
   CHECK_STACK_ALIGNMENT;
   VERIFY_ON_TRANSITION;
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   /* Tell MemorySanitizer 'arguments' is initialized by generated code. */
   MSAN_UNPOISON(arguments, sizeof(*arguments));
   TRACE_NATIVE_CALL("%s", "LinkNative");
 
   NativeFunction target_function = NULL;
   bool is_bootstrap_native = false;
@@ skipping 77 matching lines @@
         args, reinterpret_cast<Dart_NativeFunction>(target_function));
   } else {
     // Because this call is within a compilation unit, Clang doesn't respect
     // the ABI alignment here.
     NativeEntry::NoScopeNativeCallWrapperNoStackCheck(
         args, reinterpret_cast<Dart_NativeFunction>(target_function));
   }
 }
 #endif  // !defined(TARGET_ARCH_DBC)
 
-
 }  // namespace dart