1 /*
2  * Copyright (C) 2014 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "graph_visualizer.h"
18 
19 #include <dlfcn.h>
20 
21 #include <cctype>
22 #include <sstream>
23 
24 #include "art_method.h"
25 #include "bounds_check_elimination.h"
26 #include "builder.h"
27 #include "code_generator.h"
28 #include "data_type-inl.h"
29 #include "dead_code_elimination.h"
30 #include "dex/descriptors_names.h"
31 #include "disassembler.h"
32 #include "inliner.h"
33 #include "licm.h"
34 #include "nodes.h"
35 #include "optimization.h"
36 #include "reference_type_propagation.h"
37 #include "register_allocator_linear_scan.h"
38 #include "scoped_thread_state_change-inl.h"
39 #include "ssa_liveness_analysis.h"
40 #include "utils/assembler.h"
41 #include "utils/intrusive_forward_list.h"
42 
43 namespace art {
44 
HasWhitespace(const char * str)45 static bool HasWhitespace(const char* str) {
46   DCHECK(str != nullptr);
47   while (str[0] != 0) {
48     if (isspace(str[0])) {
49       return true;
50     }
51     str++;
52   }
53   return false;
54 }
55 
56 class StringList {
57  public:
58   enum Format {
59     kArrayBrackets,
60     kSetBrackets,
61   };
62 
63   // Create an empty list
StringList(Format format=kArrayBrackets)64   explicit StringList(Format format = kArrayBrackets) : format_(format), is_empty_(true) {}
65 
66   // Construct StringList from a linked list. List element class T
67   // must provide methods `GetNext` and `Dump`.
68   template<class T>
StringList(T * first_entry,Format format=kArrayBrackets)69   explicit StringList(T* first_entry, Format format = kArrayBrackets) : StringList(format) {
70     for (T* current = first_entry; current != nullptr; current = current->GetNext()) {
71       current->Dump(NewEntryStream());
72     }
73   }
74   // Construct StringList from a list of elements. The value type must provide method `Dump`.
75   template <typename Container>
StringList(const Container & list,Format format=kArrayBrackets)76   explicit StringList(const Container& list, Format format = kArrayBrackets) : StringList(format) {
77     for (const typename Container::value_type& current : list) {
78       current.Dump(NewEntryStream());
79     }
80   }
81 
NewEntryStream()82   std::ostream& NewEntryStream() {
83     if (is_empty_) {
84       is_empty_ = false;
85     } else {
86       sstream_ << ",";
87     }
88     return sstream_;
89   }
90 
91  private:
92   Format format_;
93   bool is_empty_;
94   std::ostringstream sstream_;
95 
96   friend std::ostream& operator<<(std::ostream& os, const StringList& list);
97 };
98 
operator <<(std::ostream & os,const StringList & list)99 std::ostream& operator<<(std::ostream& os, const StringList& list) {
100   switch (list.format_) {
101     case StringList::kArrayBrackets: return os << "[" << list.sstream_.str() << "]";
102     case StringList::kSetBrackets:   return os << "{" << list.sstream_.str() << "}";
103     default:
104       LOG(FATAL) << "Invalid StringList format";
105       UNREACHABLE();
106   }
107 }
108 
109 typedef Disassembler* create_disasm_prototype(InstructionSet instruction_set,
110                                               DisassemblerOptions* options);
111 class HGraphVisualizerDisassembler {
112  public:
HGraphVisualizerDisassembler(InstructionSet instruction_set,const uint8_t * base_address,const uint8_t * end_address)113   HGraphVisualizerDisassembler(InstructionSet instruction_set,
114                                const uint8_t* base_address,
115                                const uint8_t* end_address)
116       : instruction_set_(instruction_set), disassembler_(nullptr) {
117     libart_disassembler_handle_ =
118         dlopen(kIsDebugBuild ? "libartd-disassembler.so" : "libart-disassembler.so", RTLD_NOW);
119     if (libart_disassembler_handle_ == nullptr) {
120       LOG(WARNING) << "Failed to dlopen libart-disassembler: " << dlerror();
121       return;
122     }
123     create_disasm_prototype* create_disassembler = reinterpret_cast<create_disasm_prototype*>(
124         dlsym(libart_disassembler_handle_, "create_disassembler"));
125     if (create_disassembler == nullptr) {
126       LOG(WARNING) << "Could not find create_disassembler entry: " << dlerror();
127       return;
128     }
129     // Reading the disassembly from 0x0 is easier, so we print relative
130     // addresses. We will only disassemble the code once everything has
131     // been generated, so we can read data in literal pools.
132     disassembler_ = std::unique_ptr<Disassembler>((*create_disassembler)(
133             instruction_set,
134             new DisassemblerOptions(/* absolute_addresses */ false,
135                                     base_address,
136                                     end_address,
137                                     /* can_read_literals */ true,
138                                     Is64BitInstructionSet(instruction_set)
139                                         ? &Thread::DumpThreadOffset<PointerSize::k64>
140                                         : &Thread::DumpThreadOffset<PointerSize::k32>)));
141   }
142 
~HGraphVisualizerDisassembler()143   ~HGraphVisualizerDisassembler() {
144     // We need to call ~Disassembler() before we close the library.
145     disassembler_.reset();
146     if (libart_disassembler_handle_ != nullptr) {
147       dlclose(libart_disassembler_handle_);
148     }
149   }
150 
Disassemble(std::ostream & output,size_t start,size_t end) const151   void Disassemble(std::ostream& output, size_t start, size_t end) const {
152     if (disassembler_ == nullptr) {
153       return;
154     }
155 
156     const uint8_t* base = disassembler_->GetDisassemblerOptions()->base_address_;
157     if (instruction_set_ == InstructionSet::kThumb2) {
158       // ARM and Thumb-2 use the same disassembler. The bottom bit of the
159       // address is used to distinguish between the two.
160       base += 1;
161     }
162     disassembler_->Dump(output, base + start, base + end);
163   }
164 
165  private:
166   InstructionSet instruction_set_;
167   std::unique_ptr<Disassembler> disassembler_;
168 
169   void* libart_disassembler_handle_;
170 };
171 
172 
173 /**
174  * HGraph visitor to generate a file suitable for the c1visualizer tool and IRHydra.
175  */
176 class HGraphVisualizerPrinter : public HGraphDelegateVisitor {
177  public:
HGraphVisualizerPrinter(HGraph * graph,std::ostream & output,const char * pass_name,bool is_after_pass,bool graph_in_bad_state,const CodeGenerator & codegen,const DisassemblyInformation * disasm_info=nullptr)178   HGraphVisualizerPrinter(HGraph* graph,
179                           std::ostream& output,
180                           const char* pass_name,
181                           bool is_after_pass,
182                           bool graph_in_bad_state,
183                           const CodeGenerator& codegen,
184                           const DisassemblyInformation* disasm_info = nullptr)
185       : HGraphDelegateVisitor(graph),
186         output_(output),
187         pass_name_(pass_name),
188         is_after_pass_(is_after_pass),
189         graph_in_bad_state_(graph_in_bad_state),
190         codegen_(codegen),
191         disasm_info_(disasm_info),
192         disassembler_(disasm_info_ != nullptr
193                       ? new HGraphVisualizerDisassembler(
194                             codegen_.GetInstructionSet(),
195                             codegen_.GetAssembler().CodeBufferBaseAddress(),
196                             codegen_.GetAssembler().CodeBufferBaseAddress()
197                                 + codegen_.GetAssembler().CodeSize())
198                       : nullptr),
199         indent_(0) {}
200 
Flush()201   void Flush() {
202     // We use "\n" instead of std::endl to avoid implicit flushing which
203     // generates too many syscalls during debug-GC tests (b/27826765).
204     output_ << std::flush;
205   }
206 
StartTag(const char * name)207   void StartTag(const char* name) {
208     AddIndent();
209     output_ << "begin_" << name << "\n";
210     indent_++;
211   }
212 
EndTag(const char * name)213   void EndTag(const char* name) {
214     indent_--;
215     AddIndent();
216     output_ << "end_" << name << "\n";
217   }
218 
PrintProperty(const char * name,const char * property)219   void PrintProperty(const char* name, const char* property) {
220     AddIndent();
221     output_ << name << " \"" << property << "\"\n";
222   }
223 
PrintProperty(const char * name,const char * property,int id)224   void PrintProperty(const char* name, const char* property, int id) {
225     AddIndent();
226     output_ << name << " \"" << property << id << "\"\n";
227   }
228 
PrintEmptyProperty(const char * name)229   void PrintEmptyProperty(const char* name) {
230     AddIndent();
231     output_ << name << "\n";
232   }
233 
PrintTime(const char * name)234   void PrintTime(const char* name) {
235     AddIndent();
236     output_ << name << " " << time(nullptr) << "\n";
237   }
238 
PrintInt(const char * name,int value)239   void PrintInt(const char* name, int value) {
240     AddIndent();
241     output_ << name << " " << value << "\n";
242   }
243 
AddIndent()244   void AddIndent() {
245     for (size_t i = 0; i < indent_; ++i) {
246       output_ << "  ";
247     }
248   }
249 
PrintPredecessors(HBasicBlock * block)250   void PrintPredecessors(HBasicBlock* block) {
251     AddIndent();
252     output_ << "predecessors";
253     for (HBasicBlock* predecessor : block->GetPredecessors()) {
254       output_ << " \"B" << predecessor->GetBlockId() << "\" ";
255     }
256     if (block->IsEntryBlock() && (disasm_info_ != nullptr)) {
257       output_ << " \"" << kDisassemblyBlockFrameEntry << "\" ";
258     }
259     output_<< "\n";
260   }
261 
PrintSuccessors(HBasicBlock * block)262   void PrintSuccessors(HBasicBlock* block) {
263     AddIndent();
264     output_ << "successors";
265     for (HBasicBlock* successor : block->GetNormalSuccessors()) {
266       output_ << " \"B" << successor->GetBlockId() << "\" ";
267     }
268     output_<< "\n";
269   }
270 
PrintExceptionHandlers(HBasicBlock * block)271   void PrintExceptionHandlers(HBasicBlock* block) {
272     AddIndent();
273     output_ << "xhandlers";
274     for (HBasicBlock* handler : block->GetExceptionalSuccessors()) {
275       output_ << " \"B" << handler->GetBlockId() << "\" ";
276     }
277     if (block->IsExitBlock() &&
278         (disasm_info_ != nullptr) &&
279         !disasm_info_->GetSlowPathIntervals().empty()) {
280       output_ << " \"" << kDisassemblyBlockSlowPaths << "\" ";
281     }
282     output_<< "\n";
283   }
284 
DumpLocation(std::ostream & stream,const Location & location)285   void DumpLocation(std::ostream& stream, const Location& location) {
286     if (location.IsRegister()) {
287       codegen_.DumpCoreRegister(stream, location.reg());
288     } else if (location.IsFpuRegister()) {
289       codegen_.DumpFloatingPointRegister(stream, location.reg());
290     } else if (location.IsConstant()) {
291       stream << "#";
292       HConstant* constant = location.GetConstant();
293       if (constant->IsIntConstant()) {
294         stream << constant->AsIntConstant()->GetValue();
295       } else if (constant->IsLongConstant()) {
296         stream << constant->AsLongConstant()->GetValue();
297       } else if (constant->IsFloatConstant()) {
298         stream << constant->AsFloatConstant()->GetValue();
299       } else if (constant->IsDoubleConstant()) {
300         stream << constant->AsDoubleConstant()->GetValue();
301       } else if (constant->IsNullConstant()) {
302         stream << "null";
303       }
304     } else if (location.IsInvalid()) {
305       stream << "invalid";
306     } else if (location.IsStackSlot()) {
307       stream << location.GetStackIndex() << "(sp)";
308     } else if (location.IsFpuRegisterPair()) {
309       codegen_.DumpFloatingPointRegister(stream, location.low());
310       stream << "|";
311       codegen_.DumpFloatingPointRegister(stream, location.high());
312     } else if (location.IsRegisterPair()) {
313       codegen_.DumpCoreRegister(stream, location.low());
314       stream << "|";
315       codegen_.DumpCoreRegister(stream, location.high());
316     } else if (location.IsUnallocated()) {
317       stream << "unallocated";
318     } else if (location.IsDoubleStackSlot()) {
319       stream << "2x" << location.GetStackIndex() << "(sp)";
320     } else {
321       DCHECK(location.IsSIMDStackSlot());
322       stream << "4x" << location.GetStackIndex() << "(sp)";
323     }
324   }
325 
StartAttributeStream(const char * name=nullptr)326   std::ostream& StartAttributeStream(const char* name = nullptr) {
327     if (name == nullptr) {
328       output_ << " ";
329     } else {
330       DCHECK(!HasWhitespace(name)) << "Checker does not allow spaces in attributes";
331       output_ << " " << name << ":";
332     }
333     return output_;
334   }
335 
VisitParallelMove(HParallelMove * instruction)336   void VisitParallelMove(HParallelMove* instruction) OVERRIDE {
337     StartAttributeStream("liveness") << instruction->GetLifetimePosition();
338     StringList moves;
339     for (size_t i = 0, e = instruction->NumMoves(); i < e; ++i) {
340       MoveOperands* move = instruction->MoveOperandsAt(i);
341       std::ostream& str = moves.NewEntryStream();
342       DumpLocation(str, move->GetSource());
343       str << "->";
344       DumpLocation(str, move->GetDestination());
345     }
346     StartAttributeStream("moves") <<  moves;
347   }
348 
VisitIntConstant(HIntConstant * instruction)349   void VisitIntConstant(HIntConstant* instruction) OVERRIDE {
350     StartAttributeStream() << instruction->GetValue();
351   }
352 
VisitLongConstant(HLongConstant * instruction)353   void VisitLongConstant(HLongConstant* instruction) OVERRIDE {
354     StartAttributeStream() << instruction->GetValue();
355   }
356 
VisitFloatConstant(HFloatConstant * instruction)357   void VisitFloatConstant(HFloatConstant* instruction) OVERRIDE {
358     StartAttributeStream() << instruction->GetValue();
359   }
360 
VisitDoubleConstant(HDoubleConstant * instruction)361   void VisitDoubleConstant(HDoubleConstant* instruction) OVERRIDE {
362     StartAttributeStream() << instruction->GetValue();
363   }
364 
VisitPhi(HPhi * phi)365   void VisitPhi(HPhi* phi) OVERRIDE {
366     StartAttributeStream("reg") << phi->GetRegNumber();
367     StartAttributeStream("is_catch_phi") << std::boolalpha << phi->IsCatchPhi() << std::noboolalpha;
368   }
369 
VisitMemoryBarrier(HMemoryBarrier * barrier)370   void VisitMemoryBarrier(HMemoryBarrier* barrier) OVERRIDE {
371     StartAttributeStream("kind") << barrier->GetBarrierKind();
372   }
373 
VisitMonitorOperation(HMonitorOperation * monitor)374   void VisitMonitorOperation(HMonitorOperation* monitor) OVERRIDE {
375     StartAttributeStream("kind") << (monitor->IsEnter() ? "enter" : "exit");
376   }
377 
VisitLoadClass(HLoadClass * load_class)378   void VisitLoadClass(HLoadClass* load_class) OVERRIDE {
379     StartAttributeStream("load_kind") << load_class->GetLoadKind();
380     const char* descriptor = load_class->GetDexFile().GetTypeDescriptor(
381         load_class->GetDexFile().GetTypeId(load_class->GetTypeIndex()));
382     StartAttributeStream("class_name") << PrettyDescriptor(descriptor);
383     StartAttributeStream("gen_clinit_check") << std::boolalpha
384         << load_class->MustGenerateClinitCheck() << std::noboolalpha;
385     StartAttributeStream("needs_access_check") << std::boolalpha
386         << load_class->NeedsAccessCheck() << std::noboolalpha;
387   }
388 
VisitLoadString(HLoadString * load_string)389   void VisitLoadString(HLoadString* load_string) OVERRIDE {
390     StartAttributeStream("load_kind") << load_string->GetLoadKind();
391   }
392 
VisitCheckCast(HCheckCast * check_cast)393   void VisitCheckCast(HCheckCast* check_cast) OVERRIDE {
394     StartAttributeStream("check_kind") << check_cast->GetTypeCheckKind();
395     StartAttributeStream("must_do_null_check") << std::boolalpha
396         << check_cast->MustDoNullCheck() << std::noboolalpha;
397   }
398 
VisitInstanceOf(HInstanceOf * instance_of)399   void VisitInstanceOf(HInstanceOf* instance_of) OVERRIDE {
400     StartAttributeStream("check_kind") << instance_of->GetTypeCheckKind();
401     StartAttributeStream("must_do_null_check") << std::boolalpha
402         << instance_of->MustDoNullCheck() << std::noboolalpha;
403   }
404 
VisitArrayLength(HArrayLength * array_length)405   void VisitArrayLength(HArrayLength* array_length) OVERRIDE {
406     StartAttributeStream("is_string_length") << std::boolalpha
407         << array_length->IsStringLength() << std::noboolalpha;
408     if (array_length->IsEmittedAtUseSite()) {
409       StartAttributeStream("emitted_at_use") << "true";
410     }
411   }
412 
VisitBoundsCheck(HBoundsCheck * bounds_check)413   void VisitBoundsCheck(HBoundsCheck* bounds_check) OVERRIDE {
414     StartAttributeStream("is_string_char_at") << std::boolalpha
415         << bounds_check->IsStringCharAt() << std::noboolalpha;
416   }
417 
VisitArrayGet(HArrayGet * array_get)418   void VisitArrayGet(HArrayGet* array_get) OVERRIDE {
419     StartAttributeStream("is_string_char_at") << std::boolalpha
420         << array_get->IsStringCharAt() << std::noboolalpha;
421   }
422 
VisitArraySet(HArraySet * array_set)423   void VisitArraySet(HArraySet* array_set) OVERRIDE {
424     StartAttributeStream("value_can_be_null") << std::boolalpha
425         << array_set->GetValueCanBeNull() << std::noboolalpha;
426     StartAttributeStream("needs_type_check") << std::boolalpha
427         << array_set->NeedsTypeCheck() << std::noboolalpha;
428   }
429 
VisitCompare(HCompare * compare)430   void VisitCompare(HCompare* compare) OVERRIDE {
431     ComparisonBias bias = compare->GetBias();
432     StartAttributeStream("bias") << (bias == ComparisonBias::kGtBias
433                                      ? "gt"
434                                      : (bias == ComparisonBias::kLtBias ? "lt" : "none"));
435   }
436 
VisitInvoke(HInvoke * invoke)437   void VisitInvoke(HInvoke* invoke) OVERRIDE {
438     StartAttributeStream("dex_file_index") << invoke->GetDexMethodIndex();
439     ArtMethod* method = invoke->GetResolvedMethod();
440     // We don't print signatures, which conflict with c1visualizer format.
441     static constexpr bool kWithSignature = false;
442     // Note that we can only use the graph's dex file for the unresolved case. The
443     // other invokes might be coming from inlined methods.
444     ScopedObjectAccess soa(Thread::Current());
445     std::string method_name = (method == nullptr)
446         ? GetGraph()->GetDexFile().PrettyMethod(invoke->GetDexMethodIndex(), kWithSignature)
447         : method->PrettyMethod(kWithSignature);
448     StartAttributeStream("method_name") << method_name;
449     StartAttributeStream("always_throws") << std::boolalpha
450                                           << invoke->AlwaysThrows()
451                                           << std::noboolalpha;
452   }
453 
VisitInvokeUnresolved(HInvokeUnresolved * invoke)454   void VisitInvokeUnresolved(HInvokeUnresolved* invoke) OVERRIDE {
455     VisitInvoke(invoke);
456     StartAttributeStream("invoke_type") << invoke->GetInvokeType();
457   }
458 
VisitInvokeStaticOrDirect(HInvokeStaticOrDirect * invoke)459   void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) OVERRIDE {
460     VisitInvoke(invoke);
461     StartAttributeStream("method_load_kind") << invoke->GetMethodLoadKind();
462     StartAttributeStream("intrinsic") << invoke->GetIntrinsic();
463     if (invoke->IsStatic()) {
464       StartAttributeStream("clinit_check") << invoke->GetClinitCheckRequirement();
465     }
466   }
467 
VisitInvokeVirtual(HInvokeVirtual * invoke)468   void VisitInvokeVirtual(HInvokeVirtual* invoke) OVERRIDE {
469     VisitInvoke(invoke);
470     StartAttributeStream("intrinsic") << invoke->GetIntrinsic();
471   }
472 
VisitInvokePolymorphic(HInvokePolymorphic * invoke)473   void VisitInvokePolymorphic(HInvokePolymorphic* invoke) OVERRIDE {
474     VisitInvoke(invoke);
475     StartAttributeStream("invoke_type") << "InvokePolymorphic";
476   }
477 
VisitInstanceFieldGet(HInstanceFieldGet * iget)478   void VisitInstanceFieldGet(HInstanceFieldGet* iget) OVERRIDE {
479     StartAttributeStream("field_name") <<
480         iget->GetFieldInfo().GetDexFile().PrettyField(iget->GetFieldInfo().GetFieldIndex(),
481                                                       /* with type */ false);
482     StartAttributeStream("field_type") << iget->GetFieldType();
483   }
484 
VisitInstanceFieldSet(HInstanceFieldSet * iset)485   void VisitInstanceFieldSet(HInstanceFieldSet* iset) OVERRIDE {
486     StartAttributeStream("field_name") <<
487         iset->GetFieldInfo().GetDexFile().PrettyField(iset->GetFieldInfo().GetFieldIndex(),
488                                                       /* with type */ false);
489     StartAttributeStream("field_type") << iset->GetFieldType();
490   }
491 
VisitStaticFieldGet(HStaticFieldGet * sget)492   void VisitStaticFieldGet(HStaticFieldGet* sget) OVERRIDE {
493     StartAttributeStream("field_name") <<
494         sget->GetFieldInfo().GetDexFile().PrettyField(sget->GetFieldInfo().GetFieldIndex(),
495                                                       /* with type */ false);
496     StartAttributeStream("field_type") << sget->GetFieldType();
497   }
498 
VisitStaticFieldSet(HStaticFieldSet * sset)499   void VisitStaticFieldSet(HStaticFieldSet* sset) OVERRIDE {
500     StartAttributeStream("field_name") <<
501         sset->GetFieldInfo().GetDexFile().PrettyField(sset->GetFieldInfo().GetFieldIndex(),
502                                                       /* with type */ false);
503     StartAttributeStream("field_type") << sset->GetFieldType();
504   }
505 
VisitUnresolvedInstanceFieldGet(HUnresolvedInstanceFieldGet * field_access)506   void VisitUnresolvedInstanceFieldGet(HUnresolvedInstanceFieldGet* field_access) OVERRIDE {
507     StartAttributeStream("field_type") << field_access->GetFieldType();
508   }
509 
VisitUnresolvedInstanceFieldSet(HUnresolvedInstanceFieldSet * field_access)510   void VisitUnresolvedInstanceFieldSet(HUnresolvedInstanceFieldSet* field_access) OVERRIDE {
511     StartAttributeStream("field_type") << field_access->GetFieldType();
512   }
513 
VisitUnresolvedStaticFieldGet(HUnresolvedStaticFieldGet * field_access)514   void VisitUnresolvedStaticFieldGet(HUnresolvedStaticFieldGet* field_access) OVERRIDE {
515     StartAttributeStream("field_type") << field_access->GetFieldType();
516   }
517 
VisitUnresolvedStaticFieldSet(HUnresolvedStaticFieldSet * field_access)518   void VisitUnresolvedStaticFieldSet(HUnresolvedStaticFieldSet* field_access) OVERRIDE {
519     StartAttributeStream("field_type") << field_access->GetFieldType();
520   }
521 
VisitTryBoundary(HTryBoundary * try_boundary)522   void VisitTryBoundary(HTryBoundary* try_boundary) OVERRIDE {
523     StartAttributeStream("kind") << (try_boundary->IsEntry() ? "entry" : "exit");
524   }
525 
VisitDeoptimize(HDeoptimize * deoptimize)526   void VisitDeoptimize(HDeoptimize* deoptimize) OVERRIDE {
527     StartAttributeStream("kind") << deoptimize->GetKind();
528   }
529 
VisitVecOperation(HVecOperation * vec_operation)530   void VisitVecOperation(HVecOperation* vec_operation) OVERRIDE {
531     StartAttributeStream("packed_type") << vec_operation->GetPackedType();
532   }
533 
VisitVecMemoryOperation(HVecMemoryOperation * vec_mem_operation)534   void VisitVecMemoryOperation(HVecMemoryOperation* vec_mem_operation) OVERRIDE {
535     StartAttributeStream("alignment") << vec_mem_operation->GetAlignment().ToString();
536   }
537 
VisitVecHalvingAdd(HVecHalvingAdd * hadd)538   void VisitVecHalvingAdd(HVecHalvingAdd* hadd) OVERRIDE {
539     VisitVecBinaryOperation(hadd);
540     StartAttributeStream("rounded") << std::boolalpha << hadd->IsRounded() << std::noboolalpha;
541   }
542 
VisitVecMultiplyAccumulate(HVecMultiplyAccumulate * instruction)543   void VisitVecMultiplyAccumulate(HVecMultiplyAccumulate* instruction) OVERRIDE {
544     VisitVecOperation(instruction);
545     StartAttributeStream("kind") << instruction->GetOpKind();
546   }
547 
548 #if defined(ART_ENABLE_CODEGEN_arm) || defined(ART_ENABLE_CODEGEN_arm64)
VisitMultiplyAccumulate(HMultiplyAccumulate * instruction)549   void VisitMultiplyAccumulate(HMultiplyAccumulate* instruction) OVERRIDE {
550     StartAttributeStream("kind") << instruction->GetOpKind();
551   }
552 
VisitBitwiseNegatedRight(HBitwiseNegatedRight * instruction)553   void VisitBitwiseNegatedRight(HBitwiseNegatedRight* instruction) OVERRIDE {
554     StartAttributeStream("kind") << instruction->GetOpKind();
555   }
556 
VisitDataProcWithShifterOp(HDataProcWithShifterOp * instruction)557   void VisitDataProcWithShifterOp(HDataProcWithShifterOp* instruction) OVERRIDE {
558     StartAttributeStream("kind") << instruction->GetInstrKind() << "+" << instruction->GetOpKind();
559     if (HDataProcWithShifterOp::IsShiftOp(instruction->GetOpKind())) {
560       StartAttributeStream("shift") << instruction->GetShiftAmount();
561     }
562   }
563 #endif
564 
IsPass(const char * name)565   bool IsPass(const char* name) {
566     return strcmp(pass_name_, name) == 0;
567   }
568 
PrintInstruction(HInstruction * instruction)569   void PrintInstruction(HInstruction* instruction) {
570     output_ << instruction->DebugName();
571     HConstInputsRef inputs = instruction->GetInputs();
572     if (!inputs.empty()) {
573       StringList input_list;
574       for (const HInstruction* input : inputs) {
575         input_list.NewEntryStream() << DataType::TypeId(input->GetType()) << input->GetId();
576       }
577       StartAttributeStream() << input_list;
578     }
579     instruction->Accept(this);
580     if (instruction->HasEnvironment()) {
581       StringList envs;
582       for (HEnvironment* environment = instruction->GetEnvironment();
583            environment != nullptr;
584            environment = environment->GetParent()) {
585         StringList vregs;
586         for (size_t i = 0, e = environment->Size(); i < e; ++i) {
587           HInstruction* insn = environment->GetInstructionAt(i);
588           if (insn != nullptr) {
589             vregs.NewEntryStream() << DataType::TypeId(insn->GetType()) << insn->GetId();
590           } else {
591             vregs.NewEntryStream() << "_";
592           }
593         }
594         envs.NewEntryStream() << vregs;
595       }
596       StartAttributeStream("env") << envs;
597     }
598     if (IsPass(SsaLivenessAnalysis::kLivenessPassName)
599         && is_after_pass_
600         && instruction->GetLifetimePosition() != kNoLifetime) {
601       StartAttributeStream("liveness") << instruction->GetLifetimePosition();
602       if (instruction->HasLiveInterval()) {
603         LiveInterval* interval = instruction->GetLiveInterval();
604         StartAttributeStream("ranges")
605             << StringList(interval->GetFirstRange(), StringList::kSetBrackets);
606         StartAttributeStream("uses") << StringList(interval->GetUses());
607         StartAttributeStream("env_uses") << StringList(interval->GetEnvironmentUses());
608         StartAttributeStream("is_fixed") << interval->IsFixed();
609         StartAttributeStream("is_split") << interval->IsSplit();
610         StartAttributeStream("is_low") << interval->IsLowInterval();
611         StartAttributeStream("is_high") << interval->IsHighInterval();
612       }
613     }
614 
615     if (IsPass(RegisterAllocator::kRegisterAllocatorPassName) && is_after_pass_) {
616       StartAttributeStream("liveness") << instruction->GetLifetimePosition();
617       LocationSummary* locations = instruction->GetLocations();
618       if (locations != nullptr) {
619         StringList input_list;
620         for (size_t i = 0, e = locations->GetInputCount(); i < e; ++i) {
621           DumpLocation(input_list.NewEntryStream(), locations->InAt(i));
622         }
623         std::ostream& attr = StartAttributeStream("locations");
624         attr << input_list << "->";
625         DumpLocation(attr, locations->Out());
626       }
627     }
628 
629     HLoopInformation* loop_info = instruction->GetBlock()->GetLoopInformation();
630     if (loop_info == nullptr) {
631       StartAttributeStream("loop") << "none";
632     } else {
633       StartAttributeStream("loop") << "B" << loop_info->GetHeader()->GetBlockId();
634       HLoopInformation* outer = loop_info->GetPreHeader()->GetLoopInformation();
635       if (outer != nullptr) {
636         StartAttributeStream("outer_loop") << "B" << outer->GetHeader()->GetBlockId();
637       } else {
638         StartAttributeStream("outer_loop") << "none";
639       }
640       StartAttributeStream("irreducible")
641           << std::boolalpha << loop_info->IsIrreducible() << std::noboolalpha;
642     }
643 
644     if ((IsPass(HGraphBuilder::kBuilderPassName)
645         || IsPass(HInliner::kInlinerPassName))
646         && (instruction->GetType() == DataType::Type::kReference)) {
647       ReferenceTypeInfo info = instruction->IsLoadClass()
648         ? instruction->AsLoadClass()->GetLoadedClassRTI()
649         : instruction->GetReferenceTypeInfo();
650       ScopedObjectAccess soa(Thread::Current());
651       if (info.IsValid()) {
652         StartAttributeStream("klass")
653             << mirror::Class::PrettyDescriptor(info.GetTypeHandle().Get());
654         StartAttributeStream("can_be_null")
655             << std::boolalpha << instruction->CanBeNull() << std::noboolalpha;
656         StartAttributeStream("exact") << std::boolalpha << info.IsExact() << std::noboolalpha;
657       } else if (instruction->IsLoadClass()) {
658         StartAttributeStream("klass") << "unresolved";
659       } else {
660         // The NullConstant may be added to the graph during other passes that happen between
661         // ReferenceTypePropagation and Inliner (e.g. InstructionSimplifier). If the inliner
662         // doesn't run or doesn't inline anything, the NullConstant remains untyped.
663         // So we should check NullConstants for validity only after reference type propagation.
664         DCHECK(graph_in_bad_state_ ||
665                (!is_after_pass_ && IsPass(HGraphBuilder::kBuilderPassName)))
666             << instruction->DebugName() << instruction->GetId() << " has invalid rti "
667             << (is_after_pass_ ? "after" : "before") << " pass " << pass_name_;
668       }
669     }
670     if (disasm_info_ != nullptr) {
671       DCHECK(disassembler_ != nullptr);
672       // If the information is available, disassemble the code generated for
673       // this instruction.
674       auto it = disasm_info_->GetInstructionIntervals().find(instruction);
675       if (it != disasm_info_->GetInstructionIntervals().end()
676           && it->second.start != it->second.end) {
677         output_ << "\n";
678         disassembler_->Disassemble(output_, it->second.start, it->second.end);
679       }
680     }
681   }
682 
PrintInstructions(const HInstructionList & list)683   void PrintInstructions(const HInstructionList& list) {
684     for (HInstructionIterator it(list); !it.Done(); it.Advance()) {
685       HInstruction* instruction = it.Current();
686       int bci = 0;
687       size_t num_uses = instruction->GetUses().SizeSlow();
688       AddIndent();
689       output_ << bci << " " << num_uses << " "
690               << DataType::TypeId(instruction->GetType()) << instruction->GetId() << " ";
691       PrintInstruction(instruction);
692       output_ << " " << kEndInstructionMarker << "\n";
693     }
694   }
695 
DumpStartOfDisassemblyBlock(const char * block_name,int predecessor_index,int successor_index)696   void DumpStartOfDisassemblyBlock(const char* block_name,
697                                    int predecessor_index,
698                                    int successor_index) {
699     StartTag("block");
700     PrintProperty("name", block_name);
701     PrintInt("from_bci", -1);
702     PrintInt("to_bci", -1);
703     if (predecessor_index != -1) {
704       PrintProperty("predecessors", "B", predecessor_index);
705     } else {
706       PrintEmptyProperty("predecessors");
707     }
708     if (successor_index != -1) {
709       PrintProperty("successors", "B", successor_index);
710     } else {
711       PrintEmptyProperty("successors");
712     }
713     PrintEmptyProperty("xhandlers");
714     PrintEmptyProperty("flags");
715     StartTag("states");
716     StartTag("locals");
717     PrintInt("size", 0);
718     PrintProperty("method", "None");
719     EndTag("locals");
720     EndTag("states");
721     StartTag("HIR");
722   }
723 
DumpEndOfDisassemblyBlock()724   void DumpEndOfDisassemblyBlock() {
725     EndTag("HIR");
726     EndTag("block");
727   }
728 
DumpDisassemblyBlockForFrameEntry()729   void DumpDisassemblyBlockForFrameEntry() {
730     DumpStartOfDisassemblyBlock(kDisassemblyBlockFrameEntry,
731                                 -1,
732                                 GetGraph()->GetEntryBlock()->GetBlockId());
733     output_ << "    0 0 disasm " << kDisassemblyBlockFrameEntry << " ";
734     GeneratedCodeInterval frame_entry = disasm_info_->GetFrameEntryInterval();
735     if (frame_entry.start != frame_entry.end) {
736       output_ << "\n";
737       disassembler_->Disassemble(output_, frame_entry.start, frame_entry.end);
738     }
739     output_ << kEndInstructionMarker << "\n";
740     DumpEndOfDisassemblyBlock();
741   }
742 
DumpDisassemblyBlockForSlowPaths()743   void DumpDisassemblyBlockForSlowPaths() {
744     if (disasm_info_->GetSlowPathIntervals().empty()) {
745       return;
746     }
747     // If the graph has an exit block we attach the block for the slow paths
748     // after it. Else we just add the block to the graph without linking it to
749     // any other.
750     DumpStartOfDisassemblyBlock(
751         kDisassemblyBlockSlowPaths,
752         GetGraph()->HasExitBlock() ? GetGraph()->GetExitBlock()->GetBlockId() : -1,
753         -1);
754     for (SlowPathCodeInfo info : disasm_info_->GetSlowPathIntervals()) {
755       output_ << "    0 0 disasm " << info.slow_path->GetDescription() << "\n";
756       disassembler_->Disassemble(output_, info.code_interval.start, info.code_interval.end);
757       output_ << kEndInstructionMarker << "\n";
758     }
759     DumpEndOfDisassemblyBlock();
760   }
761 
Run()762   void Run() {
763     StartTag("cfg");
764     std::string pass_desc = std::string(pass_name_)
765                           + " ("
766                           + (is_after_pass_ ? "after" : "before")
767                           + (graph_in_bad_state_ ? ", bad_state" : "")
768                           + ")";
769     PrintProperty("name", pass_desc.c_str());
770     if (disasm_info_ != nullptr) {
771       DumpDisassemblyBlockForFrameEntry();
772     }
773     VisitInsertionOrder();
774     if (disasm_info_ != nullptr) {
775       DumpDisassemblyBlockForSlowPaths();
776     }
777     EndTag("cfg");
778     Flush();
779   }
780 
VisitBasicBlock(HBasicBlock * block)781   void VisitBasicBlock(HBasicBlock* block) OVERRIDE {
782     StartTag("block");
783     PrintProperty("name", "B", block->GetBlockId());
784     if (block->GetLifetimeStart() != kNoLifetime) {
785       // Piggy back on these fields to show the lifetime of the block.
786       PrintInt("from_bci", block->GetLifetimeStart());
787       PrintInt("to_bci", block->GetLifetimeEnd());
788     } else {
789       PrintInt("from_bci", -1);
790       PrintInt("to_bci", -1);
791     }
792     PrintPredecessors(block);
793     PrintSuccessors(block);
794     PrintExceptionHandlers(block);
795 
796     if (block->IsCatchBlock()) {
797       PrintProperty("flags", "catch_block");
798     } else {
799       PrintEmptyProperty("flags");
800     }
801 
802     if (block->GetDominator() != nullptr) {
803       PrintProperty("dominator", "B", block->GetDominator()->GetBlockId());
804     }
805 
806     StartTag("states");
807     StartTag("locals");
808     PrintInt("size", 0);
809     PrintProperty("method", "None");
810     for (HInstructionIterator it(block->GetPhis()); !it.Done(); it.Advance()) {
811       AddIndent();
812       HInstruction* instruction = it.Current();
813       output_ << instruction->GetId() << " " << DataType::TypeId(instruction->GetType())
814               << instruction->GetId() << "[ ";
815       for (const HInstruction* input : instruction->GetInputs()) {
816         output_ << input->GetId() << " ";
817       }
818       output_ << "]\n";
819     }
820     EndTag("locals");
821     EndTag("states");
822 
823     StartTag("HIR");
824     PrintInstructions(block->GetPhis());
825     PrintInstructions(block->GetInstructions());
826     EndTag("HIR");
827     EndTag("block");
828   }
829 
830   static constexpr const char* const kEndInstructionMarker = "<|@";
831   static constexpr const char* const kDisassemblyBlockFrameEntry = "FrameEntry";
832   static constexpr const char* const kDisassemblyBlockSlowPaths = "SlowPaths";
833 
834  private:
835   std::ostream& output_;
836   const char* pass_name_;
837   const bool is_after_pass_;
838   const bool graph_in_bad_state_;
839   const CodeGenerator& codegen_;
840   const DisassemblyInformation* disasm_info_;
841   std::unique_ptr<HGraphVisualizerDisassembler> disassembler_;
842   size_t indent_;
843 
844   DISALLOW_COPY_AND_ASSIGN(HGraphVisualizerPrinter);
845 };
846 
HGraphVisualizer(std::ostream * output,HGraph * graph,const CodeGenerator & codegen)847 HGraphVisualizer::HGraphVisualizer(std::ostream* output,
848                                    HGraph* graph,
849                                    const CodeGenerator& codegen)
850   : output_(output), graph_(graph), codegen_(codegen) {}
851 
PrintHeader(const char * method_name) const852 void HGraphVisualizer::PrintHeader(const char* method_name) const {
853   DCHECK(output_ != nullptr);
854   HGraphVisualizerPrinter printer(graph_, *output_, "", true, false, codegen_);
855   printer.StartTag("compilation");
856   printer.PrintProperty("name", method_name);
857   printer.PrintProperty("method", method_name);
858   printer.PrintTime("date");
859   printer.EndTag("compilation");
860   printer.Flush();
861 }
862 
DumpGraph(const char * pass_name,bool is_after_pass,bool graph_in_bad_state) const863 void HGraphVisualizer::DumpGraph(const char* pass_name,
864                                  bool is_after_pass,
865                                  bool graph_in_bad_state) const {
866   DCHECK(output_ != nullptr);
867   if (!graph_->GetBlocks().empty()) {
868     HGraphVisualizerPrinter printer(graph_,
869                                     *output_,
870                                     pass_name,
871                                     is_after_pass,
872                                     graph_in_bad_state,
873                                     codegen_);
874     printer.Run();
875   }
876 }
877 
DumpGraphWithDisassembly() const878 void HGraphVisualizer::DumpGraphWithDisassembly() const {
879   DCHECK(output_ != nullptr);
880   if (!graph_->GetBlocks().empty()) {
881     HGraphVisualizerPrinter printer(graph_,
882                                     *output_,
883                                     "disassembly",
884                                     /* is_after_pass */ true,
885                                     /* graph_in_bad_state */ false,
886                                     codegen_,
887                                     codegen_.GetDisassemblyInformation());
888     printer.Run();
889   }
890 }
891 
892 }  // namespace art
893