clang-format runtime/vm

runtime/vm/flow_graph_compiler_dbc.cc

 // Copyright (c) 2016, 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/globals.h"  // Needed here to get TARGET_ARCH_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/ast_printer.h"
@@ skipping 102 matching lines @@
   builder->AddPcMarker(Function::ZoneHandle(zone), slot_ix++);
   builder->AddConstant(Function::ZoneHandle(zone), slot_ix++);
 
   // Emit all values that are needed for materialization as a part of the
   // expression stack for the bottom-most frame. This guarantees that GC
   // will be able to find them during materialization.
   slot_ix = builder->EmitMaterializationArguments(slot_ix);
 
   // For the innermost environment, set outgoing arguments and the locals.
   for (intptr_t i = current->Length() - 1;
-       i >= current->fixed_parameter_count();
-       i--) {
+       i >= current->fixed_parameter_count(); i--) {
     builder->AddCopy(current->ValueAt(i), current->LocationAt(i), slot_ix++);
   }
 
   builder->AddCallerFp(slot_ix++);
 
   Environment* previous = current;
   current = current->outer();
   while (current != NULL) {
     // For any outer environment the deopt id is that of the call instruction
     // which is recorded in the outer environment.
-    builder->AddReturnAddress(
-        current->function(),
-        Thread::ToDeoptAfter(current->deopt_id()),
-        slot_ix++);
+    builder->AddReturnAddress(current->function(),
+                              Thread::ToDeoptAfter(current->deopt_id()),
+                              slot_ix++);
 
     builder->AddPcMarker(previous->function(), slot_ix++);
     builder->AddConstant(previous->function(), slot_ix++);
 
     // The values of outgoing arguments can be changed from the inlined call so
     // we must read them from the previous environment.
     for (intptr_t i = previous->fixed_parameter_count() - 1; i >= 0; i--) {
-      builder->AddCopy(previous->ValueAt(i),
-                       previous->LocationAt(i),
+      builder->AddCopy(previous->ValueAt(i), previous->LocationAt(i),
                        slot_ix++);
     }
 
     // Set the locals, note that outgoing arguments are not in the environment.
     for (intptr_t i = current->Length() - 1;
-         i >= current->fixed_parameter_count();
-         i--) {
-      builder->AddCopy(current->ValueAt(i),
-                       current->LocationAt(i),
-                       slot_ix++);
+         i >= current->fixed_parameter_count(); i--) {
+      builder->AddCopy(current->ValueAt(i), current->LocationAt(i), slot_ix++);
     }
 
     builder->AddCallerFp(slot_ix++);
 
     // Iterate on the outer environment.
     previous = current;
     current = current->outer();
   }
   // The previous pointer is now the outermost environment.
   ASSERT(previous != NULL);
@@ skipping 20 matching lines @@
   // deoptimization point in optimized code, after call.
   const intptr_t deopt_id_after = Thread::ToDeoptAfter(instr->deopt_id());
   if (is_optimizing()) {
     // Return/ReturnTOS instruction drops incoming arguments so
     // we have to drop outgoing arguments from the innermost environment.
     // On all other architectures caller drops outgoing arguments itself
     // hence the difference.
     pending_deoptimization_env_->DropArguments(instr->ArgumentCount());
     AddDeoptIndexAtCall(deopt_id_after);
     // This descriptor is needed for exception handling in optimized code.
-    AddCurrentDescriptor(RawPcDescriptors::kOther,
-                         deopt_id_after, instr->token_pos());
+    AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id_after,
+                         instr->token_pos());
   } else {
     // Add deoptimization continuation point after the call and before the
     // arguments are removed.
-    AddCurrentDescriptor(RawPcDescriptors::kDeopt,
-                         deopt_id_after,
+    AddCurrentDescriptor(RawPcDescriptors::kDeopt, deopt_id_after,
                          instr->token_pos());
   }
 }
 
 
 void CompilerDeoptInfoWithStub::GenerateCode(FlowGraphCompiler* compiler,
                                              intptr_t stub_ix) {
   UNREACHABLE();
 }
 
@@ skipping 22 matching lines @@
   __ PushConstant(dst_name);
 
   if (dst_type.IsMalformedOrMalbounded()) {
     __ BadTypeError();
   } else {
     bool may_be_smi = false;
     if (!dst_type.IsVoidType() && dst_type.IsInstantiated()) {
       const Class& type_class = Class::Handle(zone(), dst_type.type_class());
       if (type_class.NumTypeArguments() == 0) {
         const Class& smi_class = Class::Handle(zone(), Smi::Class());
-        may_be_smi = smi_class.IsSubtypeOf(TypeArguments::Handle(zone()),
-                                           type_class,
-                                           TypeArguments::Handle(zone()),
-                                           NULL,
-                                           NULL,
-                                           Heap::kOld);
+        may_be_smi = smi_class.IsSubtypeOf(
+            TypeArguments::Handle(zone()), type_class,
+            TypeArguments::Handle(zone()), NULL, NULL, Heap::kOld);
       }
     }
     __ AssertAssignable(may_be_smi ? 1 : 0, __ AddConstant(test_cache));
   }
 
   if (is_optimizing()) {
     // Register allocator does not think that our first input (also used as
     // output) needs to be kept alive across the call because that is how code
     // is written on other platforms (where registers are always spilled across
     // the call): inputs are consumed by operation and output is produced so
     // neither are alive at the safepoint.
     // We have to mark the slot alive manually to ensure that GC
     // visits it.
     locs->SetStackBit(locs->out(0).reg());
   }
   RecordSafepoint(locs);
   AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id, token_pos);
   if (is_optimizing()) {
     // Assert assignable keeps the instance on the stack as the result,
     // all other arguments are popped.
     ASSERT(locs->out(0).reg() == locs->in(0).reg());
     __ Drop1();
   }
 }
 
 
 void FlowGraphCompiler::EmitInstructionEpilogue(Instruction* instr) {
   if (!is_optimizing()) {
     Definition* defn = instr->AsDefinition();
-    if ((defn != NULL) &&
-        (defn->tag() != Instruction::kPushArgument) &&
+    if ((defn != NULL) && (defn->tag() != Instruction::kPushArgument) &&
         (defn->tag() != Instruction::kStoreIndexed) &&
         (defn->tag() != Instruction::kStoreStaticField) &&
         (defn->tag() != Instruction::kStoreLocal) &&
         (defn->tag() != Instruction::kStoreInstanceField) &&
-        (defn->tag() != Instruction::kDropTemps) &&
-        !defn->HasTemp()) {
+        (defn->tag() != Instruction::kDropTemps) && !defn->HasTemp()) {
       __ Drop1();
     }
   }
 }
 
 
 void FlowGraphCompiler::GenerateInlinedGetter(intptr_t offset) {
   __ Move(0, -(1 + kParamEndSlotFromFp));
   ASSERT(offset % kWordSize == 0);
-  if (Utils::IsInt(8, offset/ kWordSize)) {
+  if (Utils::IsInt(8, offset / kWordSize)) {
     __ LoadField(0, 0, offset / kWordSize);
   } else {
     __ LoadFieldExt(0, 0);
     __ Nop(offset / kWordSize);
   }
   __ Return(0);
 }
 
 
 void FlowGraphCompiler::GenerateInlinedSetter(intptr_t offset) {
   __ Move(0, -(2 + kParamEndSlotFromFp));
   __ Move(1, -(1 + kParamEndSlotFromFp));
   ASSERT(offset % kWordSize == 0);
-  if (Utils::IsInt(8, offset/ kWordSize)) {
+  if (Utils::IsInt(8, offset / kWordSize)) {
     __ StoreField(0, offset / kWordSize, 1);
   } else {
     __ StoreFieldExt(0, 1);
     __ Nop(offset / kWordSize);
   }
   __ LoadConstant(0, Object::Handle());
   __ Return(0);
 }
 
 
 void FlowGraphCompiler::EmitFrameEntry() {
   const Function& function = parsed_function().function();
   const intptr_t num_fixed_params = function.num_fixed_parameters();
   const int num_opt_pos_params = function.NumOptionalPositionalParameters();
   const int num_opt_named_params = function.NumOptionalNamedParameters();
   const int num_params =
       num_fixed_params + num_opt_pos_params + num_opt_named_params;
-  const bool has_optional_params = (num_opt_pos_params != 0) ||
-      (num_opt_named_params != 0);
+  const bool has_optional_params =
+      (num_opt_pos_params != 0) || (num_opt_named_params != 0);
   const int num_locals = parsed_function().num_stack_locals();
   const intptr_t context_index =
       -parsed_function().current_context_var()->index() - 1;
 
-  if (CanOptimizeFunction() &&
-      function.IsOptimizable() &&
+  if (CanOptimizeFunction() && function.IsOptimizable() &&
       (!is_optimizing() || may_reoptimize())) {
     __ HotCheck(!is_optimizing(), GetOptimizationThreshold());
   }
 
   if (has_optional_params) {
-    __ EntryOptional(num_fixed_params,
-                     num_opt_pos_params,
+    __ EntryOptional(num_fixed_params, num_opt_pos_params,
                      num_opt_named_params);
   } else if (!is_optimizing()) {
     __ Entry(num_fixed_params, num_locals, context_index);
   } else {
     __ EntryOptimized(num_fixed_params,
                       flow_graph_.graph_entry()->spill_slot_count());
   }
 
   if (num_opt_named_params != 0) {
     LocalScope* scope = parsed_function().node_sequence()->scope();
@@ skipping 29 matching lines @@
     for (intptr_t i = 0; i < num_opt_pos_params; i++) {
       const Object& value = parsed_function().DefaultParameterValueAt(i);
       __ LoadConstant(num_fixed_params + i, value);
     }
   }
 
 
   if (has_optional_params) {
     if (!is_optimizing()) {
       ASSERT(num_locals > 0);  // There is always at least context_var.
-      __ Frame(num_locals);  // Reserve space for locals.
+      __ Frame(num_locals);    // Reserve space for locals.
     } else if (flow_graph_.graph_entry()->spill_slot_count() >
-                   flow_graph_.num_copied_params()) {
+               flow_graph_.num_copied_params()) {
       __ Frame(flow_graph_.graph_entry()->spill_slot_count() -
-          flow_graph_.num_copied_params());
+               flow_graph_.num_copied_params());
     }
   }
 
   if (function.IsClosureFunction()) {
-    Register reg = is_optimizing() ? flow_graph_.num_copied_params()
-                                   : context_index;
+    Register reg =
+        is_optimizing() ? flow_graph_.num_copied_params() : context_index;
     Register closure_reg = reg;
     LocalScope* scope = parsed_function().node_sequence()->scope();
     LocalVariable* local = scope->VariableAt(0);
     if (local->index() > 0) {
       __ Move(reg, -local->index());
     } else {
       closure_reg = -local->index() - 1;
     }
     __ LoadField(reg, closure_reg, Closure::context_offset() / kWordSize);
   } else if (has_optional_params && !is_optimizing()) {
     __ LoadConstant(context_index,
-        Object::Handle(isolate()->object_store()->empty_context()));
+                    Object::Handle(isolate()->object_store()->empty_context()));
   }
 }
 
 
 void FlowGraphCompiler::CompileGraph() {
   InitCompiler();
 
   if (TryIntrinsify()) {
     // Skip regular code generation.
     return;
@@ skipping 134 matching lines @@
 void ParallelMoveResolver::RestoreFpuScratch(FpuRegister reg) {
   UNIMPLEMENTED();
 }
 
 
 #undef __
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC