1 /*
2  * Copyright (C) 2011 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 "dex_instruction-inl.h"
18 
19 #include <inttypes.h>
20 
21 #include <iomanip>
22 #include <sstream>
23 
24 #include "android-base/stringprintf.h"
25 
26 #include "dex_file-inl.h"
27 #include "utf.h"
28 
29 namespace art {
30 
31 using android::base::StringPrintf;
32 
33 const char* const Instruction::kInstructionNames[] = {
34 #define INSTRUCTION_NAME(o, c, pname, f, i, a, e, v) pname,
35 #include "dex_instruction_list.h"
36   DEX_INSTRUCTION_LIST(INSTRUCTION_NAME)
37 #undef DEX_INSTRUCTION_LIST
38 #undef INSTRUCTION_NAME
39 };
40 
41 static_assert(sizeof(Instruction::InstructionDescriptor) == 8u, "Unexpected descriptor size");
42 
InstructionSizeInCodeUnitsByOpcode(Instruction::Code opcode,Instruction::Format format)43 static constexpr int8_t InstructionSizeInCodeUnitsByOpcode(Instruction::Code opcode,
44                                                            Instruction::Format format) {
45   if (opcode == Instruction::Code::NOP) {
46     return -1;
47   } else if ((format >= Instruction::Format::k10x) && (format <= Instruction::Format::k10t)) {
48     return 1;
49   } else if ((format >= Instruction::Format::k20t) && (format <= Instruction::Format::k22c)) {
50     return 2;
51   } else if ((format >= Instruction::Format::k32x) && (format <= Instruction::Format::k3rc)) {
52     return 3;
53   } else if ((format >= Instruction::Format::k45cc) && (format <= Instruction::Format::k4rcc)) {
54     return 4;
55   } else if (format == Instruction::Format::k51l) {
56     return 5;
57   } else {
58     return -1;
59   }
60 }
61 
62 Instruction::InstructionDescriptor const Instruction::kInstructionDescriptors[] = {
63 #define INSTRUCTION_DESCR(opcode, c, p, format, index, flags, eflags, vflags) \
64     { vflags, \
65       format, \
66       index, \
67       flags, \
68       InstructionSizeInCodeUnitsByOpcode((c), (format)), \
69     },
70 #include "dex_instruction_list.h"
71   DEX_INSTRUCTION_LIST(INSTRUCTION_DESCR)
72 #undef DEX_INSTRUCTION_LIST
73 #undef INSTRUCTION_DESCR
74 };
75 
GetTargetOffset() const76 int32_t Instruction::GetTargetOffset() const {
77   switch (FormatOf(Opcode())) {
78     // Cases for conditional branches follow.
79     case k22t: return VRegC_22t();
80     case k21t: return VRegB_21t();
81     // Cases for unconditional branches follow.
82     case k10t: return VRegA_10t();
83     case k20t: return VRegA_20t();
84     case k30t: return VRegA_30t();
85     default: LOG(FATAL) << "Tried to access the branch offset of an instruction " << Name() <<
86         " which does not have a target operand.";
87   }
88   UNREACHABLE();
89 }
90 
CanFlowThrough() const91 bool Instruction::CanFlowThrough() const {
92   const uint16_t* insns = reinterpret_cast<const uint16_t*>(this);
93   uint16_t insn = *insns;
94   Code opcode = static_cast<Code>(insn & 0xFF);
95   return  FlagsOf(opcode) & Instruction::kContinue;
96 }
97 
SizeInCodeUnitsComplexOpcode() const98 size_t Instruction::SizeInCodeUnitsComplexOpcode() const {
99   const uint16_t* insns = reinterpret_cast<const uint16_t*>(this);
100   // Handle special NOP encoded variable length sequences.
101   switch (*insns) {
102     case kPackedSwitchSignature:
103       return (4 + insns[1] * 2);
104     case kSparseSwitchSignature:
105       return (2 + insns[1] * 4);
106     case kArrayDataSignature: {
107       uint16_t element_size = insns[1];
108       uint32_t length = insns[2] | (((uint32_t)insns[3]) << 16);
109       // The plus 1 is to round up for odd size and width.
110       return (4 + (element_size * length + 1) / 2);
111     }
112     default:
113       if ((*insns & 0xFF) == 0) {
114         return 1;  // NOP.
115       } else {
116         LOG(FATAL) << "Unreachable: " << DumpString(nullptr);
117         UNREACHABLE();
118       }
119   }
120 }
121 
CodeUnitsRequiredForSizeOfComplexOpcode() const122 size_t Instruction::CodeUnitsRequiredForSizeOfComplexOpcode() const {
123   const uint16_t* insns = reinterpret_cast<const uint16_t*>(this);
124   // Handle special NOP encoded variable length sequences.
125   switch (*insns) {
126     case kPackedSwitchSignature:
127       FALLTHROUGH_INTENDED;
128     case kSparseSwitchSignature:
129       return 2;
130     case kArrayDataSignature:
131       return 4;
132     default:
133       if ((*insns & 0xFF) == 0) {
134         return 1;  // NOP.
135       } else {
136         LOG(FATAL) << "Unreachable: " << DumpString(nullptr);
137         UNREACHABLE();
138       }
139   }
140 }
141 
DumpHex(size_t code_units) const142 std::string Instruction::DumpHex(size_t code_units) const {
143   size_t inst_length = SizeInCodeUnits();
144   if (inst_length > code_units) {
145     inst_length = code_units;
146   }
147   std::ostringstream os;
148   const uint16_t* insn = reinterpret_cast<const uint16_t*>(this);
149   for (size_t i = 0; i < inst_length; i++) {
150     os << StringPrintf("0x%04x", insn[i]) << " ";
151   }
152   for (size_t i = inst_length; i < code_units; i++) {
153     os << "       ";
154   }
155   return os.str();
156 }
157 
DumpHexLE(size_t instr_code_units) const158 std::string Instruction::DumpHexLE(size_t instr_code_units) const {
159   size_t inst_length = SizeInCodeUnits();
160   if (inst_length > instr_code_units) {
161     inst_length = instr_code_units;
162   }
163   std::ostringstream os;
164   const uint16_t* insn = reinterpret_cast<const uint16_t*>(this);
165   for (size_t i = 0; i < inst_length; i++) {
166     os << StringPrintf("%02x%02x", static_cast<uint8_t>(insn[i] & 0x00FF),
167                        static_cast<uint8_t>((insn[i] & 0xFF00) >> 8)) << " ";
168   }
169   for (size_t i = inst_length; i < instr_code_units; i++) {
170     os << "     ";
171   }
172   return os.str();
173 }
174 
DumpString(const DexFile * file) const175 std::string Instruction::DumpString(const DexFile* file) const {
176   std::ostringstream os;
177   const char* opcode = kInstructionNames[Opcode()];
178   switch (FormatOf(Opcode())) {
179     case k10x:  os << opcode; break;
180     case k12x:  os << StringPrintf("%s v%d, v%d", opcode, VRegA_12x(), VRegB_12x()); break;
181     case k11n:  os << StringPrintf("%s v%d, #%+d", opcode, VRegA_11n(), VRegB_11n()); break;
182     case k11x:  os << StringPrintf("%s v%d", opcode, VRegA_11x()); break;
183     case k10t:  os << StringPrintf("%s %+d", opcode, VRegA_10t()); break;
184     case k20t:  os << StringPrintf("%s %+d", opcode, VRegA_20t()); break;
185     case k22x:  os << StringPrintf("%s v%d, v%d", opcode, VRegA_22x(), VRegB_22x()); break;
186     case k21t:  os << StringPrintf("%s v%d, %+d", opcode, VRegA_21t(), VRegB_21t()); break;
187     case k21s:  os << StringPrintf("%s v%d, #%+d", opcode, VRegA_21s(), VRegB_21s()); break;
188     case k21h: {
189         // op vAA, #+BBBB0000[00000000]
190         if (Opcode() == CONST_HIGH16) {
191           uint32_t value = VRegB_21h() << 16;
192           os << StringPrintf("%s v%d, #int %+d // 0x%x", opcode, VRegA_21h(), value, value);
193         } else {
194           uint64_t value = static_cast<uint64_t>(VRegB_21h()) << 48;
195           os << StringPrintf("%s v%d, #long %+" PRId64 " // 0x%" PRIx64, opcode, VRegA_21h(),
196                              value, value);
197         }
198       }
199       break;
200     case k21c: {
201       switch (Opcode()) {
202         case CONST_STRING:
203           if (file != nullptr) {
204             uint32_t string_idx = VRegB_21c();
205             if (string_idx < file->NumStringIds()) {
206               os << StringPrintf(
207                   "const-string v%d, %s // string@%d",
208                   VRegA_21c(),
209                   PrintableString(file->StringDataByIdx(dex::StringIndex(string_idx))).c_str(),
210                   string_idx);
211             } else {
212               os << StringPrintf("const-string v%d, <<invalid-string-idx-%d>> // string@%d",
213                                  VRegA_21c(),
214                                  string_idx,
215                                  string_idx);
216             }
217             break;
218           }
219           FALLTHROUGH_INTENDED;
220         case CHECK_CAST:
221         case CONST_CLASS:
222         case NEW_INSTANCE:
223           if (file != nullptr) {
224             dex::TypeIndex type_idx(VRegB_21c());
225             os << opcode << " v" << static_cast<int>(VRegA_21c()) << ", "
226                << file->PrettyType(type_idx) << " // type@" << type_idx;
227             break;
228           }
229           FALLTHROUGH_INTENDED;
230         case SGET:
231         case SGET_WIDE:
232         case SGET_OBJECT:
233         case SGET_BOOLEAN:
234         case SGET_BYTE:
235         case SGET_CHAR:
236         case SGET_SHORT:
237           if (file != nullptr) {
238             uint32_t field_idx = VRegB_21c();
239             os << opcode << "  v" << static_cast<int>(VRegA_21c()) << ", " << file->PrettyField(field_idx, true)
240                << " // field@" << field_idx;
241             break;
242           }
243           FALLTHROUGH_INTENDED;
244         case SPUT:
245         case SPUT_WIDE:
246         case SPUT_OBJECT:
247         case SPUT_BOOLEAN:
248         case SPUT_BYTE:
249         case SPUT_CHAR:
250         case SPUT_SHORT:
251           if (file != nullptr) {
252             uint32_t field_idx = VRegB_21c();
253             os << opcode << " v" << static_cast<int>(VRegA_21c()) << ", " << file->PrettyField(field_idx, true)
254                << " // field@" << field_idx;
255             break;
256           }
257           FALLTHROUGH_INTENDED;
258         default:
259           os << StringPrintf("%s v%d, thing@%d", opcode, VRegA_21c(), VRegB_21c());
260           break;
261       }
262       break;
263     }
264     case k23x:  os << StringPrintf("%s v%d, v%d, v%d", opcode, VRegA_23x(), VRegB_23x(), VRegC_23x()); break;
265     case k22b:  os << StringPrintf("%s v%d, v%d, #%+d", opcode, VRegA_22b(), VRegB_22b(), VRegC_22b()); break;
266     case k22t:  os << StringPrintf("%s v%d, v%d, %+d", opcode, VRegA_22t(), VRegB_22t(), VRegC_22t()); break;
267     case k22s:  os << StringPrintf("%s v%d, v%d, #%+d", opcode, VRegA_22s(), VRegB_22s(), VRegC_22s()); break;
268     case k22c: {
269       switch (Opcode()) {
270         case IGET:
271         case IGET_WIDE:
272         case IGET_OBJECT:
273         case IGET_BOOLEAN:
274         case IGET_BYTE:
275         case IGET_CHAR:
276         case IGET_SHORT:
277           if (file != nullptr) {
278             uint32_t field_idx = VRegC_22c();
279             os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", "
280                << file->PrettyField(field_idx, true) << " // field@" << field_idx;
281             break;
282           }
283           FALLTHROUGH_INTENDED;
284         case IGET_QUICK:
285         case IGET_OBJECT_QUICK:
286           if (file != nullptr) {
287             uint32_t field_idx = VRegC_22c();
288             os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", "
289                << "// offset@" << field_idx;
290             break;
291           }
292           FALLTHROUGH_INTENDED;
293         case IPUT:
294         case IPUT_WIDE:
295         case IPUT_OBJECT:
296         case IPUT_BOOLEAN:
297         case IPUT_BYTE:
298         case IPUT_CHAR:
299         case IPUT_SHORT:
300           if (file != nullptr) {
301             uint32_t field_idx = VRegC_22c();
302             os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", "
303                << file->PrettyField(field_idx, true) << " // field@" << field_idx;
304             break;
305           }
306           FALLTHROUGH_INTENDED;
307         case IPUT_QUICK:
308         case IPUT_OBJECT_QUICK:
309           if (file != nullptr) {
310             uint32_t field_idx = VRegC_22c();
311             os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v" << static_cast<int>(VRegB_22c()) << ", "
312                << "// offset@" << field_idx;
313             break;
314           }
315           FALLTHROUGH_INTENDED;
316         case INSTANCE_OF:
317           if (file != nullptr) {
318             dex::TypeIndex type_idx(VRegC_22c());
319             os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v"
320                << static_cast<int>(VRegB_22c()) << ", " << file->PrettyType(type_idx)
321                << " // type@" << type_idx.index_;
322             break;
323           }
324           FALLTHROUGH_INTENDED;
325         case NEW_ARRAY:
326           if (file != nullptr) {
327             dex::TypeIndex type_idx(VRegC_22c());
328             os << opcode << " v" << static_cast<int>(VRegA_22c()) << ", v"
329                << static_cast<int>(VRegB_22c()) << ", " << file->PrettyType(type_idx)
330                << " // type@" << type_idx.index_;
331             break;
332           }
333           FALLTHROUGH_INTENDED;
334         default:
335           os << StringPrintf("%s v%d, v%d, thing@%d", opcode, VRegA_22c(), VRegB_22c(), VRegC_22c());
336           break;
337       }
338       break;
339     }
340     case k32x:  os << StringPrintf("%s v%d, v%d", opcode, VRegA_32x(), VRegB_32x()); break;
341     case k30t:  os << StringPrintf("%s %+d", opcode, VRegA_30t()); break;
342     case k31t:  os << StringPrintf("%s v%d, %+d", opcode, VRegA_31t(), VRegB_31t()); break;
343     case k31i:  os << StringPrintf("%s v%d, #%+d", opcode, VRegA_31i(), VRegB_31i()); break;
344     case k31c:
345       if (Opcode() == CONST_STRING_JUMBO) {
346         uint32_t string_idx = VRegB_31c();
347         if (file != nullptr) {
348           if (string_idx < file->NumStringIds()) {
349             os << StringPrintf(
350                 "%s v%d, %s // string@%d",
351                 opcode,
352                 VRegA_31c(),
353                 PrintableString(file->StringDataByIdx(dex::StringIndex(string_idx))).c_str(),
354                 string_idx);
355           } else {
356             os << StringPrintf("%s v%d, <<invalid-string-idx-%d>> // string@%d",
357                                opcode,
358                                VRegA_31c(),
359                                string_idx,
360                                string_idx);
361           }
362         } else {
363           os << StringPrintf("%s v%d, string@%d", opcode, VRegA_31c(), string_idx);
364         }
365       } else {
366         os << StringPrintf("%s v%d, thing@%d", opcode, VRegA_31c(), VRegB_31c()); break;
367       }
368       break;
369     case k35c: {
370       uint32_t arg[kMaxVarArgRegs];
371       GetVarArgs(arg);
372       auto DumpArgs = [&](size_t count) {
373         for (size_t i = 0; i < count; ++i) {
374           if (i != 0) {
375             os << ", ";
376           }
377           os << "v" << arg[i];
378         }
379       };
380       switch (Opcode()) {
381         case FILLED_NEW_ARRAY:
382         {
383           os << opcode << " {";
384           DumpArgs(VRegA_35c());
385           os << "}, type@" << VRegB_35c();
386         }
387         break;
388 
389         case INVOKE_VIRTUAL:
390         case INVOKE_SUPER:
391         case INVOKE_DIRECT:
392         case INVOKE_STATIC:
393         case INVOKE_INTERFACE:
394           if (file != nullptr) {
395             os << opcode << " {";
396             uint32_t method_idx = VRegB_35c();
397             DumpArgs(VRegA_35c());
398             os << "}, " << file->PrettyMethod(method_idx) << " // method@" << method_idx;
399             break;
400           }
401           FALLTHROUGH_INTENDED;
402         case INVOKE_VIRTUAL_QUICK:
403           if (file != nullptr) {
404             os << opcode << " {";
405             uint32_t vtable_offset = VRegB_35c();
406             DumpArgs(VRegA_35c());
407             os << "},  // vtable@" << vtable_offset;
408             break;
409           }
410           FALLTHROUGH_INTENDED;
411         case INVOKE_CUSTOM:
412           if (file != nullptr) {
413             os << opcode << " {";
414             uint32_t call_site_idx = VRegB_35c();
415             DumpArgs(VRegA_35c());
416             os << "},  // call_site@" << call_site_idx;
417             break;
418           }
419           FALLTHROUGH_INTENDED;
420         default:
421           os << opcode << " {";
422           DumpArgs(VRegA_35c());
423           os << "}, thing@" << VRegB_35c();
424           break;
425       }
426       break;
427     }
428     case k3rc: {
429       uint16_t first_reg = VRegC_3rc();
430       uint16_t last_reg =  VRegC_3rc() + VRegA_3rc() - 1;
431       switch (Opcode()) {
432         case INVOKE_VIRTUAL_RANGE:
433         case INVOKE_SUPER_RANGE:
434         case INVOKE_DIRECT_RANGE:
435         case INVOKE_STATIC_RANGE:
436         case INVOKE_INTERFACE_RANGE:
437           if (file != nullptr) {
438             uint32_t method_idx = VRegB_3rc();
439             os << StringPrintf("%s, {v%d .. v%d}, ", opcode, first_reg, last_reg)
440                << file->PrettyMethod(method_idx) << " // method@" << method_idx;
441             break;
442           }
443           FALLTHROUGH_INTENDED;
444         case INVOKE_VIRTUAL_RANGE_QUICK:
445           if (file != nullptr) {
446             uint32_t method_idx = VRegB_3rc();
447             os << StringPrintf("%s, {v%d .. v%d}, ", opcode, first_reg, last_reg)
448                << "// vtable@" << method_idx;
449             break;
450           }
451           FALLTHROUGH_INTENDED;
452         case INVOKE_CUSTOM_RANGE:
453           if (file != nullptr) {
454             uint32_t call_site_idx = VRegB_3rc();
455             os << StringPrintf("%s, {v%d .. v%d}, ", opcode, first_reg, last_reg)
456                << "// call_site@" << call_site_idx;
457             break;
458           }
459           FALLTHROUGH_INTENDED;
460         default:
461           os << StringPrintf("%s, {v%d .. v%d}, ", opcode, first_reg, last_reg)
462              << "thing@" << VRegB_3rc();
463           break;
464       }
465       break;
466     }
467     case k45cc: {
468       uint32_t arg[kMaxVarArgRegs];
469       GetVarArgs(arg);
470       uint16_t method_idx = VRegB_45cc();
471       dex::ProtoIndex proto_idx(VRegH_45cc());
472       os << opcode << " {";
473       for (uint32_t i = 0; i < VRegA_45cc(); ++i) {
474         if (i != 0) {
475           os << ", ";
476         }
477         os << "v" << arg[i];
478       }
479       os << "}";
480       if (file != nullptr) {
481         os << ", " << file->PrettyMethod(method_idx)
482            << ", " << file->GetShorty(proto_idx)
483            << " // ";
484       } else {
485         os << ", ";
486       }
487       os << "method@" << method_idx << ", proto@" << proto_idx;
488       break;
489     }
490     case k4rcc:
491       switch (Opcode()) {
492         case INVOKE_POLYMORPHIC_RANGE: {
493           if (file != nullptr) {
494             uint16_t method_idx = VRegB_4rcc();
495             dex::ProtoIndex proto_idx(VRegH_4rcc());
496             os << opcode << ", {v" << VRegC_4rcc() << " .. v" << (VRegC_4rcc() + VRegA_4rcc())
497                << "}, " << file->PrettyMethod(method_idx)
498                << ", " << file->GetShorty(dex::ProtoIndex(proto_idx))
499                << " // method@" << method_idx << ", proto@" << proto_idx;
500             break;
501           }
502         }
503         FALLTHROUGH_INTENDED;
504         default: {
505           uint16_t method_idx = VRegB_4rcc();
506           dex::ProtoIndex proto_idx(VRegH_4rcc());
507           os << opcode << ", {v" << VRegC_4rcc() << " .. v" << (VRegC_4rcc() + VRegA_4rcc())
508              << "}, method@" << method_idx << ", proto@" << proto_idx;
509         }
510       }
511       break;
512     case k51l: os << StringPrintf("%s v%d, #%+" PRId64, opcode, VRegA_51l(), VRegB_51l()); break;
513     case kInvalidFormat: os << "<invalid-opcode-format>";
514   }
515   return os.str();
516 }
517 
518 // Add some checks that ensure the flags make sense. We need a subclass to be in the context of
519 // Instruction. Otherwise the flags from the instruction list don't work.
520 struct InstructionStaticAsserts : private Instruction {
521   #define IMPLIES(a, b) (!(a) || (b))
522 
523   #define VAR_ARGS_CHECK(o, c, pname, f, i, a, e, v) \
524     static_assert(IMPLIES((f) == k35c || (f) == k45cc, \
525                           ((v) & (kVerifyVarArg | kVerifyVarArgNonZero)) != 0), \
526                   "Missing var-arg verification");
527   #include "dex_instruction_list.h"
528     DEX_INSTRUCTION_LIST(VAR_ARGS_CHECK)
529   #undef DEX_INSTRUCTION_LIST
530   #undef VAR_ARGS_CHECK
531 
532   #define VAR_ARGS_RANGE_CHECK(o, c, pname, f, i, a, e, v) \
533     static_assert(IMPLIES((f) == k3rc || (f) == k4rcc, \
534                           ((v) & (kVerifyVarArgRange | kVerifyVarArgRangeNonZero)) != 0), \
535                   "Missing var-arg verification");
536   #include "dex_instruction_list.h"
537     DEX_INSTRUCTION_LIST(VAR_ARGS_RANGE_CHECK)
538   #undef DEX_INSTRUCTION_LIST
539   #undef VAR_ARGS_RANGE_CHECK
540 
541   #define EXPERIMENTAL_CHECK(o, c, pname, f, i, a, e, v) \
542     static_assert(kHaveExperimentalInstructions || (((a) & kExperimental) == 0), \
543                   "Unexpected experimental instruction.");
544     #include "dex_instruction_list.h"
545   DEX_INSTRUCTION_LIST(EXPERIMENTAL_CHECK)
546   #undef DEX_INSTRUCTION_LIST
547   #undef EXPERIMENTAL_CHECK
548 };
549 
operator <<(std::ostream & os,Instruction::Code code)550 std::ostream& operator<<(std::ostream& os, Instruction::Code code) {
551   return os << Instruction::Name(code);
552 }
553 
GetOperand(size_t operand_index) const554 uint32_t RangeInstructionOperands::GetOperand(size_t operand_index) const {
555   DCHECK_LT(operand_index, GetNumberOfOperands());
556   return first_operand_ + operand_index;
557 }
558 
GetOperand(size_t operand_index) const559 uint32_t VarArgsInstructionOperands::GetOperand(size_t operand_index) const {
560   DCHECK_LT(operand_index, GetNumberOfOperands());
561   return operands_[operand_index];
562 }
563 
GetOperand(size_t operand_index) const564 uint32_t NoReceiverInstructionOperands::GetOperand(size_t operand_index) const {
565   DCHECK_LT(GetNumberOfOperands(), inner_->GetNumberOfOperands());
566   // The receiver is the first operand and since we're skipping it, we need to
567   // add 1 to the operand_index.
568   return inner_->GetOperand(operand_index + 1);
569 }
570 
571 }  // namespace art
572