clang-format runtime/vm

runtime/vm/il_printer.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/il_printer.h"
 
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/intermediate_language.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 
 namespace dart {
 
 #ifndef PRODUCT
 
-DEFINE_FLAG(bool, display_sorted_ic_data, false,
-    "Calls display a unary, sorted-by count form of ICData");
+DEFINE_FLAG(bool,
+            display_sorted_ic_data,
+            false,
+            "Calls display a unary, sorted-by count form of ICData");
 DEFINE_FLAG(bool, print_environments, false, "Print SSA environments.");
-DEFINE_FLAG(charp, print_flow_graph_filter, NULL,
-    "Print only IR of functions with matching names");
+DEFINE_FLAG(charp,
+            print_flow_graph_filter,
+            NULL,
+            "Print only IR of functions with matching names");
 
 DECLARE_FLAG(bool, trace_inlining_intervals);
 
 void BufferFormatter::Print(const char* format, ...) {
   va_list args;
   va_start(args, format);
   VPrint(format, args);
   va_end(args);
 }
 
 
 void BufferFormatter::VPrint(const char* format, va_list args) {
   intptr_t available = size_ - position_;
   if (available <= 0) return;
-  intptr_t written =
-      OS::VSNPrint(buffer_ + position_, available, format, args);
+  intptr_t written = OS::VSNPrint(buffer_ + position_, available, format, args);
   if (written >= 0) {
     position_ += (available <= written) ? available : written;
   }
 }
 
 
 // Checks whether function's name matches the given filter, which is
 // a comma-separated list of strings.
 bool FlowGraphPrinter::PassesFilter(const char* filter,
                                     const Function& function) {
@@ skipping 11 matching lines @@
   char* token = strtok_r(filter_buffer, ",", &save_ptr);
   bool found = false;
   while (token != NULL) {
     if (strstr(function_name, token) != NULL) {
       found = true;
       break;
     }
     const intptr_t token_len = strlen(token);
     if (token[token_len - 1] == '%') {
       if (function_name_len > token_len) {
-        const char* suffix = function_name +
-            (function_name_len - token_len + 1);
+        const char* suffix =
+            function_name + (function_name_len - token_len + 1);
         if (strncmp(suffix, token, token_len - 1) == 0) {
           found = true;
           break;
         }
       }
     }
     token = strtok_r(NULL, ",", &save_ptr);
   }
   delete[] filter_buffer;
 
@@ skipping 67 matching lines @@
   }
 }
 
 
 void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
                                       TokenPosition token_pos,
                                       Value* value,
                                       const AbstractType& dst_type,
                                       const String& dst_name,
                                       bool eliminated) {
-    const char* compile_type_name = "unknown";
-    if (value != NULL && value->reaching_type_ != NULL) {
-      compile_type_name = value->reaching_type_->ToCString();
-    }
-    THR_Print("%s type check: compile type %s is %s specific than "
-              "type '%s' of '%s'.\n",
-                         eliminated ? "Eliminated" : "Generated",
-                         compile_type_name,
-                         eliminated ? "more" : "not more",
-                         String::Handle(dst_type.Name()).ToCString(),
-                         dst_name.ToCString());
+  const char* compile_type_name = "unknown";
+  if (value != NULL && value->reaching_type_ != NULL) {
+    compile_type_name = value->reaching_type_->ToCString();
+  }
+  THR_Print(
+      "%s type check: compile type %s is %s specific than "
+      "type '%s' of '%s'.\n",
+      eliminated ? "Eliminated" : "Generated", compile_type_name,
+      eliminated ? "more" : "not more",
+      String::Handle(dst_type.Name()).ToCString(), dst_name.ToCString());
 }
 
 
 void CompileType::PrintTo(BufferFormatter* f) const {
   const char* type_name = "?";
   if ((cid_ != kIllegalCid) && (cid_ != kDynamicCid)) {
     const Class& cls =
         Class::Handle(Isolate::Current()->class_table()->At(cid_));
     type_name = String::Handle(cls.ScrubbedName()).ToCString();
   } else if (type_ != NULL &&
@@ skipping 46 matching lines @@
     f->Print("...");
   }
   f->Print("]");
 }
 
 
 static void PrintICDataSortedHelper(BufferFormatter* f,
                                     const ICData& ic_data_orig) {
   const ICData& ic_data =
       ICData::Handle(ic_data_orig.AsUnaryClassChecksSortedByCount());
-  f->Print(" IC[n:%" Pd"; ", ic_data.NumberOfChecks());
+  f->Print(" IC[n:%" Pd "; ", ic_data.NumberOfChecks());
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     const intptr_t count = ic_data.GetCountAt(i);
     const intptr_t cid = ic_data.GetReceiverClassIdAt(i);
     const Class& cls =
         Class::Handle(Isolate::Current()->class_table()->At(cid));
-    f->Print("%s : %" Pd ", ",
-        String::Handle(cls.Name()).ToCString(), count);
+    f->Print("%s : %" Pd ", ", String::Handle(cls.Name()).ToCString(), count);
   }
   f->Print("]");
 }
 
 
 void FlowGraphPrinter::PrintICData(const ICData& ic_data,
                                    intptr_t num_checks_to_print) {
   char buffer[1024];
   BufferFormatter f(buffer, sizeof(buffer));
   PrintICDataHelper(&f, ic_data, num_checks_to_print);
   THR_Print("%s ", buffer);
   const Array& a = Array::Handle(ic_data.arguments_descriptor());
   THR_Print(" arg-desc %" Pd "\n", a.Length());
 }
 
 
 static void PrintUse(BufferFormatter* f, const Definition& definition) {
   if (definition.HasSSATemp()) {
     if (definition.HasPairRepresentation()) {
       f->Print("(v%" Pd ", v%" Pd ")", definition.ssa_temp_index(),
-                                       definition.ssa_temp_index() + 1);
+               definition.ssa_temp_index() + 1);
     } else {
       f->Print("v%" Pd "", definition.ssa_temp_index());
     }
   } else if (definition.HasTemp()) {
     f->Print("t%" Pd "", definition.temp_index());
   }
 }
 
 
 const char* Instruction::ToCString() const {
@@ skipping 52 matching lines @@
     if (InputAt(i) != NULL) {
       InputAt(i)->PrintTo(f);
     }
   }
 }
 
 
 void Value::PrintTo(BufferFormatter* f) const {
   PrintUse(f, *definition());
 
-  if ((reaching_type_ != NULL) &&
-      (reaching_type_ != definition()->type_)) {
+  if ((reaching_type_ != NULL) && (reaching_type_ != definition()->type_)) {
     f->Print(" ");
     reaching_type_->PrintTo(f);
   }
 }
 
 
 void ConstantInstr::PrintOperandsTo(BufferFormatter* f) const {
   const char* cstr = value().ToCString();
   const char* new_line = strchr(cstr, '\n');
   if (new_line == NULL) {
@@ skipping 69 matching lines @@
   f->Print("%" Pd "", num_temps());
   if (value() != NULL) {
     f->Print(", ");
     value()->PrintTo(f);
   }
 }
 
 
 void AssertAssignableInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
-  f->Print(", %s, '%s'",
-           dst_type().ToCString(),
-           dst_name().ToCString());
+  f->Print(", %s, '%s'", dst_type().ToCString(), dst_name().ToCString());
   f->Print(" instantiator_type_arguments(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print(")");
 }
 
 
 void AssertBooleanInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
 }
 
@@ skipping 52 matching lines @@
   if (needs_number_check()) {
     f->Print(", with number check");
   }
 }
 
 
 void TestCidsInstr::PrintOperandsTo(BufferFormatter* f) const {
   left()->PrintTo(f);
   f->Print(" %s [", Token::Str(kind()));
   for (intptr_t i = 0; i < cid_results().length(); i += 2) {
-    f->Print("0x%" Px ":%s ",
-        cid_results()[i], cid_results()[i + 1] == 0 ? "false" : "true");
+    f->Print("0x%" Px ":%s ", cid_results()[i],
+             cid_results()[i + 1] == 0 ? "false" : "true");
   }
   f->Print("] ");
 }
 
 
 void EqualityCompareInstr::PrintOperandsTo(BufferFormatter* f) const {
   left()->PrintTo(f);
   f->Print(" %s ", Token::Str(kind()));
   right()->PrintTo(f);
 }
@@ skipping 18 matching lines @@
   value()->PrintTo(f);
 }
 
 
 void NativeCallInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s", native_name().ToCString());
 }
 
 
 void GuardFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%s %s, ",
-           String::Handle(field().name()).ToCString(),
+  f->Print("%s %s, ", String::Handle(field().name()).ToCString(),
            field().GuardedPropertiesAsCString());
   value()->PrintTo(f);
 }
 
 
 void StoreInstanceFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   if (field().IsNull()) {
     f->Print("{%" Pd "}, ", offset_in_bytes());
   } else {
-    f->Print("%s {%" Pd "}, ",
-             String::Handle(field().name()).ToCString(),
+    f->Print("%s {%" Pd "}, ", String::Handle(field().name()).ToCString(),
              field().Offset());
   }
   instance()->PrintTo(f);
   f->Print(", ");
   value()->PrintTo(f);
 }
 
 
 void IfThenElseInstr::PrintOperandsTo(BufferFormatter* f) const {
   comparison()->PrintOperandsTo(f);
-  f->Print(" ? %" Pd " : %" Pd,
-           if_true_,
-           if_false_);
+  f->Print(" ? %" Pd " : %" Pd, if_true_, if_false_);
 }
 
 
 void LoadStaticFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   field_value()->PrintTo(f);
 }
 
 
 void StoreStaticFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", String::Handle(field().name()).ToCString());
   value()->PrintTo(f);
 }
 
 
 void InstanceOfInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
-  f->Print(" %s %s",
-            negate_result() ? "ISNOT" : "IS",
-            String::Handle(type().Name()).ToCString());
+  f->Print(" %s %s", negate_result() ? "ISNOT" : "IS",
+           String::Handle(type().Name()).ToCString());
   f->Print(" type-arg(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print(")");
 }
 
 
 void RelationalOpInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(kind()));
   left()->PrintTo(f);
   f->Print(", ");
@@ skipping 26 matching lines @@
 
 void LoadFieldInstr::PrintOperandsTo(BufferFormatter* f) const {
   instance()->PrintTo(f);
   f->Print(", %" Pd, offset_in_bytes());
 
   if (field() != NULL) {
     f->Print(" {%s}", String::Handle(field()->name()).ToCString());
     const char* expected = "?";
     if (field()->guarded_cid() != kIllegalCid) {
       const Class& cls = Class::Handle(
-            Isolate::Current()->class_table()->At(field()->guarded_cid()));
+          Isolate::Current()->class_table()->At(field()->guarded_cid()));
       expected = String::Handle(cls.Name()).ToCString();
     }
 
-    f->Print(" [%s %s]",
-             field()->is_nullable() ? "nullable" : "non-nullable",
+    f->Print(" [%s %s]", field()->is_nullable() ? "nullable" : "non-nullable",
              expected);
   }
 
   f->Print(", immutable=%d", immutable_);
 }
 
 
 void InstantiateTypeInstr::PrintOperandsTo(BufferFormatter* f) const {
   const String& type_name = String::Handle(type().Name());
   f->Print("%s, ", type_name.ToCString());
@@ skipping 336 matching lines @@
 void UnaryDoubleOpInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%s, ", Token::Str(op_kind()));
   value()->PrintTo(f);
 }
 
 
 void CheckClassIdInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
 
   const Class& cls =
-    Class::Handle(Isolate::Current()->class_table()->At(cid()));
+      Class::Handle(Isolate::Current()->class_table()->At(cid()));
   f->Print(", %s", String::Handle(cls.ScrubbedName()).ToCString());
 }
 
 
 void CheckClassInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
   if (FLAG_display_sorted_ic_data) {
     PrintICDataSortedHelper(f, unary_checks());
   } else {
     PrintICDataHelper(f, unary_checks(), FlowGraphPrinter::kPrintAll);
@@ skipping 20 matching lines @@
       f->Print("\n      ");
       def->PrintTo(f);
     }
     f->Print("\n}");
   }
 }
 
 
 void JoinEntryInstr::PrintTo(BufferFormatter* f) const {
   if (try_index() != CatchClauseNode::kInvalidTryIndex) {
-    f->Print("B%" Pd "[join try_idx %" Pd "]:%" Pd " pred(",
-             block_id(), try_index(), GetDeoptId());
+    f->Print("B%" Pd "[join try_idx %" Pd "]:%" Pd " pred(", block_id(),
+             try_index(), GetDeoptId());
   } else {
     f->Print("B%" Pd "[join]:%" Pd " pred(", block_id(), GetDeoptId());
   }
   for (intptr_t i = 0; i < predecessors_.length(); ++i) {
     if (i > 0) f->Print(", ");
     f->Print("B%" Pd, predecessors_[i]->block_id());
   }
   f->Print(")");
   if (phis_ != NULL) {
     f->Print(" {");
@@ skipping 28 matching lines @@
     }
     f->Print("\n}");
   }
   if (HasParallelMove()) {
     f->Print(" ");
     parallel_move()->PrintTo(f);
   }
 }
 
 
-static const char *RepresentationToCString(Representation rep) {
+static const char* RepresentationToCString(Representation rep) {
   switch (rep) {
     case kTagged:
       return "tagged";
     case kUntagged:
       return "untagged";
     case kUnboxedDouble:
       return "double";
     case kUnboxedInt32:
       return "int32";
     case kUnboxedUint32:
@@ skipping 14 matching lines @@
       return "none";
     case kNumRepresentations:
       UNREACHABLE();
   }
   return "?";
 }
 
 
 void PhiInstr::PrintTo(BufferFormatter* f) const {
   if (HasPairRepresentation()) {
-    f->Print("(v%" Pd ", v%" Pd ") <- phi(",
-             ssa_temp_index(), ssa_temp_index() + 1);
+    f->Print("(v%" Pd ", v%" Pd ") <- phi(", ssa_temp_index(),
+             ssa_temp_index() + 1);
   } else {
     f->Print("v%" Pd " <- phi(", ssa_temp_index());
   }
   for (intptr_t i = 0; i < inputs_.length(); ++i) {
     if (inputs_[i] != NULL) inputs_[i]->PrintTo(f);
     if (i < inputs_.length() - 1) f->Print(", ");
   }
   f->Print(")");
   if (is_alive()) {
     f->Print(" alive");
   } else {
     f->Print(" dead");
   }
   if (range_ != NULL) {
     f->Print(" ");
     range_->PrintTo(f);
   }
 
-  if (representation() != kNoRepresentation &&
-      representation() != kTagged) {
+  if (representation() != kNoRepresentation && representation() != kTagged) {
     f->Print(" %s", RepresentationToCString(representation()));
   }
 
   if (type_ != NULL) {
     f->Print(" ");
     type_->PrintTo(f);
   }
 }
 
 
 void UnboxIntegerInstr::PrintOperandsTo(BufferFormatter* f) const {
   if (is_truncating()) {
     f->Print("[tr], ");
   }
   Definition::PrintOperandsTo(f);
 }
 
 
 void UnboxedIntConverterInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%s->%s%s, ",
-           RepresentationToCString(from()),
-           RepresentationToCString(to()),
-           is_truncating() ? "[tr]" : "");
+  f->Print("%s->%s%s, ", RepresentationToCString(from()),
+           RepresentationToCString(to()), is_truncating() ? "[tr]" : "");
   Definition::PrintOperandsTo(f);
 }
 
 
 void ParameterInstr::PrintOperandsTo(BufferFormatter* f) const {
   f->Print("%" Pd, index());
 }
 
 
 void CheckStackOverflowInstr::PrintOperandsTo(BufferFormatter* f) const {
   if (in_loop()) f->Print("depth %" Pd, loop_depth());
 }
 
 
 void TargetEntryInstr::PrintTo(BufferFormatter* f) const {
   if (try_index() != CatchClauseNode::kInvalidTryIndex) {
-    f->Print("B%" Pd "[target try_idx %" Pd "]:%" Pd,
-             block_id(), try_index(), GetDeoptId());
+    f->Print("B%" Pd "[target try_idx %" Pd "]:%" Pd, block_id(), try_index(),
+             GetDeoptId());
   } else {
     f->Print("B%" Pd "[target]:%" Pd, block_id(), GetDeoptId());
   }
   if (HasParallelMove()) {
     f->Print(" ");
     parallel_move()->PrintTo(f);
   }
 }
 
 
@@ skipping 45 matching lines @@
   InputAt(0)->PrintTo(f);
   f->Print(")");
 }
 
 
 void BranchInstr::PrintTo(BufferFormatter* f) const {
   f->Print("%s ", DebugName());
   f->Print("if ");
   comparison()->PrintTo(f);
 
-  f->Print(" goto (%" Pd ", %" Pd ")",
-            true_successor()->block_id(),
-            false_successor()->block_id());
+  f->Print(" goto (%" Pd ", %" Pd ")", true_successor()->block_id(),
+           false_successor()->block_id());
 }
 
 
 void ParallelMoveInstr::PrintTo(BufferFormatter* f) const {
   f->Print("%s ", DebugName());
   for (intptr_t i = 0; i < moves_.length(); i++) {
     if (i != 0) f->Print(", ");
     moves_[i]->dest().PrintTo(f);
     f->Print(" <- ");
     moves_[i]->src().PrintTo(f);
@@ skipping 70 matching lines @@
 }
 
 
 bool FlowGraphPrinter::ShouldPrint(const Function& function) {
   return false;
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart