vm/analysis/CodeVerify.h

   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 bytecode verifier.
  19  */
  20 #ifndef _DALVIK_CODEVERIFY
  21 #define _DALVIK_CODEVERIFY
  22
  23 #include "analysis/VerifySubs.h"
  24
  25
  26 /*
  27  * Enumeration for register type values.  The "hi" piece of a 64-bit value
  28  * MUST immediately follow the "lo" piece in the enumeration, so we can check
  29  * that hi==lo+1.
  30  *
  31  * Assignment of constants:
  32  *   [-MAXINT,-32768)   : integer
  33  *   [-32768,-128)      : short
  34  *   [-128,0)           : byte
  35  *   0                  : zero
  36  *   1                  : one
  37  *   [2,128)            : posbyte
  38  *   [128,32768)        : posshort
  39  *   [32768,65536)      : char
  40  *   [65536,MAXINT]     : integer
  41  *
  42  * Allowed "implicit" widening conversions:
  43  *   zero -> boolean, posbyte, byte, posshort, short, char, integer, ref (null)
  44  *   one -> boolean, posbyte, byte, posshort, short, char, integer
  45  *   boolean -> posbyte, byte, posshort, short, char, integer
  46  *   posbyte -> posshort, short, integer, char
  47  *   byte -> short, integer
  48  *   posshort -> integer, char
  49  *   short -> integer
  50  *   char -> integer
  51  *
  52  * In addition, all of the above can convert to "float".
  53  *
  54  * We're more careful with integer values than the spec requires.  The
  55  * motivation is to restrict byte/char/short to the correct range of values.
  56  * For example, if a method takes a byte argument, we don't want to allow
  57  * the code to load the constant "1024" and pass it in.
  58  */
  59 enum {
  60     kRegTypeUnknown = 0,    /* initial state; use value=0 so calloc works */
  61     kRegTypeUninit = 1,     /* MUST be odd to distinguish from pointer */
  62     kRegTypeConflict,       /* merge clash makes this reg's type unknowable */
  63
  64     /*
  65      * Category-1nr types.  The order of these is chiseled into a couple
  66      * of tables, so don't add, remove, or reorder if you can avoid it.
  67      */
  68 #define kRegType1nrSTART    kRegTypeFloat
  69     kRegTypeFloat,
  70     kRegTypeZero,           /* 32-bit 0, could be Boolean, Int, Float, or Ref */
  71     kRegTypeOne,            /* 32-bit 1, could be Boolean, Int, Float */
  72     kRegTypeBoolean,        /* must be 0 or 1 */
  73     kRegTypePosByte,        /* byte, known positive (can become char) */
  74     kRegTypeByte,
  75     kRegTypePosShort,       /* short, known positive (can become char) */
  76     kRegTypeShort,
  77     kRegTypeChar,
  78     kRegTypeInteger,
  79 #define kRegType1nrEND      kRegTypeInteger
  80
  81     kRegTypeLongLo,         /* lower-numbered register; endian-independent */
  82     kRegTypeLongHi,
  83     kRegTypeDoubleLo,
  84     kRegTypeDoubleHi,
  85
  86     /*
  87      * Enumeration max; this is used with "full" (32-bit) RegType values.
  88      *
  89      * Anything larger than this is a ClassObject or uninit ref.  Mask off
  90      * all but the low 8 bits; if you're left with kRegTypeUninit, pull
  91      * the uninit index out of the high 24.  Because kRegTypeUninit has an
  92      * odd value, there is no risk of a particular ClassObject pointer bit
  93      * pattern being confused for it (assuming our class object allocator
  94      * uses word alignment).
  95      */
  96     kRegTypeMAX
  97 };
  98 #define kRegTypeUninitMask  0xff
  99 #define kRegTypeUninitShift 8
 100
 101 /*
 102  * RegType holds information about the type of data held in a register.
 103  * For most types it's a simple enum.  For reference types it holds a
 104  * pointer to the ClassObject, and for uninitialized references it holds
 105  * an index into the UninitInstanceMap.
 106  */
 107 typedef u4 RegType;
 108
 109 /* table with merge logic for primitive types */
 110 extern const char gDvmMergeTab[kRegTypeMAX][kRegTypeMAX];
 111
 112
 113 /*
 114  * Returns "true" if the flags indicate that this address holds the start
 115  * of an instruction.
 116  */
 117 INLINE bool dvmInsnIsOpcode(const InsnFlags* insnFlags, int addr) {
 118     return (insnFlags[addr] & kInsnFlagWidthMask) != 0;
 119 }
 120
 121 /*
 122  * Extract the unsigned 16-bit instruction width from "flags".
 123  */
 124 INLINE int dvmInsnGetWidth(const InsnFlags* insnFlags, int addr) {
 125     return insnFlags[addr] & kInsnFlagWidthMask;
 126 }
 127
 128 /*
 129  * Changed?
 130  */
 131 INLINE bool dvmInsnIsChanged(const InsnFlags* insnFlags, int addr) {
 132     return (insnFlags[addr] & kInsnFlagChanged) != 0;
 133 }
 134 INLINE void dvmInsnSetChanged(InsnFlags* insnFlags, int addr, bool changed)
 135 {
 136     if (changed)
 137         insnFlags[addr] |= kInsnFlagChanged;
 138     else
 139         insnFlags[addr] &= ~kInsnFlagChanged;
 140 }
 141
 142 /*
 143  * Visited?
 144  */
 145 INLINE bool dvmInsnIsVisited(const InsnFlags* insnFlags, int addr) {
 146     return (insnFlags[addr] & kInsnFlagVisited) != 0;
 147 }
 148 INLINE void dvmInsnSetVisited(InsnFlags* insnFlags, int addr, bool changed)
 149 {
 150     if (changed)
 151         insnFlags[addr] |= kInsnFlagVisited;
 152     else
 153         insnFlags[addr] &= ~kInsnFlagVisited;
 154 }
 155
 156 /*
 157  * Visited or changed?
 158  */
 159 INLINE bool dvmInsnIsVisitedOrChanged(const InsnFlags* insnFlags, int addr) {
 160     return (insnFlags[addr] & (kInsnFlagVisited|kInsnFlagChanged)) != 0;
 161 }
 162
 163 /*
 164  * In a "try" block?
 165  */
 166 INLINE bool dvmInsnIsInTry(const InsnFlags* insnFlags, int addr) {
 167     return (insnFlags[addr] & kInsnFlagInTry) != 0;
 168 }
 169 INLINE void dvmInsnSetInTry(InsnFlags* insnFlags, int addr, bool inTry)
 170 {
 171     assert(inTry);
 172     //if (inTry)
 173         insnFlags[addr] |= kInsnFlagInTry;
 174     //else
 175     //    insnFlags[addr] &= ~kInsnFlagInTry;
 176 }
 177
 178 /*
 179  * Instruction is a branch target or exception handler?
 180  */
 181 INLINE bool dvmInsnIsBranchTarget(const InsnFlags* insnFlags, int addr) {
 182     return (insnFlags[addr] & kInsnFlagBranchTarget) != 0;
 183 }
 184 INLINE void dvmInsnSetBranchTarget(InsnFlags* insnFlags, int addr,
 185     bool isBranch)
 186 {
 187     assert(isBranch);
 188     //if (isBranch)
 189         insnFlags[addr] |= kInsnFlagBranchTarget;
 190     //else
 191     //    insnFlags[addr] &= ~kInsnFlagBranchTarget;
 192 }
 193
 194 /*
 195  * Instruction is a GC point?
 196  */
 197 INLINE bool dvmInsnIsGcPoint(const InsnFlags* insnFlags, int addr) {
 198     return (insnFlags[addr] & kInsnFlagGcPoint) != 0;
 199 }
 200 INLINE void dvmInsnSetGcPoint(InsnFlags* insnFlags, int addr,
 201     bool isGcPoint)
 202 {
 203     assert(isGcPoint);
 204     //if (isGcPoint)
 205         insnFlags[addr] |= kInsnFlagGcPoint;
 206     //else
 207     //    insnFlags[addr] &= ~kInsnFlagGcPoint;
 208 }
 209
 210
 211 /*
 212  * Table that maps uninitialized instances to classes, based on the
 213  * address of the new-instance instruction.
 214  */
 215 typedef struct UninitInstanceMap {
 216     int numEntries;
 217     struct {
 218         int             addr;   /* code offset, or -1 for method arg ("this") */
 219         ClassObject*    clazz;  /* class created at this address */
 220     } map[1];
 221 } UninitInstanceMap;
 222 #define kUninitThisArgAddr  (-1)
 223 #define kUninitThisArgSlot  0
 224
 225 /*
 226  * Create a new UninitInstanceMap.
 227  */
 228 UninitInstanceMap* dvmCreateUninitInstanceMap(const Method* meth,
 229     const InsnFlags* insnFlags, int newInstanceCount);
 230
 231 /*
 232  * Release the storage associated with an UninitInstanceMap.
 233  */
 234 void dvmFreeUninitInstanceMap(UninitInstanceMap* uninitMap);
 235
 236 /*
 237  * Associate a class with an address.  Returns the map slot index, or -1
 238  * if the address isn't listed in the map (shouldn't happen) or if a
 239  * different class is already associated with the address (shouldn't
 240  * happen either).
 241  */
 242 //int dvmSetUninitInstance(UninitInstanceMap* uninitMap, int addr,
 243 //    ClassObject* clazz);
 244
 245 /*
 246  * Return the class associated with an uninitialized reference.  Pass in
 247  * the map index.
 248  */
 249 //ClassObject* dvmGetUninitInstance(const UninitInstanceMap* uninitMap, int idx);
 250
 251 /*
 252  * Clear the class associated with an uninitialized reference.  Pass in
 253  * the map index.
 254  */
 255 //void dvmClearUninitInstance(UninitInstanceMap* uninitMap, int idx);
 256
 257
 258 /*
 259  * Verify bytecode in "meth".  "insnFlags" should be populated with
 260  * instruction widths and "in try" flags.
 261  */
 262 bool dvmVerifyCodeFlow(Method* meth, InsnFlags* insnFlags,
 263     UninitInstanceMap* uninitMap);
 264
 265 #endif /*_DALVIK_CODEVERIFY*/