Fix product build for 32-bit architectures, simulators and ARM64.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 4870 matching lines @@
       new(Z) BitVector(Z, flow_graph_->current_ssa_temp_index());
 
   // Worklist used to collect dependency graph.
   DefinitionWorklist worklist(flow_graph_, candidates.length());
   for (intptr_t i = 0; i < candidates.length(); i++) {
     BinarySmiOpInstr* op = candidates[i];
     if (op->WasEliminated() || processed->Contains(op->ssa_temp_index())) {
       continue;
     }
 
-    if (FLAG_trace_smi_widening) {
+    if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
       THR_Print("analysing candidate: %s\n", op->ToCString());
     }
     worklist.Clear();
     worklist.Add(op);
 
     // Collect dependency graph. Note: more items are added to worklist
     // inside this loop.
     intptr_t gain = 0;
     for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
       Definition* defn = worklist.definitions()[j];
 
-      if (FLAG_trace_smi_widening) {
+      if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
         THR_Print("> %s\n", defn->ToCString());
       }
 
       if (defn->IsBinarySmiOp() &&
           BenefitsFromWidening(defn->AsBinarySmiOp())) {
         gain++;
-        if (FLAG_trace_smi_widening) {
+        if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
           THR_Print("^ [%" Pd "] (o) %s\n", gain, defn->ToCString());
         }
       }
 
       const intptr_t defn_loop = loops[defn->GetBlock()->preorder_number()];
 
       // Process all inputs.
       for (intptr_t k = 0; k < defn->InputCount(); k++) {
         Definition* input = defn->InputAt(k)->definition();
         if (input->IsBinarySmiOp() &&
             CanBeWidened(input->AsBinarySmiOp())) {
           worklist.Add(input);
         } else if (input->IsPhi() && (input->Type()->ToCid() == kSmiCid)) {
           worklist.Add(input);
         } else if (input->IsBinaryMintOp()) {
           // Mint operation produces untagged result. We avoid tagging.
           gain++;
-          if (FLAG_trace_smi_widening) {
+          if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("^ [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         } else if (defn_loop == loops[input->GetBlock()->preorder_number()] &&
                    (input->Type()->ToCid() == kSmiCid)) {
           // Input comes from the same loop, is known to be smi and requires
           // untagging.
           // TODO(vegorov) this heuristic assumes that values that are not
           // known to be smi have to be checked and this check can be
           // coalesced with untagging. Start coalescing them.
           gain--;
-          if (FLAG_trace_smi_widening) {
+          if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("v [%" Pd "] (i) %s\n", gain, input->ToCString());
           }
         }
       }
 
       // Process all uses.
       for (Value* use = defn->input_use_list();
            use != NULL;
            use = use->next_use()) {
         Instruction* instr = use->instruction();
         Definition* use_defn = instr->AsDefinition();
         if (use_defn == NULL) {
           // We assume that tagging before returning or pushing argument costs
           // very little compared to the cost of the return/call itself.
           if (!instr->IsReturn() && !instr->IsPushArgument()) {
             gain--;
-            if (FLAG_trace_smi_widening) {
+            if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
               THR_Print("v [%" Pd "] (u) %s\n",
                         gain,
                         use->instruction()->ToCString());
             }
           }
           continue;
         } else if (use_defn->IsBinarySmiOp() &&
                    CanBeWidened(use_defn->AsBinarySmiOp())) {
           worklist.Add(use_defn);
         } else if (use_defn->IsPhi() &&
                    use_defn->AsPhi()->Type()->ToCid() == kSmiCid) {
           worklist.Add(use_defn);
         } else if (use_defn->IsBinaryMintOp()) {
           // BinaryMintOp requires untagging of its inputs.
           // Converting kUnboxedInt32 to kUnboxedMint is essentially zero cost
           // sign extension operation.
           gain++;
-          if (FLAG_trace_smi_widening) {
+          if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("^ [%" Pd "] (u) %s\n",
                       gain,
                       use->instruction()->ToCString());
           }
         } else if (defn_loop == loops[instr->GetBlock()->preorder_number()]) {
           gain--;
-          if (FLAG_trace_smi_widening) {
+          if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
             THR_Print("v [%" Pd "] (u) %s\n",
                       gain,
                       use->instruction()->ToCString());
           }
         }
       }
     }
 
     processed->AddAll(worklist.contains_vector());
 
-    if (FLAG_trace_smi_widening) {
+    if (FLAG_support_il_printer && FLAG_trace_smi_widening) {
       THR_Print("~ %s gain %" Pd "\n", op->ToCString(), gain);
     }
 
     if (gain > 0) {
       // We have positive gain from widening. Convert all BinarySmiOpInstr into
       // BinaryInt32OpInstr and set representation of all phis to kUnboxedInt32.
       for (intptr_t j = 0; j < worklist.definitions().length(); j++) {
         Definition* defn = worklist.definitions()[j];
         ASSERT(defn->IsPhi() || defn->IsBinarySmiOp());
 
@@ skipping 44 matching lines @@
         // the code for this instruction, however, leaving the environment
         // changes code.
         current->RemoveEnvironment();
       }
     }
   }
 }
 
 
 }  // namespace dart