InstrUtils.cpp revision ab35b50311951feea3782151dd5422ee944685c2
1/* 2 * Copyright (C) 2008 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/* 18 * Dalvik instruction utility functions. 19 * 20 * IMPORTANT NOTE: Much of the contents of this file are generated 21 * automatically by the opcode-gen tool. Any edits to the generated 22 * sections will get wiped out the next time the tool is run. 23 */ 24 25#include "InstrUtils.h" 26#include <stdlib.h> 27 28/* 29 * Table that maps each opcode to the full width of instructions that 30 * use that opcode, in (16-bit) code units. Unimplemented opcodes as 31 * well as the "breakpoint" opcode have a width of zero. 32 */ 33static InstructionWidth gInstructionWidthTable[kNumPackedOpcodes] = { 34 // BEGIN(libdex-widths); GENERATED AUTOMATICALLY BY opcode-gen 35 1, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 1, 1, 1, 1, 36 1, 1, 1, 2, 3, 2, 2, 3, 5, 2, 2, 3, 2, 1, 1, 2, 37 2, 1, 2, 2, 3, 3, 3, 1, 1, 2, 3, 3, 3, 2, 2, 2, 38 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0, 39 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 40 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 41 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 42 3, 3, 3, 0, 3, 3, 3, 3, 3, 0, 0, 1, 1, 1, 1, 1, 43 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 44 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 45 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 46 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 47 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 48 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 49 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 3, 3, 50 3, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 0, 51 // END(libdex-widths) 52}; 53 54/* 55 * Table that maps each opcode to the flags associated with that 56 * opcode. 57 */ 58static u1 gOpcodeFlagsTable[kNumPackedOpcodes] = { 59 // BEGIN(libdex-flags); GENERATED AUTOMATICALLY BY opcode-gen 60 kInstrCanContinue, 61 kInstrCanContinue, 62 kInstrCanContinue, 63 kInstrCanContinue, 64 kInstrCanContinue, 65 kInstrCanContinue, 66 kInstrCanContinue, 67 kInstrCanContinue, 68 kInstrCanContinue, 69 kInstrCanContinue, 70 kInstrCanContinue, 71 kInstrCanContinue, 72 kInstrCanContinue, 73 kInstrCanContinue, 74 kInstrCanReturn, 75 kInstrCanReturn, 76 kInstrCanReturn, 77 kInstrCanReturn, 78 kInstrCanContinue, 79 kInstrCanContinue, 80 kInstrCanContinue, 81 kInstrCanContinue, 82 kInstrCanContinue, 83 kInstrCanContinue, 84 kInstrCanContinue, 85 kInstrCanContinue, 86 kInstrCanContinue|kInstrCanThrow, 87 kInstrCanContinue|kInstrCanThrow, 88 kInstrCanContinue|kInstrCanThrow, 89 kInstrCanContinue|kInstrCanThrow, 90 kInstrCanContinue|kInstrCanThrow, 91 kInstrCanContinue|kInstrCanThrow, 92 kInstrCanContinue|kInstrCanThrow, 93 kInstrCanContinue|kInstrCanThrow, 94 kInstrCanContinue|kInstrCanThrow, 95 kInstrCanContinue|kInstrCanThrow, 96 kInstrCanContinue|kInstrCanThrow, 97 kInstrCanContinue|kInstrCanThrow, 98 kInstrCanContinue, 99 kInstrCanThrow, 100 kInstrCanBranch, 101 kInstrCanBranch, 102 kInstrCanBranch, 103 kInstrCanContinue|kInstrCanSwitch, 104 kInstrCanContinue|kInstrCanSwitch, 105 kInstrCanContinue, 106 kInstrCanContinue, 107 kInstrCanContinue, 108 kInstrCanContinue, 109 kInstrCanContinue, 110 kInstrCanContinue|kInstrCanBranch, 111 kInstrCanContinue|kInstrCanBranch, 112 kInstrCanContinue|kInstrCanBranch, 113 kInstrCanContinue|kInstrCanBranch, 114 kInstrCanContinue|kInstrCanBranch, 115 kInstrCanContinue|kInstrCanBranch, 116 kInstrCanContinue|kInstrCanBranch, 117 kInstrCanContinue|kInstrCanBranch, 118 kInstrCanContinue|kInstrCanBranch, 119 kInstrCanContinue|kInstrCanBranch, 120 kInstrCanContinue|kInstrCanBranch, 121 kInstrCanContinue|kInstrCanBranch, 122 0, 123 0, 124 0, 125 0, 126 0, 127 0, 128 kInstrCanContinue|kInstrCanThrow, 129 kInstrCanContinue|kInstrCanThrow, 130 kInstrCanContinue|kInstrCanThrow, 131 kInstrCanContinue|kInstrCanThrow, 132 kInstrCanContinue|kInstrCanThrow, 133 kInstrCanContinue|kInstrCanThrow, 134 kInstrCanContinue|kInstrCanThrow, 135 kInstrCanContinue|kInstrCanThrow, 136 kInstrCanContinue|kInstrCanThrow, 137 kInstrCanContinue|kInstrCanThrow, 138 kInstrCanContinue|kInstrCanThrow, 139 kInstrCanContinue|kInstrCanThrow, 140 kInstrCanContinue|kInstrCanThrow, 141 kInstrCanContinue|kInstrCanThrow, 142 kInstrCanContinue|kInstrCanThrow, 143 kInstrCanContinue|kInstrCanThrow, 144 kInstrCanContinue|kInstrCanThrow, 145 kInstrCanContinue|kInstrCanThrow, 146 kInstrCanContinue|kInstrCanThrow, 147 kInstrCanContinue|kInstrCanThrow, 148 kInstrCanContinue|kInstrCanThrow, 149 kInstrCanContinue|kInstrCanThrow, 150 kInstrCanContinue|kInstrCanThrow, 151 kInstrCanContinue|kInstrCanThrow, 152 kInstrCanContinue|kInstrCanThrow, 153 kInstrCanContinue|kInstrCanThrow, 154 kInstrCanContinue|kInstrCanThrow, 155 kInstrCanContinue|kInstrCanThrow, 156 kInstrCanContinue|kInstrCanThrow, 157 kInstrCanContinue|kInstrCanThrow, 158 kInstrCanContinue|kInstrCanThrow, 159 kInstrCanContinue|kInstrCanThrow, 160 kInstrCanContinue|kInstrCanThrow, 161 kInstrCanContinue|kInstrCanThrow, 162 kInstrCanContinue|kInstrCanThrow, 163 kInstrCanContinue|kInstrCanThrow, 164 kInstrCanContinue|kInstrCanThrow, 165 kInstrCanContinue|kInstrCanThrow, 166 kInstrCanContinue|kInstrCanThrow, 167 kInstrCanContinue|kInstrCanThrow, 168 kInstrCanContinue|kInstrCanThrow, 169 kInstrCanContinue|kInstrCanThrow, 170 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 171 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 172 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 173 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 174 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 175 0, 176 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 177 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 178 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 179 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 180 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 181 0, 182 0, 183 kInstrCanContinue, 184 kInstrCanContinue, 185 kInstrCanContinue, 186 kInstrCanContinue, 187 kInstrCanContinue, 188 kInstrCanContinue, 189 kInstrCanContinue, 190 kInstrCanContinue, 191 kInstrCanContinue, 192 kInstrCanContinue, 193 kInstrCanContinue, 194 kInstrCanContinue, 195 kInstrCanContinue, 196 kInstrCanContinue, 197 kInstrCanContinue, 198 kInstrCanContinue, 199 kInstrCanContinue, 200 kInstrCanContinue, 201 kInstrCanContinue, 202 kInstrCanContinue, 203 kInstrCanContinue, 204 kInstrCanContinue, 205 kInstrCanContinue, 206 kInstrCanContinue, 207 kInstrCanContinue|kInstrCanThrow, 208 kInstrCanContinue|kInstrCanThrow, 209 kInstrCanContinue, 210 kInstrCanContinue, 211 kInstrCanContinue, 212 kInstrCanContinue, 213 kInstrCanContinue, 214 kInstrCanContinue, 215 kInstrCanContinue, 216 kInstrCanContinue, 217 kInstrCanContinue, 218 kInstrCanContinue|kInstrCanThrow, 219 kInstrCanContinue|kInstrCanThrow, 220 kInstrCanContinue, 221 kInstrCanContinue, 222 kInstrCanContinue, 223 kInstrCanContinue, 224 kInstrCanContinue, 225 kInstrCanContinue, 226 kInstrCanContinue, 227 kInstrCanContinue, 228 kInstrCanContinue, 229 kInstrCanContinue, 230 kInstrCanContinue, 231 kInstrCanContinue, 232 kInstrCanContinue, 233 kInstrCanContinue, 234 kInstrCanContinue, 235 kInstrCanContinue, 236 kInstrCanContinue, 237 kInstrCanContinue, 238 kInstrCanContinue, 239 kInstrCanContinue|kInstrCanThrow, 240 kInstrCanContinue|kInstrCanThrow, 241 kInstrCanContinue, 242 kInstrCanContinue, 243 kInstrCanContinue, 244 kInstrCanContinue, 245 kInstrCanContinue, 246 kInstrCanContinue, 247 kInstrCanContinue, 248 kInstrCanContinue, 249 kInstrCanContinue, 250 kInstrCanContinue|kInstrCanThrow, 251 kInstrCanContinue|kInstrCanThrow, 252 kInstrCanContinue, 253 kInstrCanContinue, 254 kInstrCanContinue, 255 kInstrCanContinue, 256 kInstrCanContinue, 257 kInstrCanContinue, 258 kInstrCanContinue, 259 kInstrCanContinue, 260 kInstrCanContinue, 261 kInstrCanContinue, 262 kInstrCanContinue, 263 kInstrCanContinue, 264 kInstrCanContinue, 265 kInstrCanContinue, 266 kInstrCanContinue, 267 kInstrCanContinue, 268 kInstrCanContinue, 269 kInstrCanContinue, 270 kInstrCanContinue, 271 kInstrCanContinue|kInstrCanThrow, 272 kInstrCanContinue|kInstrCanThrow, 273 kInstrCanContinue, 274 kInstrCanContinue, 275 kInstrCanContinue, 276 kInstrCanContinue, 277 kInstrCanContinue, 278 kInstrCanContinue, 279 kInstrCanContinue|kInstrCanThrow, 280 kInstrCanContinue|kInstrCanThrow, 281 kInstrCanContinue, 282 kInstrCanContinue, 283 kInstrCanContinue, 284 kInstrCanContinue, 285 kInstrCanContinue, 286 kInstrCanContinue, 287 kInstrCanContinue|kInstrCanThrow, 288 kInstrCanContinue|kInstrCanThrow, 289 kInstrCanContinue|kInstrCanThrow, 290 kInstrCanContinue|kInstrCanThrow, 291 kInstrCanContinue|kInstrCanThrow, 292 kInstrCanContinue|kInstrCanThrow, 293 kInstrCanContinue|kInstrCanThrow, 294 kInstrCanContinue|kInstrCanThrow, 295 kInstrCanContinue|kInstrCanThrow, 296 0, 297 kInstrCanThrow, 298 kInstrCanContinue|kInstrCanThrow, 299 kInstrCanContinue|kInstrCanThrow, 300 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 301 kInstrCanReturn, 302 kInstrCanContinue|kInstrCanThrow, 303 kInstrCanContinue|kInstrCanThrow, 304 kInstrCanContinue|kInstrCanThrow, 305 kInstrCanContinue|kInstrCanThrow, 306 kInstrCanContinue|kInstrCanThrow, 307 kInstrCanContinue|kInstrCanThrow, 308 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 309 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 310 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 311 kInstrCanContinue|kInstrCanThrow|kInstrInvoke, 312 kInstrCanContinue|kInstrCanThrow, 313 kInstrCanContinue|kInstrCanThrow, 314 kInstrCanContinue|kInstrCanThrow, 315 0, 316 // END(libdex-flags) 317}; 318 319/* 320 * Table that maps each opcode to the instruction format associated 321 * that opcode. 322 */ 323static u1 gInstructionFormatTable[kNumPackedOpcodes] = { 324 // BEGIN(libdex-formats); GENERATED AUTOMATICALLY BY opcode-gen 325 kFmt10x, kFmt12x, kFmt22x, kFmt32x, kFmt12x, kFmt22x, kFmt32x, 326 kFmt12x, kFmt22x, kFmt32x, kFmt11x, kFmt11x, kFmt11x, kFmt11x, 327 kFmt10x, kFmt11x, kFmt11x, kFmt11x, kFmt11n, kFmt21s, kFmt31i, 328 kFmt21h, kFmt21s, kFmt31i, kFmt51l, kFmt21h, kFmt21c, kFmt31c, 329 kFmt21c, kFmt11x, kFmt11x, kFmt21c, kFmt22c, kFmt12x, kFmt21c, 330 kFmt22c, kFmt35c, kFmt3rc, kFmt31t, kFmt11x, kFmt10t, kFmt20t, 331 kFmt30t, kFmt31t, kFmt31t, kFmt23x, kFmt23x, kFmt23x, kFmt23x, 332 kFmt23x, kFmt22t, kFmt22t, kFmt22t, kFmt22t, kFmt22t, kFmt22t, 333 kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt00x, 334 kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt23x, kFmt23x, 335 kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, 336 kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt22c, kFmt22c, 337 kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, 338 kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt21c, kFmt21c, 339 kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, 340 kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt35c, kFmt35c, 341 kFmt35c, kFmt35c, kFmt35c, kFmt00x, kFmt3rc, kFmt3rc, kFmt3rc, 342 kFmt3rc, kFmt3rc, kFmt00x, kFmt00x, kFmt12x, kFmt12x, kFmt12x, 343 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, 344 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, 345 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt23x, kFmt23x, kFmt23x, 346 kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, 347 kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, 348 kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, 349 kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, 350 kFmt23x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, 351 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, 352 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, 353 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, 354 kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt22s, kFmt22s, 355 kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22b, 356 kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, 357 kFmt22b, kFmt22b, kFmt22b, kFmt22c, kFmt22c, kFmt21c, kFmt21c, 358 kFmt22c, kFmt22c, kFmt22c, kFmt21c, kFmt21c, kFmt00x, kFmt20bc, 359 kFmt35mi, kFmt3rmi, kFmt35c, kFmt10x, kFmt22cs, kFmt22cs, kFmt22cs, 360 kFmt22cs, kFmt22cs, kFmt22cs, kFmt35ms, kFmt3rms, kFmt35ms, kFmt3rms, 361 kFmt22c, kFmt21c, kFmt21c, kFmt00x, 362 // END(libdex-formats) 363}; 364 365/* 366 * Table that maps each opcode to the index type implied by that 367 * opcode. 368 */ 369static u1 gInstructionIndexTypeTable[kNumPackedOpcodes] = { 370 // BEGIN(libdex-index-types); GENERATED AUTOMATICALLY BY opcode-gen 371 kIndexNone, kIndexNone, kIndexNone, 372 kIndexNone, kIndexNone, kIndexNone, 373 kIndexNone, kIndexNone, kIndexNone, 374 kIndexNone, kIndexNone, kIndexNone, 375 kIndexNone, kIndexNone, kIndexNone, 376 kIndexNone, kIndexNone, kIndexNone, 377 kIndexNone, kIndexNone, kIndexNone, 378 kIndexNone, kIndexNone, kIndexNone, 379 kIndexNone, kIndexNone, kIndexStringRef, 380 kIndexStringRef, kIndexTypeRef, kIndexNone, 381 kIndexNone, kIndexTypeRef, kIndexTypeRef, 382 kIndexNone, kIndexTypeRef, kIndexTypeRef, 383 kIndexTypeRef, kIndexTypeRef, kIndexNone, 384 kIndexNone, kIndexNone, kIndexNone, 385 kIndexNone, kIndexNone, kIndexNone, 386 kIndexNone, kIndexNone, kIndexNone, 387 kIndexNone, kIndexNone, kIndexNone, 388 kIndexNone, kIndexNone, kIndexNone, 389 kIndexNone, kIndexNone, kIndexNone, 390 kIndexNone, kIndexNone, kIndexNone, 391 kIndexNone, kIndexNone, kIndexUnknown, 392 kIndexUnknown, kIndexUnknown, kIndexUnknown, 393 kIndexUnknown, kIndexUnknown, kIndexNone, 394 kIndexNone, kIndexNone, kIndexNone, 395 kIndexNone, kIndexNone, kIndexNone, 396 kIndexNone, kIndexNone, kIndexNone, 397 kIndexNone, kIndexNone, kIndexNone, 398 kIndexNone, kIndexFieldRef, kIndexFieldRef, 399 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 400 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 401 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 402 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 403 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 404 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 405 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 406 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 407 kIndexFieldRef, kIndexFieldRef, kIndexMethodRef, 408 kIndexMethodRef, kIndexMethodRef, kIndexMethodRef, 409 kIndexMethodRef, kIndexUnknown, kIndexMethodRef, 410 kIndexMethodRef, kIndexMethodRef, kIndexMethodRef, 411 kIndexMethodRef, kIndexUnknown, kIndexUnknown, 412 kIndexNone, kIndexNone, kIndexNone, 413 kIndexNone, kIndexNone, kIndexNone, 414 kIndexNone, kIndexNone, kIndexNone, 415 kIndexNone, kIndexNone, kIndexNone, 416 kIndexNone, kIndexNone, kIndexNone, 417 kIndexNone, kIndexNone, kIndexNone, 418 kIndexNone, kIndexNone, kIndexNone, 419 kIndexNone, kIndexNone, kIndexNone, 420 kIndexNone, kIndexNone, kIndexNone, 421 kIndexNone, kIndexNone, kIndexNone, 422 kIndexNone, kIndexNone, kIndexNone, 423 kIndexNone, kIndexNone, kIndexNone, 424 kIndexNone, kIndexNone, kIndexNone, 425 kIndexNone, kIndexNone, kIndexNone, 426 kIndexNone, kIndexNone, kIndexNone, 427 kIndexNone, kIndexNone, kIndexNone, 428 kIndexNone, kIndexNone, kIndexNone, 429 kIndexNone, kIndexNone, kIndexNone, 430 kIndexNone, kIndexNone, kIndexNone, 431 kIndexNone, kIndexNone, kIndexNone, 432 kIndexNone, kIndexNone, kIndexNone, 433 kIndexNone, kIndexNone, kIndexNone, 434 kIndexNone, kIndexNone, kIndexNone, 435 kIndexNone, kIndexNone, kIndexNone, 436 kIndexNone, kIndexNone, kIndexNone, 437 kIndexNone, kIndexNone, kIndexNone, 438 kIndexNone, kIndexNone, kIndexNone, 439 kIndexNone, kIndexNone, kIndexNone, 440 kIndexNone, kIndexNone, kIndexNone, 441 kIndexNone, kIndexNone, kIndexNone, 442 kIndexNone, kIndexNone, kIndexNone, 443 kIndexNone, kIndexNone, kIndexNone, 444 kIndexNone, kIndexNone, kIndexNone, 445 kIndexNone, kIndexNone, kIndexNone, 446 kIndexNone, kIndexNone, kIndexFieldRef, 447 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 448 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 449 kIndexFieldRef, kIndexFieldRef, kIndexUnknown, 450 kIndexVaries, kIndexInlineMethod, kIndexInlineMethod, 451 kIndexMethodRef, kIndexNone, kIndexFieldOffset, 452 kIndexFieldOffset, kIndexFieldOffset, kIndexFieldOffset, 453 kIndexFieldOffset, kIndexFieldOffset, kIndexVtableOffset, 454 kIndexVtableOffset, kIndexVtableOffset, kIndexVtableOffset, 455 kIndexFieldRef, kIndexFieldRef, kIndexFieldRef, 456 kIndexUnknown, 457 // END(libdex-index-types) 458}; 459 460/* 461 * Global InstructionInfoTables struct. 462 */ 463InstructionInfoTables gDexOpcodeInfo = { 464 gInstructionFormatTable, 465 gInstructionIndexTypeTable, 466 gOpcodeFlagsTable, 467 gInstructionWidthTable 468}; 469 470/* 471 * Handy macros for helping decode instructions. 472 */ 473#define FETCH(_offset) (insns[(_offset)]) 474#define FETCH_u4(_offset) (fetch_u4_impl((_offset), insns)) 475#define INST_A(_inst) (((u2)(_inst) >> 8) & 0x0f) 476#define INST_B(_inst) ((u2)(_inst) >> 12) 477#define INST_AA(_inst) ((_inst) >> 8) 478 479/* Helper for FETCH_u4, above. */ 480static inline u4 fetch_u4_impl(u4 offset, const u2* insns) { 481 return insns[offset] | ((u4) insns[offset+1] << 16); 482} 483 484/* 485 * Decode the instruction pointed to by "insns". 486 * 487 * Fills out the pieces of "pDec" that are affected by the current 488 * instruction. Does not touch anything else. 489 */ 490void dexDecodeInstruction(const u2* insns, DecodedInstruction* pDec) 491{ 492 u2 inst = *insns; 493 Opcode opcode = dexOpcodeFromCodeUnit(inst); 494 InstructionFormat format = dexGetFormatFromOpcode(opcode); 495 496 pDec->opcode = opcode; 497 pDec->indexType = dexGetIndexTypeFromOpcode(opcode); 498 499 switch (format) { 500 case kFmt10x: // op 501 /* nothing to do; copy the AA bits out for the verifier */ 502 pDec->vA = INST_AA(inst); 503 break; 504 case kFmt12x: // op vA, vB 505 pDec->vA = INST_A(inst); 506 pDec->vB = INST_B(inst); 507 break; 508 case kFmt11n: // op vA, #+B 509 pDec->vA = INST_A(inst); 510 pDec->vB = (s4) (INST_B(inst) << 28) >> 28; // sign extend 4-bit value 511 break; 512 case kFmt11x: // op vAA 513 pDec->vA = INST_AA(inst); 514 break; 515 case kFmt10t: // op +AA 516 pDec->vA = (s1) INST_AA(inst); // sign-extend 8-bit value 517 break; 518 case kFmt20t: // op +AAAA 519 pDec->vA = (s2) FETCH(1); // sign-extend 16-bit value 520 break; 521 case kFmt20bc: // [opt] op AA, thing@BBBB 522 case kFmt21c: // op vAA, thing@BBBB 523 case kFmt22x: // op vAA, vBBBB 524 pDec->vA = INST_AA(inst); 525 pDec->vB = FETCH(1); 526 break; 527 case kFmt21s: // op vAA, #+BBBB 528 case kFmt21t: // op vAA, +BBBB 529 pDec->vA = INST_AA(inst); 530 pDec->vB = (s2) FETCH(1); // sign-extend 16-bit value 531 break; 532 case kFmt21h: // op vAA, #+BBBB0000[00000000] 533 pDec->vA = INST_AA(inst); 534 /* 535 * The value should be treated as right-zero-extended, but we don't 536 * actually do that here. Among other things, we don't know if it's 537 * the top bits of a 32- or 64-bit value. 538 */ 539 pDec->vB = FETCH(1); 540 break; 541 case kFmt23x: // op vAA, vBB, vCC 542 pDec->vA = INST_AA(inst); 543 pDec->vB = FETCH(1) & 0xff; 544 pDec->vC = FETCH(1) >> 8; 545 break; 546 case kFmt22b: // op vAA, vBB, #+CC 547 pDec->vA = INST_AA(inst); 548 pDec->vB = FETCH(1) & 0xff; 549 pDec->vC = (s1) (FETCH(1) >> 8); // sign-extend 8-bit value 550 break; 551 case kFmt22s: // op vA, vB, #+CCCC 552 case kFmt22t: // op vA, vB, +CCCC 553 pDec->vA = INST_A(inst); 554 pDec->vB = INST_B(inst); 555 pDec->vC = (s2) FETCH(1); // sign-extend 16-bit value 556 break; 557 case kFmt22c: // op vA, vB, thing@CCCC 558 case kFmt22cs: // [opt] op vA, vB, field offset CCCC 559 pDec->vA = INST_A(inst); 560 pDec->vB = INST_B(inst); 561 pDec->vC = FETCH(1); 562 break; 563 case kFmt30t: // op +AAAAAAAA 564 pDec->vA = FETCH_u4(1); // signed 32-bit value 565 break; 566 case kFmt31t: // op vAA, +BBBBBBBB 567 case kFmt31c: // op vAA, string@BBBBBBBB 568 pDec->vA = INST_AA(inst); 569 pDec->vB = FETCH_u4(1); // 32-bit value 570 break; 571 case kFmt32x: // op vAAAA, vBBBB 572 pDec->vA = FETCH(1); 573 pDec->vB = FETCH(2); 574 break; 575 case kFmt31i: // op vAA, #+BBBBBBBB 576 pDec->vA = INST_AA(inst); 577 pDec->vB = FETCH_u4(1); // signed 32-bit value 578 break; 579 case kFmt35c: // op {vC, vD, vE, vF, vG}, thing@BBBB 580 case kFmt35ms: // [opt] invoke-virtual+super 581 case kFmt35mi: // [opt] inline invoke 582 { 583 /* 584 * Note that the fields mentioned in the spec don't appear in 585 * their "usual" positions here compared to most formats. This 586 * was done so that the field names for the argument count and 587 * reference index match between this format and the corresponding 588 * range formats (3rc and friends). 589 * 590 * Bottom line: The argument count is always in vA, and the 591 * method constant (or equivalent) is always in vB. 592 */ 593 u2 regList; 594 int i, count; 595 596 pDec->vA = INST_B(inst); // This is labeled A in the spec. 597 pDec->vB = FETCH(1); 598 regList = FETCH(2); 599 600 count = pDec->vA; 601 602 /* 603 * Copy the argument registers into the arg[] array, and 604 * also copy the first argument (if any) into vC. (The 605 * DecodedInstruction structure doesn't have separate 606 * fields for {vD, vE, vF, vG}, so there's no need to make 607 * copies of those.) Note that cases 5..2 fall through. 608 */ 609 switch (count) { 610 case 5: { 611 if (format == kFmt35mi) { 612 /* A fifth arg is verboten for inline invokes. */ 613 LOGW("Invalid arg count in 35mi (5)"); 614 goto bail; 615 } 616 /* 617 * Per note at the top of this format decoder, the 618 * fifth argument comes from the A field in the 619 * instruction, but it's labeled G in the spec. 620 */ 621 pDec->arg[4] = INST_A(inst); 622 } 623 case 4: pDec->arg[3] = (regList >> 12) & 0x0f; 624 case 3: pDec->arg[2] = (regList >> 8) & 0x0f; 625 case 2: pDec->arg[1] = (regList >> 4) & 0x0f; 626 case 1: pDec->vC = pDec->arg[0] = regList & 0x0f; break; 627 case 0: break; // Valid, but no need to do anything. 628 default: 629 LOGW("Invalid arg count in 35c/35ms/35mi (%d)", count); 630 goto bail; 631 } 632 } 633 break; 634 case kFmt3rc: // op {vCCCC .. v(CCCC+AA-1)}, meth@BBBB 635 case kFmt3rms: // [opt] invoke-virtual+super/range 636 case kFmt3rmi: // [opt] execute-inline/range 637 pDec->vA = INST_AA(inst); 638 pDec->vB = FETCH(1); 639 pDec->vC = FETCH(2); 640 break; 641 case kFmt51l: // op vAA, #+BBBBBBBBBBBBBBBB 642 pDec->vA = INST_AA(inst); 643 pDec->vB_wide = FETCH_u4(1) | ((u8) FETCH_u4(3) << 32); 644 break; 645 default: 646 LOGW("Can't decode unexpected format %d (op=%d)", format, opcode); 647 assert(false); 648 break; 649 } 650 651bail: 652 ; 653} 654 655/* 656 * Return the width of the specified instruction, or 0 if not defined. Also 657 * works for special OP_NOP entries, including switch statement data tables 658 * and array data. 659 */ 660size_t dexGetWidthFromInstruction(const u2* insns) 661{ 662 size_t width; 663 664 if (*insns == kPackedSwitchSignature) { 665 width = 4 + insns[1] * 2; 666 } else if (*insns == kSparseSwitchSignature) { 667 width = 2 + insns[1] * 4; 668 } else if (*insns == kArrayDataSignature) { 669 u2 elemWidth = insns[1]; 670 u4 len = insns[2] | (((u4)insns[3]) << 16); 671 // The plus 1 is to round up for odd size and width. 672 width = 4 + (elemWidth * len + 1) / 2; 673 } else { 674 width = dexGetWidthFromOpcode(dexOpcodeFromCodeUnit(insns[0])); 675 } 676 677 return width; 678} 679