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

runtime/vm/dwarf.cc

 // Copyright (c) 2017, 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/dwarf.h"
 
 #include "vm/code_descriptors.h"
 #include "vm/object_store.h"
 
 namespace dart {
@@ skipping 30 matching lines @@
 
   const Function& function;
   TokenPosition call_pos;
   int32_t start_pc_offset;
   int32_t end_pc_offset;
   InliningNode* children_head;
   InliningNode* children_tail;
   InliningNode* children_next;
 };
 
-
 Dwarf::Dwarf(Zone* zone, WriteStream* stream)
     : zone_(zone),
       stream_(stream),
       codes_(zone, 1024),
       code_to_index_(zone),
       functions_(zone, 1024),
       function_to_index_(zone),
       scripts_(zone, 1024),
       script_to_index_(zone),
       temp_(0) {}
 
-
 intptr_t Dwarf::AddCode(const Code& code) {
   ASSERT(!code.IsNull());
   CodeIndexPair* pair = code_to_index_.Lookup(&code);
   if (pair != NULL) {
     return pair->index_;
   }
   intptr_t index = codes_.length();
   const Code& zone_code = Code::ZoneHandle(zone_, code.raw());
   code_to_index_.Insert(CodeIndexPair(&zone_code, index));
   codes_.Add(&zone_code);
   if (code.IsFunctionCode()) {
     const Function& function = Function::Handle(zone_, code.function());
     AddFunction(function);
   }
   const Array& inline_functions =
       Array::Handle(zone_, code.inlined_id_to_function());
   if (!inline_functions.IsNull()) {
     Function& function = Function::Handle(zone_);
     for (intptr_t i = 0; i < inline_functions.Length(); i++) {
       function ^= inline_functions.At(i);
       AddFunction(function);
     }
   }
   return index;
 }
 
-
 intptr_t Dwarf::AddFunction(const Function& function) {
   ASSERT(!function.IsNull());
   FunctionIndexPair* pair = function_to_index_.Lookup(&function);
   if (pair != NULL) {
     return pair->index_;
   }
   intptr_t index = functions_.length();
   const Function& zone_func = Function::ZoneHandle(zone_, function.raw());
   function_to_index_.Insert(FunctionIndexPair(&zone_func, index));
   functions_.Add(&zone_func);
   const Script& script = Script::Handle(zone_, function.script());
   AddScript(script);
   return index;
 }
 
-
 intptr_t Dwarf::AddScript(const Script& script) {
   ASSERT(!script.IsNull());
   ScriptIndexPair* pair = script_to_index_.Lookup(&script);
   if (pair != NULL) {
     return pair->index_;
   }
   // DWARF file numbers start from 1.
   intptr_t index = scripts_.length() + 1;
   const Script& zone_script = Script::ZoneHandle(zone_, script.raw());
   script_to_index_.Insert(ScriptIndexPair(&zone_script, index));
   scripts_.Add(&zone_script);
   return index;
 }
 
-
 intptr_t Dwarf::LookupFunction(const Function& function) {
   ASSERT(!function.IsNull());
   FunctionIndexPair* pair = function_to_index_.Lookup(&function);
   if (pair == NULL) {
     FATAL1("Function detected too late during DWARF generation: %s",
            function.ToCString());
   }
   return pair->index_;
 }
 
-
 intptr_t Dwarf::LookupScript(const Script& script) {
   ASSERT(!script.IsNull());
   ScriptIndexPair* pair = script_to_index_.Lookup(&script);
   if (pair == NULL) {
     FATAL1("Script detected too late during DWARF generation: %s",
            script.ToCString());
   }
   return pair->index_;
 }
 
-
 void Dwarf::Print(const char* format, ...) {
   va_list args;
   va_start(args, format);
   stream_->VPrint(format, args);
   va_end(args);
 }
 
-
 void Dwarf::WriteAbbreviations() {
 // Dwarf data mostly takes the form of a tree, whose nodes are called
 // DIEs. Each DIE begins with an abbreviation code, and the abbreviation
 // describes the attributes of that DIE and their representation.
 
 #if defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
   Print(".section __DWARF,__debug_abbrev,regular,debug\n");
 #elif defined(TARGET_OS_LINUX) || defined(TARGET_OS_ANDROID) ||                \
     defined(TARGET_OS_FUCHSIA)
   Print(".section .debug_abbrev,\"\"\n");
@@ skipping 57 matching lines @@
   uleb128(DW_AT_call_file);
   uleb128(DW_FORM_udata);
   uleb128(DW_AT_call_line);
   uleb128(DW_FORM_udata);
   uleb128(0);
   uleb128(0);  // End of attributes.
 
   uleb128(0);  // End of abbreviations.
 }
 
-
 void Dwarf::WriteCompilationUnit() {
 // 7.5.1.1 Compilation Unit Header
 
 #if defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
   Print(".section __DWARF,__debug_info,regular,debug\n");
 #elif defined(TARGET_OS_LINUX) || defined(TARGET_OS_ANDROID) ||                \
     defined(TARGET_OS_FUCHSIA)
   Print(".section .debug_info,\"\"\n");
 #else
   UNIMPLEMENTED();
@@ skipping 42 matching lines @@
 
   WriteAbstractFunctions();
   WriteConcreteFunctions();
 
   uleb128(0);  // End of children.
 
   uleb128(0);  // End of entries.
   Print(".Lcu_end:\n");
 }
 
-
 void Dwarf::WriteAbstractFunctions() {
   Script& script = Script::Handle(zone_);
   String& name = String::Handle(zone_);
   for (intptr_t i = 0; i < functions_.length(); i++) {
     const Function& function = *(functions_[i]);
     name = function.QualifiedUserVisibleName();
     script = function.script();
     intptr_t file = LookupScript(script);
     intptr_t line = 0;  // Not known. Script has already lost its token stream.
 
     Print(".Lfunc%" Pd ":\n", i);  // Label for DW_AT_abstract_origin references
     uleb128(kAbstractFunction);
     Print(".string \"%s\"\n", name.ToCString());  // DW_AT_name
     uleb128(file);                                // DW_AT_decl_file
     uleb128(line);                                // DW_AT_decl_line
     uleb128(DW_INL_inlined);                      // DW_AT_inline
     uleb128(0);                                   // End of children.
   }
 }
 
-
 void Dwarf::WriteConcreteFunctions() {
   Function& function = Function::Handle(zone_);
   Script& script = Script::Handle(zone_);
   for (intptr_t i = 0; i < codes_.length(); i++) {
     const Code& code = *(codes_[i]);
     if (!code.IsFunctionCode()) {
       continue;
     }
     function = code.function();
     intptr_t function_index = LookupFunction(function);
@@ skipping 18 matching lines @@
       for (InliningNode* child = node->children_head; child != NULL;
            child = child->children_next) {
         WriteInliningNode(child, i, script);
       }
     }
 
     uleb128(0);  // End of children.
   }
 }
 
-
 // Our state machine encodes position metadata such that we don't know the
 // end pc for an inlined function until it is popped, but DWARF DIEs encode
 // it where the function is pushed. We expand the state transitions into
 // an in-memory tree to do the conversion.
 InliningNode* Dwarf::ExpandInliningTree(const Code& code) {
   const CodeSourceMap& map =
       CodeSourceMap::Handle(zone_, code.code_source_map());
   if (map.IsNull()) {
     return NULL;
   }
@@ skipping 54 matching lines @@
 
   while (node_stack.length() > 1) {
     node_stack.Last()->end_pc_offset = current_pc_offset;
     node_stack.RemoveLast();
     token_positions.RemoveLast();
   }
   ASSERT(node_stack[0] == root_node);
   return root_node;
 }
 
-
 void Dwarf::WriteInliningNode(InliningNode* node,
                               intptr_t root_code_index,
                               const Script& parent_script) {
   intptr_t file = LookupScript(parent_script);
   intptr_t line = node->call_pos.value();
   intptr_t function_index = LookupFunction(node->function);
   const Script& script = Script::Handle(zone_, node->function.script());
 
   uleb128(kInlinedFunction);
   // DW_AT_abstract_origin
@@ skipping 14 matching lines @@
   uleb128(line);
 
   for (InliningNode* child = node->children_head; child != NULL;
        child = child->children_next) {
     WriteInliningNode(child, root_code_index, script);
   }
 
   uleb128(0);  // End of children.
 }
 
-
 void Dwarf::WriteLines() {
 #if defined(TARGET_OS_MACOS) || defined(TARGET_OS_MACOS_IOS)
   Print(".section __DWARF,__debug_line,regular,debug\n");
 #elif defined(TARGET_OS_LINUX) || defined(TARGET_OS_ANDROID) ||                \
     defined(TARGET_OS_FUCHSIA)
   Print(".section .debug_line,\"\"\n");
 #else
   UNIMPLEMENTED();
 #endif
 
@@ skipping 169 matching lines @@
   u1(0);  // This is an extended opcode
   u1(1);  // that is 1 byte long
   u1(DW_LNE_end_sequence);
 
   Print(".Lline_end:\n");
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart