1 // Copyright 2013 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "src/arm64/instrument-arm64.h"
6 
7 namespace v8 {
8 namespace internal {
9 
Counter(const char * name,CounterType type)10 Counter::Counter(const char* name, CounterType type)
11     : count_(0), enabled_(false), type_(type) {
12   DCHECK(name != NULL);
13   strncpy(name_, name, kCounterNameMaxLength);
14 }
15 
16 
Enable()17 void Counter::Enable() {
18   enabled_ = true;
19 }
20 
21 
Disable()22 void Counter::Disable() {
23   enabled_ = false;
24 }
25 
26 
IsEnabled()27 bool Counter::IsEnabled() {
28   return enabled_;
29 }
30 
31 
Increment()32 void Counter::Increment() {
33   if (enabled_) {
34     count_++;
35   }
36 }
37 
38 
count()39 uint64_t Counter::count() {
40   uint64_t result = count_;
41   if (type_ == Gauge) {
42     // If the counter is a Gauge, reset the count after reading.
43     count_ = 0;
44   }
45   return result;
46 }
47 
48 
name()49 const char* Counter::name() {
50   return name_;
51 }
52 
53 
type()54 CounterType Counter::type() {
55   return type_;
56 }
57 
58 
59 typedef struct {
60   const char* name;
61   CounterType type;
62 } CounterDescriptor;
63 
64 
65 static const CounterDescriptor kCounterList[] = {
66   {"Instruction", Cumulative},
67 
68   {"Move Immediate", Gauge},
69   {"Add/Sub DP", Gauge},
70   {"Logical DP", Gauge},
71   {"Other Int DP", Gauge},
72   {"FP DP", Gauge},
73 
74   {"Conditional Select", Gauge},
75   {"Conditional Compare", Gauge},
76 
77   {"Unconditional Branch", Gauge},
78   {"Compare and Branch", Gauge},
79   {"Test and Branch", Gauge},
80   {"Conditional Branch", Gauge},
81 
82   {"Load Integer", Gauge},
83   {"Load FP", Gauge},
84   {"Load Pair", Gauge},
85   {"Load Literal", Gauge},
86 
87   {"Store Integer", Gauge},
88   {"Store FP", Gauge},
89   {"Store Pair", Gauge},
90 
91   {"PC Addressing", Gauge},
92   {"Other", Gauge},
93   {"SP Adjust", Gauge},
94 };
95 
96 
Instrument(const char * datafile,uint64_t sample_period)97 Instrument::Instrument(const char* datafile, uint64_t sample_period)
98     : output_stream_(stderr), sample_period_(sample_period) {
99 
100   // Set up the output stream. If datafile is non-NULL, use that file. If it
101   // can't be opened, or datafile is NULL, use stderr.
102   if (datafile != NULL) {
103     output_stream_ = fopen(datafile, "w");
104     if (output_stream_ == NULL) {
105       fprintf(stderr, "Can't open output file %s. Using stderr.\n", datafile);
106       output_stream_ = stderr;
107     }
108   }
109 
110   static const int num_counters = arraysize(kCounterList);
111 
112   // Dump an instrumentation description comment at the top of the file.
113   fprintf(output_stream_, "# counters=%d\n", num_counters);
114   fprintf(output_stream_, "# sample_period=%" PRIu64 "\n", sample_period_);
115 
116   // Construct Counter objects from counter description array.
117   for (int i = 0; i < num_counters; i++) {
118     Counter* counter = new Counter(kCounterList[i].name, kCounterList[i].type);
119     counters_.push_back(counter);
120   }
121 
122   DumpCounterNames();
123 }
124 
125 
~Instrument()126 Instrument::~Instrument() {
127   // Dump any remaining instruction data to the output file.
128   DumpCounters();
129 
130   // Free all the counter objects.
131   std::list<Counter*>::iterator it;
132   for (it = counters_.begin(); it != counters_.end(); it++) {
133     delete *it;
134   }
135 
136   if (output_stream_ != stderr) {
137     fclose(output_stream_);
138   }
139 }
140 
141 
Update()142 void Instrument::Update() {
143   // Increment the instruction counter, and dump all counters if a sample period
144   // has elapsed.
145   static Counter* counter = GetCounter("Instruction");
146   DCHECK(counter->type() == Cumulative);
147   counter->Increment();
148 
149   if (counter->IsEnabled() && (counter->count() % sample_period_) == 0) {
150     DumpCounters();
151   }
152 }
153 
154 
DumpCounters()155 void Instrument::DumpCounters() {
156   // Iterate through the counter objects, dumping their values to the output
157   // stream.
158   std::list<Counter*>::const_iterator it;
159   for (it = counters_.begin(); it != counters_.end(); it++) {
160     fprintf(output_stream_, "%" PRIu64 ",", (*it)->count());
161   }
162   fprintf(output_stream_, "\n");
163   fflush(output_stream_);
164 }
165 
166 
DumpCounterNames()167 void Instrument::DumpCounterNames() {
168   // Iterate through the counter objects, dumping the counter names to the
169   // output stream.
170   std::list<Counter*>::const_iterator it;
171   for (it = counters_.begin(); it != counters_.end(); it++) {
172     fprintf(output_stream_, "%s,", (*it)->name());
173   }
174   fprintf(output_stream_, "\n");
175   fflush(output_stream_);
176 }
177 
178 
HandleInstrumentationEvent(unsigned event)179 void Instrument::HandleInstrumentationEvent(unsigned event) {
180   switch (event) {
181     case InstrumentStateEnable: Enable(); break;
182     case InstrumentStateDisable: Disable(); break;
183     default: DumpEventMarker(event);
184   }
185 }
186 
187 
DumpEventMarker(unsigned marker)188 void Instrument::DumpEventMarker(unsigned marker) {
189   // Dumpan event marker to the output stream as a specially formatted comment
190   // line.
191   static Counter* counter = GetCounter("Instruction");
192 
193   fprintf(output_stream_, "# %c%c @ %" PRId64 "\n", marker & 0xff,
194           (marker >> 8) & 0xff, counter->count());
195 }
196 
197 
GetCounter(const char * name)198 Counter* Instrument::GetCounter(const char* name) {
199   // Get a Counter object by name from the counter list.
200   std::list<Counter*>::const_iterator it;
201   for (it = counters_.begin(); it != counters_.end(); it++) {
202     if (strcmp((*it)->name(), name) == 0) {
203       return *it;
204     }
205   }
206 
207   // A Counter by that name does not exist: print an error message to stderr
208   // and the output file, and exit.
209   static const char* error_message =
210     "# Error: Unknown counter \"%s\". Exiting.\n";
211   fprintf(stderr, error_message, name);
212   fprintf(output_stream_, error_message, name);
213   exit(1);
214 }
215 
216 
Enable()217 void Instrument::Enable() {
218   std::list<Counter*>::iterator it;
219   for (it = counters_.begin(); it != counters_.end(); it++) {
220     (*it)->Enable();
221   }
222 }
223 
224 
Disable()225 void Instrument::Disable() {
226   std::list<Counter*>::iterator it;
227   for (it = counters_.begin(); it != counters_.end(); it++) {
228     (*it)->Disable();
229   }
230 }
231 
232 
VisitPCRelAddressing(Instruction * instr)233 void Instrument::VisitPCRelAddressing(Instruction* instr) {
234   Update();
235   static Counter* counter = GetCounter("PC Addressing");
236   counter->Increment();
237 }
238 
239 
VisitAddSubImmediate(Instruction * instr)240 void Instrument::VisitAddSubImmediate(Instruction* instr) {
241   Update();
242   static Counter* sp_counter = GetCounter("SP Adjust");
243   static Counter* add_sub_counter = GetCounter("Add/Sub DP");
244   if (((instr->Mask(AddSubOpMask) == SUB) ||
245        (instr->Mask(AddSubOpMask) == ADD)) &&
246       (instr->Rd() == 31) && (instr->Rn() == 31)) {
247     // Count adjustments to the C stack pointer caused by V8 needing two SPs.
248     sp_counter->Increment();
249   } else {
250     add_sub_counter->Increment();
251   }
252 }
253 
254 
VisitLogicalImmediate(Instruction * instr)255 void Instrument::VisitLogicalImmediate(Instruction* instr) {
256   Update();
257   static Counter* counter = GetCounter("Logical DP");
258   counter->Increment();
259 }
260 
261 
VisitMoveWideImmediate(Instruction * instr)262 void Instrument::VisitMoveWideImmediate(Instruction* instr) {
263   Update();
264   static Counter* counter = GetCounter("Move Immediate");
265 
266   if (instr->IsMovn() && (instr->Rd() == kZeroRegCode)) {
267     unsigned imm = instr->ImmMoveWide();
268     HandleInstrumentationEvent(imm);
269   } else {
270     counter->Increment();
271   }
272 }
273 
274 
VisitBitfield(Instruction * instr)275 void Instrument::VisitBitfield(Instruction* instr) {
276   Update();
277   static Counter* counter = GetCounter("Other Int DP");
278   counter->Increment();
279 }
280 
281 
VisitExtract(Instruction * instr)282 void Instrument::VisitExtract(Instruction* instr) {
283   Update();
284   static Counter* counter = GetCounter("Other Int DP");
285   counter->Increment();
286 }
287 
288 
VisitUnconditionalBranch(Instruction * instr)289 void Instrument::VisitUnconditionalBranch(Instruction* instr) {
290   Update();
291   static Counter* counter = GetCounter("Unconditional Branch");
292   counter->Increment();
293 }
294 
295 
VisitUnconditionalBranchToRegister(Instruction * instr)296 void Instrument::VisitUnconditionalBranchToRegister(Instruction* instr) {
297   Update();
298   static Counter* counter = GetCounter("Unconditional Branch");
299   counter->Increment();
300 }
301 
302 
VisitCompareBranch(Instruction * instr)303 void Instrument::VisitCompareBranch(Instruction* instr) {
304   Update();
305   static Counter* counter = GetCounter("Compare and Branch");
306   counter->Increment();
307 }
308 
309 
VisitTestBranch(Instruction * instr)310 void Instrument::VisitTestBranch(Instruction* instr) {
311   Update();
312   static Counter* counter = GetCounter("Test and Branch");
313   counter->Increment();
314 }
315 
316 
VisitConditionalBranch(Instruction * instr)317 void Instrument::VisitConditionalBranch(Instruction* instr) {
318   Update();
319   static Counter* counter = GetCounter("Conditional Branch");
320   counter->Increment();
321 }
322 
323 
VisitSystem(Instruction * instr)324 void Instrument::VisitSystem(Instruction* instr) {
325   Update();
326   static Counter* counter = GetCounter("Other");
327   counter->Increment();
328 }
329 
330 
VisitException(Instruction * instr)331 void Instrument::VisitException(Instruction* instr) {
332   Update();
333   static Counter* counter = GetCounter("Other");
334   counter->Increment();
335 }
336 
337 
InstrumentLoadStorePair(Instruction * instr)338 void Instrument::InstrumentLoadStorePair(Instruction* instr) {
339   static Counter* load_pair_counter = GetCounter("Load Pair");
340   static Counter* store_pair_counter = GetCounter("Store Pair");
341   if (instr->Mask(LoadStorePairLBit) != 0) {
342     load_pair_counter->Increment();
343   } else {
344     store_pair_counter->Increment();
345   }
346 }
347 
348 
VisitLoadStorePairPostIndex(Instruction * instr)349 void Instrument::VisitLoadStorePairPostIndex(Instruction* instr) {
350   Update();
351   InstrumentLoadStorePair(instr);
352 }
353 
354 
VisitLoadStorePairOffset(Instruction * instr)355 void Instrument::VisitLoadStorePairOffset(Instruction* instr) {
356   Update();
357   InstrumentLoadStorePair(instr);
358 }
359 
360 
VisitLoadStorePairPreIndex(Instruction * instr)361 void Instrument::VisitLoadStorePairPreIndex(Instruction* instr) {
362   Update();
363   InstrumentLoadStorePair(instr);
364 }
365 
366 
VisitLoadLiteral(Instruction * instr)367 void Instrument::VisitLoadLiteral(Instruction* instr) {
368   Update();
369   static Counter* counter = GetCounter("Load Literal");
370   counter->Increment();
371 }
372 
373 
InstrumentLoadStore(Instruction * instr)374 void Instrument::InstrumentLoadStore(Instruction* instr) {
375   static Counter* load_int_counter = GetCounter("Load Integer");
376   static Counter* store_int_counter = GetCounter("Store Integer");
377   static Counter* load_fp_counter = GetCounter("Load FP");
378   static Counter* store_fp_counter = GetCounter("Store FP");
379 
380   switch (instr->Mask(LoadStoreOpMask)) {
381     case STRB_w:    // Fall through.
382     case STRH_w:    // Fall through.
383     case STR_w:     // Fall through.
384     case STR_x:     store_int_counter->Increment(); break;
385     case STR_s:     // Fall through.
386     case STR_d:     store_fp_counter->Increment(); break;
387     case LDRB_w:    // Fall through.
388     case LDRH_w:    // Fall through.
389     case LDR_w:     // Fall through.
390     case LDR_x:     // Fall through.
391     case LDRSB_x:   // Fall through.
392     case LDRSH_x:   // Fall through.
393     case LDRSW_x:   // Fall through.
394     case LDRSB_w:   // Fall through.
395     case LDRSH_w:   load_int_counter->Increment(); break;
396     case LDR_s:     // Fall through.
397     case LDR_d:     load_fp_counter->Increment(); break;
398     default: UNREACHABLE();
399   }
400 }
401 
402 
VisitLoadStoreUnscaledOffset(Instruction * instr)403 void Instrument::VisitLoadStoreUnscaledOffset(Instruction* instr) {
404   Update();
405   InstrumentLoadStore(instr);
406 }
407 
408 
VisitLoadStorePostIndex(Instruction * instr)409 void Instrument::VisitLoadStorePostIndex(Instruction* instr) {
410   Update();
411   InstrumentLoadStore(instr);
412 }
413 
414 
VisitLoadStorePreIndex(Instruction * instr)415 void Instrument::VisitLoadStorePreIndex(Instruction* instr) {
416   Update();
417   InstrumentLoadStore(instr);
418 }
419 
420 
VisitLoadStoreRegisterOffset(Instruction * instr)421 void Instrument::VisitLoadStoreRegisterOffset(Instruction* instr) {
422   Update();
423   InstrumentLoadStore(instr);
424 }
425 
426 
VisitLoadStoreUnsignedOffset(Instruction * instr)427 void Instrument::VisitLoadStoreUnsignedOffset(Instruction* instr) {
428   Update();
429   InstrumentLoadStore(instr);
430 }
431 
432 
VisitLogicalShifted(Instruction * instr)433 void Instrument::VisitLogicalShifted(Instruction* instr) {
434   Update();
435   static Counter* counter = GetCounter("Logical DP");
436   counter->Increment();
437 }
438 
439 
VisitAddSubShifted(Instruction * instr)440 void Instrument::VisitAddSubShifted(Instruction* instr) {
441   Update();
442   static Counter* counter = GetCounter("Add/Sub DP");
443   counter->Increment();
444 }
445 
446 
VisitAddSubExtended(Instruction * instr)447 void Instrument::VisitAddSubExtended(Instruction* instr) {
448   Update();
449   static Counter* sp_counter = GetCounter("SP Adjust");
450   static Counter* add_sub_counter = GetCounter("Add/Sub DP");
451   if (((instr->Mask(AddSubOpMask) == SUB) ||
452        (instr->Mask(AddSubOpMask) == ADD)) &&
453       (instr->Rd() == 31) && (instr->Rn() == 31)) {
454     // Count adjustments to the C stack pointer caused by V8 needing two SPs.
455     sp_counter->Increment();
456   } else {
457     add_sub_counter->Increment();
458   }
459 }
460 
461 
VisitAddSubWithCarry(Instruction * instr)462 void Instrument::VisitAddSubWithCarry(Instruction* instr) {
463   Update();
464   static Counter* counter = GetCounter("Add/Sub DP");
465   counter->Increment();
466 }
467 
468 
VisitConditionalCompareRegister(Instruction * instr)469 void Instrument::VisitConditionalCompareRegister(Instruction* instr) {
470   Update();
471   static Counter* counter = GetCounter("Conditional Compare");
472   counter->Increment();
473 }
474 
475 
VisitConditionalCompareImmediate(Instruction * instr)476 void Instrument::VisitConditionalCompareImmediate(Instruction* instr) {
477   Update();
478   static Counter* counter = GetCounter("Conditional Compare");
479   counter->Increment();
480 }
481 
482 
VisitConditionalSelect(Instruction * instr)483 void Instrument::VisitConditionalSelect(Instruction* instr) {
484   Update();
485   static Counter* counter = GetCounter("Conditional Select");
486   counter->Increment();
487 }
488 
489 
VisitDataProcessing1Source(Instruction * instr)490 void Instrument::VisitDataProcessing1Source(Instruction* instr) {
491   Update();
492   static Counter* counter = GetCounter("Other Int DP");
493   counter->Increment();
494 }
495 
496 
VisitDataProcessing2Source(Instruction * instr)497 void Instrument::VisitDataProcessing2Source(Instruction* instr) {
498   Update();
499   static Counter* counter = GetCounter("Other Int DP");
500   counter->Increment();
501 }
502 
503 
VisitDataProcessing3Source(Instruction * instr)504 void Instrument::VisitDataProcessing3Source(Instruction* instr) {
505   Update();
506   static Counter* counter = GetCounter("Other Int DP");
507   counter->Increment();
508 }
509 
510 
VisitFPCompare(Instruction * instr)511 void Instrument::VisitFPCompare(Instruction* instr) {
512   Update();
513   static Counter* counter = GetCounter("FP DP");
514   counter->Increment();
515 }
516 
517 
VisitFPConditionalCompare(Instruction * instr)518 void Instrument::VisitFPConditionalCompare(Instruction* instr) {
519   Update();
520   static Counter* counter = GetCounter("Conditional Compare");
521   counter->Increment();
522 }
523 
524 
VisitFPConditionalSelect(Instruction * instr)525 void Instrument::VisitFPConditionalSelect(Instruction* instr) {
526   Update();
527   static Counter* counter = GetCounter("Conditional Select");
528   counter->Increment();
529 }
530 
531 
VisitFPImmediate(Instruction * instr)532 void Instrument::VisitFPImmediate(Instruction* instr) {
533   Update();
534   static Counter* counter = GetCounter("FP DP");
535   counter->Increment();
536 }
537 
538 
VisitFPDataProcessing1Source(Instruction * instr)539 void Instrument::VisitFPDataProcessing1Source(Instruction* instr) {
540   Update();
541   static Counter* counter = GetCounter("FP DP");
542   counter->Increment();
543 }
544 
545 
VisitFPDataProcessing2Source(Instruction * instr)546 void Instrument::VisitFPDataProcessing2Source(Instruction* instr) {
547   Update();
548   static Counter* counter = GetCounter("FP DP");
549   counter->Increment();
550 }
551 
552 
VisitFPDataProcessing3Source(Instruction * instr)553 void Instrument::VisitFPDataProcessing3Source(Instruction* instr) {
554   Update();
555   static Counter* counter = GetCounter("FP DP");
556   counter->Increment();
557 }
558 
559 
VisitFPIntegerConvert(Instruction * instr)560 void Instrument::VisitFPIntegerConvert(Instruction* instr) {
561   Update();
562   static Counter* counter = GetCounter("FP DP");
563   counter->Increment();
564 }
565 
566 
VisitFPFixedPointConvert(Instruction * instr)567 void Instrument::VisitFPFixedPointConvert(Instruction* instr) {
568   Update();
569   static Counter* counter = GetCounter("FP DP");
570   counter->Increment();
571 }
572 
573 
VisitUnallocated(Instruction * instr)574 void Instrument::VisitUnallocated(Instruction* instr) {
575   Update();
576   static Counter* counter = GetCounter("Other");
577   counter->Increment();
578 }
579 
580 
VisitUnimplemented(Instruction * instr)581 void Instrument::VisitUnimplemented(Instruction* instr) {
582   Update();
583   static Counter* counter = GetCounter("Other");
584   counter->Increment();
585 }
586 
587 
588 }  // namespace internal
589 }  // namespace v8
590