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

runtime/vm/code_descriptors.cc

 // Copyright (c) 2012, 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/code_descriptors.h"
 
 #include "vm/log.h"
 
 namespace dart {
 
@@ skipping 16 matching lines @@
     PcDescriptors::EncodeInteger(&encoded_data_, deopt_id - prev_deopt_id);
     PcDescriptors::EncodeInteger(&encoded_data_,
                                  token_pos.value() - prev_token_pos);
 
     prev_pc_offset = pc_offset;
     prev_deopt_id = deopt_id;
     prev_token_pos = token_pos.value();
   }
 }
 
-
 RawPcDescriptors* DescriptorList::FinalizePcDescriptors(uword entry_point) {
   if (encoded_data_.length() == 0) {
     return Object::empty_descriptors().raw();
   }
   return PcDescriptors::New(&encoded_data_);
 }
 
-
 void StackMapTableBuilder::AddEntry(intptr_t pc_offset,
                                     BitmapBuilder* bitmap,
                                     intptr_t register_bit_count) {
   stack_map_ = StackMap::New(pc_offset, bitmap, register_bit_count);
   list_.Add(stack_map_, Heap::kOld);
 }
 
-
 bool StackMapTableBuilder::Verify() {
   intptr_t num_entries = Length();
   StackMap& map1 = StackMap::Handle();
   StackMap& map2 = StackMap::Handle();
   for (intptr_t i = 1; i < num_entries; i++) {
     map1 = MapAt(i - 1);
     map2 = MapAt(i);
     // Ensure there are no duplicates and the entries are sorted.
     if (map1.PcOffset() >= map2.PcOffset()) {
       return false;
     }
   }
   return true;
 }
 
-
 RawArray* StackMapTableBuilder::FinalizeStackMaps(const Code& code) {
   ASSERT(Verify());
   intptr_t num_entries = Length();
   if (num_entries == 0) {
     return Object::empty_array().raw();
   }
   return Array::MakeFixedLength(list_);
 }
 
-
 RawStackMap* StackMapTableBuilder::MapAt(intptr_t index) const {
   StackMap& map = StackMap::Handle();
   map ^= list_.At(index);
   return map.raw();
 }
 
-
 RawExceptionHandlers* ExceptionHandlerList::FinalizeExceptionHandlers(
     uword entry_point) const {
   intptr_t num_handlers = Length();
   if (num_handlers == 0) {
     return Object::empty_exception_handlers().raw();
   }
   const ExceptionHandlers& handlers =
       ExceptionHandlers::Handle(ExceptionHandlers::New(num_handlers));
   for (intptr_t i = 0; i < num_handlers; i++) {
     // Assert that every element in the array has been initialized.
@@ skipping 12 matching lines @@
       const bool has_catch_all = ContainsDynamic(*list_[i].handler_types);
       handlers.SetHandlerInfo(i, list_[i].outer_try_index, list_[i].pc_offset,
                               list_[i].needs_stacktrace, has_catch_all,
                               list_[i].token_pos, list_[i].is_generated);
       handlers.SetHandledTypes(i, *list_[i].handler_types);
     }
   }
   return handlers.raw();
 }
 
-
 static uint8_t* zone_allocator(uint8_t* ptr,
                                intptr_t old_size,
                                intptr_t new_size) {
   Zone* zone = Thread::Current()->zone();
   return zone->Realloc<uint8_t>(ptr, old_size, new_size);
 }
 
-
 class CatchEntryStateMapBuilder::TrieNode : public ZoneAllocated {
  public:
   TrieNode() : pair_(), entry_state_offset_(-1) {}
   TrieNode(CatchEntryStatePair pair, intptr_t index)
       : pair_(pair), entry_state_offset_(index) {}
 
   intptr_t Offset() { return entry_state_offset_; }
 
   TrieNode* Insert(TrieNode* node) {
     children_.Add(node);
@@ skipping 13 matching lines @@
   GrowableArray<TrieNode*> children_;
 };
 
 CatchEntryStateMapBuilder::CatchEntryStateMapBuilder()
     : zone_(Thread::Current()->zone()),
       root_(new TrieNode()),
       current_pc_offset_(0),
       buffer_(NULL),
       stream_(&buffer_, zone_allocator, 64) {}
 
-
 void CatchEntryStateMapBuilder::AppendMove(intptr_t src_slot,
                                            intptr_t dest_slot) {
   moves_.Add(CatchEntryStatePair::FromMove(src_slot, dest_slot));
 }
 
-
 void CatchEntryStateMapBuilder::AppendConstant(intptr_t pool_id,
                                                intptr_t dest_slot) {
   moves_.Add(CatchEntryStatePair::FromConstant(pool_id, dest_slot));
 }
 
-
 void CatchEntryStateMapBuilder::NewMapping(intptr_t pc_offset) {
   moves_.Clear();
   current_pc_offset_ = pc_offset;
 }
 
-
 void CatchEntryStateMapBuilder::EndMapping() {
   intptr_t suffix_length = 0;
   TrieNode* suffix = root_;
   // Find the largest common suffix, get the last node of the path.
   for (intptr_t i = moves_.length() - 1; i >= 0; i--) {
     TrieNode* n = suffix->Follow(moves_[i]);
     if (n == NULL) break;
     suffix_length++;
     suffix = n;
   }
@@ skipping 11 matching lines @@
   for (intptr_t i = length - 1; i >= 0; i--) {
     Writer::Write(&stream_, moves_[i].src);
     Writer::Write(&stream_, moves_[i].dest);
 
     TrieNode* child = new (zone_) TrieNode(moves_[i], current_offset);
     node->Insert(child);
     node = child;
   }
 }
 
-
 RawTypedData* CatchEntryStateMapBuilder::FinalizeCatchEntryStateMap() {
   TypedData& td = TypedData::Handle(TypedData::New(
       kTypedDataInt8ArrayCid, stream_.bytes_written(), Heap::kOld));
   NoSafepointScope no_safepoint;
   uint8_t* dest = reinterpret_cast<uint8_t*>(td.DataAddr(0));
   uint8_t* src = stream_.buffer();
   for (intptr_t i = 0; i < stream_.bytes_written(); i++) {
     dest[i] = src[i];
   }
   return td.raw();
 }
 
-
 const TokenPosition CodeSourceMapBuilder::kInitialPosition =
     TokenPosition(TokenPosition::kDartCodeProloguePos);
 
-
 CodeSourceMapBuilder::CodeSourceMapBuilder(
     bool stack_traces_only,
     const GrowableArray<intptr_t>& caller_inline_id,
     const GrowableArray<TokenPosition>& inline_id_to_token_pos,
     const GrowableArray<const Function*>& inline_id_to_function)
     : buffered_pc_offset_(0),
       buffered_inline_id_stack_(),
       buffered_token_pos_stack_(),
       written_pc_offset_(0),
       written_inline_id_stack_(),
       written_token_pos_stack_(),
       caller_inline_id_(caller_inline_id),
       inline_id_to_token_pos_(inline_id_to_token_pos),
       inline_id_to_function_(inline_id_to_function),
       inlined_functions_(
           GrowableObjectArray::Handle(GrowableObjectArray::New(Heap::kOld))),
       buffer_(NULL),
       stream_(&buffer_, zone_allocator, 64),
       stack_traces_only_(stack_traces_only) {
   buffered_inline_id_stack_.Add(0);
   buffered_token_pos_stack_.Add(kInitialPosition);
   written_inline_id_stack_.Add(0);
   written_token_pos_stack_.Add(kInitialPosition);
 }
 
-
 void CodeSourceMapBuilder::FlushBuffer() {
   FlushBufferStack();
   FlushBufferPosition();
   FlushBufferPC();
 }
 
-
 void CodeSourceMapBuilder::FlushBufferStack() {
   for (intptr_t i = buffered_inline_id_stack_.length() - 1; i >= 0; i--) {
     intptr_t buffered_id = buffered_inline_id_stack_[i];
     if (i < written_inline_id_stack_.length()) {
       intptr_t written_id = written_inline_id_stack_[i];
       if (buffered_id == written_id) {
         // i is the top-most position where the buffered and written stack
         // match.
         while (written_inline_id_stack_.length() > i + 1) {
           WritePop();
         }
         for (intptr_t j = i + 1; j < buffered_inline_id_stack_.length(); j++) {
           TokenPosition buffered_pos = buffered_token_pos_stack_[j - 1];
           TokenPosition written_pos = written_token_pos_stack_[j - 1];
           if (buffered_pos != written_pos) {
             WriteChangePosition(buffered_pos);
           }
           WritePush(buffered_inline_id_stack_[j]);
         }
         return;
       }
     }
   }
   UNREACHABLE();
 }
 
-
 void CodeSourceMapBuilder::FlushBufferPosition() {
   ASSERT(buffered_token_pos_stack_.length() ==
          written_token_pos_stack_.length());
 
   intptr_t top = buffered_token_pos_stack_.length() - 1;
   TokenPosition buffered_pos = buffered_token_pos_stack_[top];
   TokenPosition written_pos = written_token_pos_stack_[top];
   if (buffered_pos != written_pos) {
     WriteChangePosition(buffered_pos);
   }
 }
 
-
 void CodeSourceMapBuilder::FlushBufferPC() {
   if (buffered_pc_offset_ != written_pc_offset_) {
     WriteAdvancePC(buffered_pc_offset_ - written_pc_offset_);
   }
 }
 
-
 void CodeSourceMapBuilder::StartInliningInterval(int32_t pc_offset,
                                                  intptr_t inline_id) {
   if (buffered_inline_id_stack_.Last() == inline_id) {
     // No change in function stack.
     return;
   }
   if (inline_id == -1) {
     // Basic blocking missing an inline_id.
     return;
   }
@@ skipping 31 matching lines @@
       UNREACHABLE();
     }
 
     // Report caller as at the position of the call.
     BufferChangePosition(call_token);
 
     BufferPush(callee_id);
   }
 }
 
-
 void CodeSourceMapBuilder::BeginCodeSourceRange(int32_t pc_offset) {}
 
-
 void CodeSourceMapBuilder::EndCodeSourceRange(int32_t pc_offset,
                                               TokenPosition pos) {
   if (pc_offset == buffered_pc_offset_) {
     return;  // Empty intermediate instruction.
   }
   if (pos != buffered_token_pos_stack_.Last()) {
     if (!stack_traces_only_) {
       FlushBuffer();
     }
     BufferChangePosition(pos);
   }
   BufferAdvancePC(pc_offset - buffered_pc_offset_);
 }
 
-
 void CodeSourceMapBuilder::NoteDescriptor(RawPcDescriptors::Kind kind,
                                           int32_t pc_offset,
                                           TokenPosition pos) {
   const uint8_t kCanThrow =
       RawPcDescriptors::kIcCall | RawPcDescriptors::kUnoptStaticCall |
       RawPcDescriptors::kRuntimeCall | RawPcDescriptors::kOther;
   if (stack_traces_only_ && ((kind & kCanThrow) != 0)) {
     BufferChangePosition(pos);
     BufferAdvancePC(pc_offset - buffered_pc_offset_);
     FlushBuffer();
   }
 }
 
-
 intptr_t CodeSourceMapBuilder::GetFunctionId(intptr_t inline_id) {
   const Function& function = *inline_id_to_function_[inline_id];
   for (intptr_t i = 0; i < inlined_functions_.Length(); i++) {
     if (inlined_functions_.At(i) == function.raw()) {
       return i;
     }
   }
   inlined_functions_.Add(function, Heap::kOld);
   return inlined_functions_.Length() - 1;
 }
 
-
 RawArray* CodeSourceMapBuilder::InliningIdToFunction() {
   if (inlined_functions_.Length() == 0) {
     return Object::empty_array().raw();
   }
   return Array::MakeFixedLength(inlined_functions_);
 }
 
-
 RawCodeSourceMap* CodeSourceMapBuilder::Finalize() {
   if (!stack_traces_only_) {
     FlushBuffer();
   }
   intptr_t length = stream_.bytes_written();
   const CodeSourceMap& map = CodeSourceMap::Handle(CodeSourceMap::New(length));
   NoSafepointScope no_safepoint;
   memmove(map.Data(), buffer_, length);
   return map.raw();
 }
 
-
 void CodeSourceMapBuilder::WriteChangePosition(TokenPosition pos) {
   stream_.Write<uint8_t>(kChangePosition);
   if (FLAG_precompiled_mode) {
     intptr_t line = -1;
     intptr_t inline_id = buffered_inline_id_stack_.Last();
     if (inline_id < inline_id_to_function_.length()) {
       const Function* function = inline_id_to_function_[inline_id];
       Script& script = Script::Handle(function->script());
       line = script.GetTokenLineUsingLineStarts(pos.SourcePosition());
     }
     stream_.Write<int32_t>(static_cast<int32_t>(line));
   } else {
     stream_.Write<int32_t>(static_cast<int32_t>(pos.value()));
   }
   written_token_pos_stack_.Last() = pos;
 }
 
-
 void CodeSourceMapReader::GetInlinedFunctionsAt(
     int32_t pc_offset,
     GrowableArray<const Function*>* function_stack,
     GrowableArray<TokenPosition>* token_positions) {
   function_stack->Clear();
   token_positions->Clear();
 
   NoSafepointScope no_safepoint;
   ReadStream stream(map_.Data(), map_.Length());
 
@@ skipping 32 matching lines @@
         function_stack->RemoveLast();
         token_positions->RemoveLast();
         break;
       }
       default:
         UNREACHABLE();
     }
   }
 }
 
-
 #ifndef PRODUCT
 void CodeSourceMapReader::PrintJSONInlineIntervals(JSONObject* jsobj) {
   {
     JSONArray inlined_functions(jsobj, "_inlinedFunctions");
     Function& function = Function::Handle();
     for (intptr_t i = 0; i < functions_.Length(); i++) {
       function ^= functions_.At(i);
       ASSERT(!function.IsNull());
       inlined_functions.AddValue(function);
     }
@@ skipping 38 matching lines @@
         function_stack.RemoveLast();
         break;
       }
       default:
         UNREACHABLE();
     }
   }
 }
 #endif  // !PRODUCT
 
-
 void CodeSourceMapReader::DumpInlineIntervals(uword start) {
   GrowableArray<const Function*> function_stack;
   LogBlock lb;
   NoSafepointScope no_safepoint;
   ReadStream stream(map_.Data(), map_.Length());
 
   int32_t current_pc_offset = 0;
   function_stack.Add(&root_);
 
   THR_Print("Inline intervals {\n");
@@ skipping 27 matching lines @@
         function_stack.RemoveLast();
         break;
       }
       default:
         UNREACHABLE();
     }
   }
   THR_Print("}\n");
 }
 
-
 void CodeSourceMapReader::DumpSourcePositions(uword start) {
   GrowableArray<const Function*> function_stack;
   GrowableArray<TokenPosition> token_positions;
   LogBlock lb;
   NoSafepointScope no_safepoint;
   ReadStream stream(map_.Data(), map_.Length());
 
   int32_t current_pc_offset = 0;
   function_stack.Add(&root_);
   token_positions.Add(CodeSourceMapBuilder::kInitialPosition);
@@ skipping 35 matching lines @@
         break;
       }
       default:
         UNREACHABLE();
     }
   }
   THR_Print("}\n");
 }
 
 }  // namespace dart