src/main/gov/nasa/jpf/jvm/JVMClassInfo.java

   1 /*
   2  * Copyright (C) 2014, United States Government, as represented by the
   3  * Administrator of the National Aeronautics and Space Administration.
   4  * All rights reserved.
   5  *
   6  * The Java Pathfinder core (jpf-core) platform is licensed under the
   7  * Apache License, Version 2.0 (the "License"); you may not use this file except
   8  * in compliance with the License. You may obtain a copy of the License at
   9  *
  10  *        http://www.apache.org/licenses/LICENSE-2.0.
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 package gov.nasa.jpf.jvm;
  20
  21 import java.lang.reflect.Modifier;
  22 import java.util.HashMap;
  23 import java.util.LinkedHashMap;
  24 import java.util.LinkedList;
  25
  26 import gov.nasa.jpf.Config;
  27 import gov.nasa.jpf.util.Misc;
  28 import gov.nasa.jpf.util.StringSetMatcher;
  29 import gov.nasa.jpf.vm.AbstractTypeAnnotationInfo;
  30 import gov.nasa.jpf.vm.AnnotationInfo;
  31 import gov.nasa.jpf.vm.BootstrapMethodInfo;
  32 import gov.nasa.jpf.vm.BytecodeAnnotationInfo;
  33 import gov.nasa.jpf.vm.BytecodeTypeParameterAnnotationInfo;
  34 import gov.nasa.jpf.vm.ClassInfo;
  35 import gov.nasa.jpf.vm.ClassInfoException;
  36 import gov.nasa.jpf.vm.ClassLoaderInfo;
  37 import gov.nasa.jpf.vm.ClassParseException;
  38 import gov.nasa.jpf.vm.DirectCallStackFrame;
  39 import gov.nasa.jpf.vm.ExceptionHandler;
  40 import gov.nasa.jpf.vm.ExceptionParameterAnnotationInfo;
  41 import gov.nasa.jpf.vm.FieldInfo;
  42 import gov.nasa.jpf.vm.FormalParameterAnnotationInfo;
  43 import gov.nasa.jpf.vm.GenericSignatureHolder;
  44 import gov.nasa.jpf.vm.InfoObject;
  45 import gov.nasa.jpf.vm.LocalVarInfo;
  46 import gov.nasa.jpf.vm.MethodInfo;
  47 import gov.nasa.jpf.vm.NativeMethodInfo;
  48 import gov.nasa.jpf.vm.StackFrame;
  49 import gov.nasa.jpf.vm.SuperTypeAnnotationInfo;
  50 import gov.nasa.jpf.vm.ThreadInfo;
  51 import gov.nasa.jpf.vm.ThrowsAnnotationInfo;
  52 import gov.nasa.jpf.vm.TypeAnnotationInfo;
  53 import gov.nasa.jpf.vm.TypeParameterAnnotationInfo;
  54 import gov.nasa.jpf.vm.TypeParameterBoundAnnotationInfo;
  55 import gov.nasa.jpf.vm.Types;
  56 import gov.nasa.jpf.vm.VariableAnnotationInfo;
  57
  58 /**
  59  * a ClassInfo that was created from a Java classfile
  60  */
  61 public class JVMClassInfo extends ClassInfo {
  62
  63   /**
  64    * this is the inner class that does the actual ClassInfo initialization from ClassFile. It is an inner class so that
  65    * (a) it can set ClassInfo fields, (b) it can extend ClassFileReaderAdapter, and (c) we don't clutter JVMClassInfo with
  66    * fields that are only temporarily used during parsing
  67    */
  68   class Initializer extends ClassFileReaderAdapter {
  69     protected ClassFile cf;
  70     protected JVMCodeBuilder cb;
  71
  72     public Initializer (ClassFile cf, JVMCodeBuilder cb) throws ClassParseException {
  73       this.cf = cf;
  74       this.cb = cb;
  75
  76       cf.parse(this);
  77     }
  78
  79     @Override
  80     public void setClass (ClassFile cf, String clsName, String superClsName, int flags, int cpCount) throws ClassParseException {
  81       JVMClassInfo.this.setClass(clsName, superClsName, flags, cpCount);
  82     }
  83
  84     @Override
  85     public void setClassAttribute (ClassFile cf, int attrIndex, String name, int attrLength) {
  86       if (name == ClassFile.SOURCE_FILE_ATTR) {
  87         cf.parseSourceFileAttr(this, null);
  88
  89       } else if (name == ClassFile.SIGNATURE_ATTR) {
  90         cf.parseSignatureAttr(this, JVMClassInfo.this);
  91
  92       } else if (name == ClassFile.RUNTIME_VISIBLE_ANNOTATIONS_ATTR) {
  93         cf.parseAnnotationsAttr(this, JVMClassInfo.this);
  94
  95       } else if (name == ClassFile.RUNTIME_INVISIBLE_ANNOTATIONS_ATTR) {
  96         //cf.parseAnnotationsAttr(this, ClassInfo.this);
  97
  98       } else if (name == ClassFile.RUNTIME_VISIBLE_TYPE_ANNOTATIONS_ATTR) {
  99         cf.parseTypeAnnotationsAttr(this, JVMClassInfo.this);
 100
 101       } else if (name == ClassFile.INNER_CLASSES_ATTR) {
 102         cf.parseInnerClassesAttr(this, JVMClassInfo.this);
 103
 104       } else if (name == ClassFile.ENCLOSING_METHOD_ATTR) {
 105         cf.parseEnclosingMethodAttr(this, JVMClassInfo.this);
 106
 107       } else if (name == ClassFile.BOOTSTRAP_METHOD_ATTR) {
 108         cf.parseBootstrapMethodAttr(this, JVMClassInfo.this);
 109
 110       }
 111     }
 112
 113     @Override
 114     public void setBootstrapMethodCount (ClassFile cf, Object tag, int count) {
 115       bootstrapMethods = new BootstrapMethodInfo[count];
 116     }
 117
 118     @Override
 119     public void setBootstrapMethod (ClassFile cf, Object tag, int idx, int refKind, String cls, String mth, String descriptor, int[] cpArgs) {
 120
 121       int lambdaRefKind = cf.mhRefTypeAt(cpArgs[1]);
 122
 123       int mrefIdx = cf.mhMethodRefIndexAt(cpArgs[1]);
 124       String clsName = cf.methodClassNameAt(mrefIdx).replace('/', '.');
 125       ClassInfo eclosingLambdaCls;
 126
 127       if(!clsName.equals(JVMClassInfo.this.getName())) {
 128         eclosingLambdaCls = ClassLoaderInfo.getCurrentResolvedClassInfo(clsName);
 129       } else {
 130         eclosingLambdaCls = JVMClassInfo.this;
 131       }
 132
 133       assert (eclosingLambdaCls!=null);
 134
 135       String mthName = cf.methodNameAt(mrefIdx);
 136       String signature = cf.methodDescriptorAt(mrefIdx);
 137
 138       MethodInfo lambdaBody = eclosingLambdaCls.getMethod(mthName + signature, false);
 139
 140       String samDescriptor = cf.methodTypeDescriptorAt(cpArgs[2]);
 141
 142       if(lambdaBody!=null) {
 143         bootstrapMethods[idx] = new BootstrapMethodInfo(lambdaRefKind, JVMClassInfo.this, lambdaBody, samDescriptor);
 144       }
 145     }
 146
 147    //--- inner/enclosing classes
 148     @Override
 149     public void setInnerClassCount (ClassFile cf, Object tag, int classCount) {
 150       innerClassNames = new String[classCount];
 151     }
 152
 153     @Override
 154     public void setInnerClass (ClassFile cf, Object tag, int innerClsIndex,
 155             String outerName, String innerName, String innerSimpleName, int accessFlags) {
 156       // Ok, this is a total mess - some names are in dot notation, others use '/'
 157       // and to make it even more confusing, some InnerClass attributes refer NOT
 158       // to the currently parsed class, so we have to check if we are the outerName,
 159       // but then 'outerName' can also be null instead of our own name.
 160       // Oh, and there are also InnerClass attributes that have their own name as inner names
 161       // (see java/lang/String$CaseInsensitiveComparator or ...System and java/lang/System$1 for instance)
 162       if (outerName != null) {
 163         outerName = Types.getClassNameFromTypeName(outerName);
 164       }
 165
 166       innerName = Types.getClassNameFromTypeName(innerName);
 167       if (!innerName.equals(name)) {
 168         innerClassNames[innerClsIndex] = innerName;
 169
 170       } else {
 171         // this refers to ourself, and can be a force fight with setEnclosingMethod
 172         if (outerName != null) { // only set if this is a direct member, otherwise taken from setEnclosingMethod
 173           setEnclosingClass(outerName);
 174         }
 175       }
 176     }
 177
 178     @Override
 179     public void setEnclosingMethod (ClassFile cf, Object tag, String enclosingClassName, String enclosingMethodName, String descriptor) {
 180       setEnclosingClass(enclosingClassName);
 181
 182       if (enclosingMethodName != null) {
 183         JVMClassInfo.this.setEnclosingMethod(enclosingMethodName + descriptor);
 184       }
 185     }
 186
 187     @Override
 188     public void setInnerClassesDone (ClassFile cf, Object tag) {
 189       // we have to check if we allocated too many - see the mess above
 190       for (int i = 0; i < innerClassNames.length; i++) {
 191         innerClassNames = Misc.stripNullElements(innerClassNames);
 192       }
 193     }
 194
 195     //--- source file
 196     @Override
 197     public void setSourceFile (ClassFile cf, Object tag, String fileName) {
 198       JVMClassInfo.this.setSourceFile(fileName);
 199     }
 200
 201     //--- interfaces
 202     @Override
 203     public void setInterfaceCount (ClassFile cf, int ifcCount) {
 204       interfaceNames = new String[ifcCount];
 205     }
 206
 207     @Override
 208     public void setInterface (ClassFile cf, int ifcIndex, String ifcName) {
 209       interfaceNames[ifcIndex] = Types.getClassNameFromTypeName(ifcName);
 210     }
 211
 212     //--- fields
 213     // unfortunately they are stored together in the ClassFile, i.e. we
 214     // have to split them up once we are done
 215
 216     protected FieldInfo[] fields;
 217     protected FieldInfo curFi; // need to cache for attributes
 218
 219     @Override
 220     public void setFieldCount (ClassFile cf, int fieldCount) {
 221       if (fieldCount > 0){
 222         fields = new FieldInfo[fieldCount];
 223       } else {
 224         fields = null;
 225       }
 226     }
 227
 228     @Override
 229     public void setField (ClassFile cf, int fieldIndex, int accessFlags, String name, String descriptor) {
 230       FieldInfo fi = FieldInfo.create(name, descriptor, accessFlags);
 231       fields[fieldIndex] = fi;
 232       curFi = fi; // for attributes
 233     }
 234
 235     @Override
 236     public void setFieldAttribute (ClassFile cf, int fieldIndex, int attrIndex, String name, int attrLength) {
 237       if (name == ClassFile.SIGNATURE_ATTR) {
 238         cf.parseSignatureAttr(this, curFi);
 239
 240       } else if (name == ClassFile.CONST_VALUE_ATTR) {
 241         cf.parseConstValueAttr(this, curFi);
 242
 243       } else if (name == ClassFile.RUNTIME_VISIBLE_ANNOTATIONS_ATTR) {
 244         cf.parseAnnotationsAttr(this, curFi);
 245
 246       } else if (name == ClassFile.RUNTIME_VISIBLE_TYPE_ANNOTATIONS_ATTR) {
 247         cf.parseTypeAnnotationsAttr(this, curFi);
 248
 249       } else if (name == ClassFile.RUNTIME_INVISIBLE_ANNOTATIONS_ATTR) {
 250         //cf.parseAnnotationsAttr(this, curFi);
 251       }
 252     }
 253
 254     @Override
 255     public void setConstantValue (ClassFile cf, Object tag, Object constVal) {
 256       curFi.setConstantValue(constVal);
 257     }
 258
 259     @Override
 260     public void setFieldsDone (ClassFile cf) {
 261       setFields(fields);
 262     }
 263
 264   //--- declaredMethods
 265     protected MethodInfo curMi;
 266
 267     @Override
 268     public void setMethodCount (ClassFile cf, int methodCount) {
 269       methods = new LinkedHashMap<String, MethodInfo>();
 270     }
 271
 272     @Override
 273     public void setMethod (ClassFile cf, int methodIndex, int accessFlags, String name, String signature) {
 274       MethodInfo mi = MethodInfo.create(name, signature, accessFlags);
 275       curMi = mi;
 276     }
 277
 278     @Override
 279     public void setMethodDone (ClassFile cf, int methodIndex){
 280       curMi.setLocalVarAnnotations();
 281
 282       JVMClassInfo.this.setMethod(curMi);
 283     }
 284
 285     @Override
 286     public void setMethodAttribute (ClassFile cf, int methodIndex, int attrIndex, String name, int attrLength) {
 287       if (name == ClassFile.CODE_ATTR) {
 288         cf.parseCodeAttr(this, curMi);
 289
 290       } else if (name == ClassFile.SIGNATURE_ATTR) {
 291         cf.parseSignatureAttr(this, curMi);
 292
 293       } else if (name == ClassFile.EXCEPTIONS_ATTR) {
 294         cf.parseExceptionAttr(this, curMi);
 295
 296       } else if (name == ClassFile.RUNTIME_VISIBLE_ANNOTATIONS_ATTR) {
 297         cf.parseAnnotationsAttr(this, curMi);
 298
 299       } else if (name == ClassFile.RUNTIME_INVISIBLE_ANNOTATIONS_ATTR) {
 300         //cf.parseAnnotationsAttr(this, curMi);
 301       } else if (name == ClassFile.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS_ATTR) {
 302         cf.parseParameterAnnotationsAttr(this, curMi);
 303
 304       } else if (name == ClassFile.RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS_ATTR) {
 305         //cf.parseParameterAnnotationsAttr(this, curMi);
 306
 307       } else if (name == ClassFile.RUNTIME_VISIBLE_TYPE_ANNOTATIONS_ATTR) {
 308         cf.parseTypeAnnotationsAttr(this, curMi);
 309       }
 310
 311     }
 312
 313     //--- current methods throws list
 314     protected String[] exceptions;
 315
 316     @Override
 317     public void setExceptionCount (ClassFile cf, Object tag, int exceptionCount) {
 318       exceptions = new String[exceptionCount];
 319     }
 320
 321     @Override
 322     public void setException (ClassFile cf, Object tag, int exceptionIndex, String exceptionType) {
 323       exceptions[exceptionIndex] = Types.getClassNameFromTypeName(exceptionType);
 324     }
 325
 326     @Override
 327     public void setExceptionsDone (ClassFile cf, Object tag) {
 328       curMi.setThrownExceptions(exceptions);
 329     }
 330
 331     //--- current method exception handlers
 332     protected ExceptionHandler[] handlers;
 333
 334     @Override
 335     public void setExceptionHandlerTableCount (ClassFile cf, Object tag, int exceptionTableCount) {
 336       handlers = new ExceptionHandler[exceptionTableCount];
 337     }
 338
 339     @Override
 340     public void setExceptionHandler (ClassFile cf, Object tag, int handlerIndex,
 341             int startPc, int endPc, int handlerPc, String catchType) {
 342       ExceptionHandler xh = new ExceptionHandler(catchType, startPc, endPc, handlerPc);
 343       handlers[handlerIndex] = xh;
 344     }
 345
 346     @Override
 347     public void setExceptionHandlerTableDone (ClassFile cf, Object tag) {
 348       curMi.setExceptionHandlers(handlers);
 349     }
 350
 351     //--- current method code
 352     @Override
 353     public void setCode (ClassFile cf, Object tag, int maxStack, int maxLocals, int codeLength) {
 354       curMi.setMaxLocals(maxLocals);
 355       curMi.setMaxStack(maxStack);
 356
 357       cb.reset(cf, curMi);
 358
 359       cf.parseBytecode(cb, tag, codeLength);
 360       cb.installCode();
 361     }
 362
 363     @Override
 364     public void setCodeAttribute (ClassFile cf, Object tag, int attrIndex, String name, int attrLength) {
 365       if (name == ClassFile.LINE_NUMBER_TABLE_ATTR) {
 366         cf.parseLineNumberTableAttr(this, tag);
 367
 368       } else if (name == ClassFile.LOCAL_VAR_TABLE_ATTR) {
 369         cf.parseLocalVarTableAttr(this, tag);
 370
 371       } else if (name == ClassFile.RUNTIME_VISIBLE_TYPE_ANNOTATIONS_ATTR){
 372         cf.parseTypeAnnotationsAttr(this, tag);
 373       }
 374     }
 375
 376     //--- current method line numbers
 377     protected int[] lines, startPcs;
 378
 379     @Override
 380     public void setLineNumberTableCount (ClassFile cf, Object tag, int lineNumberCount) {
 381       lines = new int[lineNumberCount];
 382       startPcs = new int[lineNumberCount];
 383     }
 384
 385     @Override
 386     public void setLineNumber (ClassFile cf, Object tag, int lineIndex, int lineNumber, int startPc) {
 387       lines[lineIndex] = lineNumber;
 388       startPcs[lineIndex] = startPc;
 389     }
 390
 391     @Override
 392     public void setLineNumberTableDone (ClassFile cf, Object tag) {
 393       curMi.setLineNumbers(lines, startPcs);
 394     }
 395
 396     //--- current method local variables
 397     protected LocalVarInfo[] localVars;
 398
 399     @Override
 400     public void setLocalVarTableCount (ClassFile cf, Object tag, int localVarCount) {
 401       localVars = new LocalVarInfo[localVarCount];
 402     }
 403
 404     @Override
 405     public void setLocalVar (ClassFile cf, Object tag, int localVarIndex,
 406             String varName, String descriptor, int scopeStartPc, int scopeEndPc, int slotIndex) {
 407       LocalVarInfo lvi = new LocalVarInfo(varName, descriptor, "", scopeStartPc, scopeEndPc, slotIndex);
 408       localVars[localVarIndex] = lvi;
 409     }
 410
 411     @Override
 412     public void setLocalVarTableDone (ClassFile cf, Object tag) {
 413       curMi.setLocalVarTable(localVars);
 414     }
 415
 416     //--- annotations
 417     protected AnnotationInfo[] annotations;
 418     protected AnnotationInfo curAi;
 419     protected LinkedList<AnnotationInfo> annotationStack;
 420     protected LinkedList<Object[]> valuesStack;
 421     protected AnnotationInfo[][] parameterAnnotations;
 422     protected Object[] values;
 423     // true if we need to filter null annotations
 424     private boolean compactAnnotationArray = false;
 425
 426     //--- declaration annotations
 427
 428     @Override
 429     public void setAnnotationCount (ClassFile cf, Object tag, int annotationCount) {
 430       annotations = new AnnotationInfo[annotationCount];
 431     }
 432
 433     @Override
 434     public void setAnnotation (ClassFile cf, Object tag, int annotationIndex, String annotationType) {
 435       if (tag instanceof InfoObject) {
 436         if(annotationIndex == -1) {
 437           if(annotationStack == null) {
 438             assert valuesStack == null;
 439             valuesStack = new LinkedList<>();
 440             annotationStack = new LinkedList<>();
 441           }
 442           annotationStack.addFirst(curAi);
 443           valuesStack.addFirst(values);
 444         }
 445         try {
 446           curAi = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 447           if(annotationIndex != -1) {
 448             annotations[annotationIndex] = curAi;
 449           }
 450         } catch(ClassInfoException cie) {
 451           // if we can't parse a field, we're sunk, throw and tank the reflective call
 452           if(annotationIndex == -1) {
 453             throw cie;
 454           }
 455           compactAnnotationArray = true;
 456           annotations[annotationIndex] = null;
 457           // skip this annotation
 458           throw new SkipAnnotation();
 459         }
 460       }
 461     }
 462
 463     @Override
 464     public void setAnnotationsDone (ClassFile cf, Object tag) {
 465       if (tag instanceof InfoObject) {
 466         AnnotationInfo[] toSet;
 467         if(compactAnnotationArray) {
 468           int nAnnot = 0;
 469           for(AnnotationInfo ai : annotations) {
 470             if(ai != null) {
 471               nAnnot++;
 472             }
 473           }
 474           toSet = new AnnotationInfo[nAnnot];
 475           int idx = 0;
 476           for(AnnotationInfo ai : annotations) {
 477             if(ai != null) {
 478               toSet[idx++] = ai;
 479             }
 480           }
 481         } else {
 482           toSet = annotations;
 483         }
 484         ((InfoObject) tag).addAnnotations(toSet);
 485       }
 486       compactAnnotationArray = false;
 487     }
 488
 489     @Override
 490     public void setParameterCount (ClassFile cf, Object tag, int parameterCount) {
 491       parameterAnnotations = new AnnotationInfo[parameterCount][];
 492     }
 493
 494     @Override
 495     public void setParameterAnnotationCount (ClassFile cf, Object tag, int paramIndex, int annotationCount) {
 496       annotations = new AnnotationInfo[annotationCount];
 497       parameterAnnotations[paramIndex] = annotations;
 498     }
 499
 500     @Override
 501     public void setParameterAnnotation (ClassFile cf, Object tag, int annotationIndex, String annotationType) {
 502       try {
 503         curAi = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 504         annotations[annotationIndex] = curAi;
 505       } catch(ClassInfoException cie) {
 506         compactAnnotationArray = true;
 507         annotations[annotationIndex] = null;
 508         throw new SkipAnnotation();
 509       }
 510     }
 511
 512     @Override
 513     public void setParametersDone (ClassFile cf, Object tag) {
 514       curMi.setParameterAnnotations(parameterAnnotations);
 515     }
 516
 517     //--- Java 8 type annotations
 518
 519     @Override
 520     public void setTypeAnnotationCount(ClassFile cf, Object tag, int annotationCount){
 521       annotations = new AnnotationInfo[annotationCount];
 522     }
 523
 524     @Override
 525     public void setTypeParameterAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 526                                            int typeIndex, short[] typePath, String annotationType){
 527       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 528       curAi = new TypeParameterAnnotationInfo(base, targetType, typePath, typeIndex);
 529       annotations[annotationIndex] = curAi;
 530     }
 531     @Override
 532     public void setSuperTypeAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 533                                        int superTypeIdx, short[] typePath, String annotationType){
 534       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 535       curAi = new SuperTypeAnnotationInfo(base, targetType, typePath, superTypeIdx);
 536       annotations[annotationIndex] = curAi;
 537     }
 538     @Override
 539     public void setTypeParameterBoundAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 540                                        int typeIndex, int boundIndex, short[] typePath, String annotationType){
 541       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 542       curAi = new TypeParameterBoundAnnotationInfo(base, targetType, typePath, typeIndex, boundIndex);
 543       annotations[annotationIndex] = curAi;
 544     }
 545     @Override
 546     public void setTypeAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 547                                   short[] typePath, String annotationType){
 548       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 549       curAi = new TypeAnnotationInfo(base, targetType, typePath);
 550       annotations[annotationIndex] = curAi;
 551     }
 552     @Override
 553     public void setFormalParameterAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 554                                              int paramIndex, short[] typePath, String annotationType){
 555       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 556       curAi = new FormalParameterAnnotationInfo(base, targetType, typePath, paramIndex);
 557       annotations[annotationIndex] = curAi;
 558     }
 559     @Override
 560     public void setThrowsAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 561                                     int throwsTypeIdx, short[] typePath, String annotationType){
 562       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 563       curAi = new ThrowsAnnotationInfo(base, targetType, typePath, throwsTypeIdx);
 564       annotations[annotationIndex] = curAi;
 565     }
 566     @Override
 567     public void setVariableAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 568                                       long[] scopeEntries, short[] typePath, String annotationType){
 569       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 570       VariableAnnotationInfo vai = new VariableAnnotationInfo(base, targetType, typePath, scopeEntries);
 571       curAi = vai;
 572       annotations[annotationIndex] = curAi;
 573     }
 574     @Override
 575     public void setExceptionParameterAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 576                                                 int exceptionIndex, short[] typePath, String annotationType){
 577       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 578       curAi= new ExceptionParameterAnnotationInfo(base, targetType, typePath, exceptionIndex);
 579       annotations[annotationIndex] = curAi;
 580     }
 581     @Override
 582     public void setBytecodeAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 583                                       int offset, short[] typePath, String annotationType){
 584       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 585       curAi = new BytecodeAnnotationInfo(base, targetType, typePath, offset);
 586       annotations[annotationIndex] = curAi;
 587     }
 588     @Override
 589     public void setBytecodeTypeParameterAnnotation(ClassFile cf, Object tag, int annotationIndex, int targetType,
 590                                              int offset, int typeArgIdx, short[] typePath, String annotationType){
 591       AnnotationInfo base = getResolvedAnnotationInfo(Types.getClassNameFromTypeName(annotationType));
 592       curAi = new BytecodeTypeParameterAnnotationInfo(base, targetType, typePath, offset, typeArgIdx);
 593       annotations[annotationIndex] = curAi;
 594     }
 595
 596     @Override
 597     public void setTypeAnnotationsDone(ClassFile cf, Object tag) {
 598       if (tag instanceof InfoObject) {
 599         int len = annotations.length;
 600         AbstractTypeAnnotationInfo[] tais = new AbstractTypeAnnotationInfo[annotations.length];
 601         for (int i=0; i<len; i++){
 602           tais[i] = (AbstractTypeAnnotationInfo)annotations[i];
 603         }
 604
 605         // we can get them in batches (e.g. VariableTypeAnnos from code attrs and ReturnTypeAnnos from method attrs
 606         ((InfoObject) tag).addTypeAnnotations( tais);
 607       }
 608     }
 609
 610     //--- AnnotationInfo values entries
 611     @Override
 612     public void setAnnotationValueCount (ClassFile cf, Object tag, int annotationIndex, int nValuePairs) {
 613       // if we have values, we need to clone the defined annotation so that we can overwrite entries
 614       curAi = curAi.cloneForOverriddenValues();
 615       if(annotationIndex != -1) {
 616         annotations[annotationIndex] = curAi;
 617       }
 618     }
 619
 620     @Override
 621     public void setPrimitiveAnnotationValue (ClassFile cf, Object tag, int annotationIndex, int valueIndex,
 622             String elementName, int arrayIndex, Object val) {
 623       if (arrayIndex >= 0) {
 624         values[arrayIndex] = val;
 625       } else {
 626         curAi.setClonedEntryValue(elementName, val);
 627       }
 628     }
 629
 630     @Override
 631     public void setAnnotationFieldValue(ClassFile cf, Object tag, int annotationIndex, int valueIndex, String elementName, int arrayIndex) {
 632       assert annotationStack.size() > 0;
 633       AnnotationInfo ai = curAi;
 634       values = valuesStack.pop();
 635       curAi = annotationStack.pop();
 636       if(arrayIndex >= 0) {
 637         values[arrayIndex] = ai;
 638       } else {
 639         curAi.setClonedEntryValue(elementName, ai);
 640       }
 641     }
 642
 643     @Override
 644     public void setStringAnnotationValue (ClassFile cf, Object tag, int annotationIndex, int valueIndex,
 645             String elementName, int arrayIndex, String val) {
 646       if (arrayIndex >= 0) {
 647         values[arrayIndex] = val;
 648       } else {
 649         curAi.setClonedEntryValue(elementName, val);
 650       }
 651     }
 652
 653     @Override
 654     public void setClassAnnotationValue (ClassFile cf, Object tag, int annotationIndex, int valueIndex, String elementName,
 655             int arrayIndex, String typeName) {
 656       Object val = AnnotationInfo.getClassValue(typeName);
 657       if (arrayIndex >= 0) {
 658         values[arrayIndex] = val;
 659       } else {
 660         curAi.setClonedEntryValue(elementName, val);
 661       }
 662     }
 663
 664     @Override
 665     public void setEnumAnnotationValue (ClassFile cf, Object tag, int annotationIndex, int valueIndex,
 666             String elementName, int arrayIndex, String enumType, String enumValue) {
 667       Object val = AnnotationInfo.getEnumValue(enumType, enumValue);
 668       if (arrayIndex >= 0) {
 669         values[arrayIndex] = val;
 670       } else {
 671         curAi.setClonedEntryValue(elementName, val);
 672       }
 673     }
 674
 675     @Override
 676     public void setAnnotationValueElementCount (ClassFile cf, Object tag, int annotationIndex, int valueIndex,
 677             String elementName, int elementCount) {
 678       values = new Object[elementCount];
 679     }
 680
 681     @Override
 682     public void setAnnotationValueElementsDone (ClassFile cf, Object tag, int annotationIndex, int valueIndex, String elementName) {
 683       curAi.setClonedEntryValue(elementName, values);
 684     }
 685
 686     //--- common attrs
 687     @Override
 688     public void setSignature (ClassFile cf, Object tag, String signature) {
 689       if (tag instanceof GenericSignatureHolder) {
 690         ((GenericSignatureHolder) tag).setGenericSignature(signature);
 691       }
 692     }
 693   }
 694
 695   // since nested class init locking can explode the state space, we make it optional and controllable
 696   protected static boolean nestedInit;
 697   protected static StringSetMatcher includeNestedInit;
 698   protected static StringSetMatcher excludeNestedInit;
 699
 700   protected static boolean init (Config config){
 701     nestedInit = config.getBoolean("jvm.nested_init", false);
 702     if (nestedInit){
 703       includeNestedInit =  StringSetMatcher.getNonEmpty(config.getStringArray("jvm.nested_init.include"));
 704       excludeNestedInit = StringSetMatcher.getNonEmpty(config.getStringArray("jvm.nested_init.exclude"));
 705     }
 706
 707     return true;
 708   }
 709
 710   JVMClassInfo (String name, ClassLoaderInfo cli, ClassFile cf, String srcUrl, JVMCodeBuilder cb) throws ClassParseException {
 711     super( name, cli, srcUrl);
 712
 713     new Initializer( cf, cb); // we just need the ctor
 714
 715     resolveAndLink();
 716   }
 717
 718
 719   //--- for annotation classinfos
 720
 721   // called on the annotation classinfo
 722   @Override
 723   protected ClassInfo createAnnotationProxy (String proxyName){
 724     return new JVMClassInfo (this, proxyName, classLoader, null);
 725   }
 726
 727   // concrete proxy ctor
 728   protected JVMClassInfo (ClassInfo ciAnnotation, String proxyName, ClassLoaderInfo cli, String url) {
 729     super( ciAnnotation, proxyName, cli, url);
 730   }
 731
 732   /**
 733    * This is called on the functional interface type. It creates a synthetic type which
 734    * implements the functional interface and contains a method capturing the behavior
 735    * of the lambda expression.
 736    */
 737   @Override
 738   protected ClassInfo createFuncObjClassInfo (BootstrapMethodInfo bootstrapMethod, String name, String samUniqueName, String[] fieldTypesName) {
 739     return new JVMClassInfo(this, bootstrapMethod, name, samUniqueName, fieldTypesName);
 740   }
 741
 742   protected JVMClassInfo (ClassInfo funcInterface, BootstrapMethodInfo bootstrapMethod, String name, String samUniqueName, String[] fieldTypesName) {
 743     super(funcInterface, bootstrapMethod, name, fieldTypesName);
 744
 745     // creating a method corresponding to the single abstract method of the functional interface
 746     methods = new HashMap<String, MethodInfo>();
 747
 748     MethodInfo fiMethod = funcInterface.getInterfaceAbstractMethod();
 749     int modifiers = fiMethod.getModifiers() & (~Modifier.ABSTRACT);
 750     int nLocals = fiMethod.getArgumentsSize();
 751     int nOperands = this.nInstanceFields + nLocals;
 752
 753     MethodInfo mi = new MethodInfo(fiMethod.getName(), fiMethod.getSignature(), modifiers, nLocals, nOperands);
 754     mi.linkToClass(this);
 755
 756     methods.put(mi.getUniqueName(), mi);
 757
 758     setLambdaDirectCallCode(mi, bootstrapMethod);
 759
 760     try {
 761       resolveAndLink();
 762     } catch (ClassParseException e) {
 763       // we do not even get here - this a synthetic class, and at this point
 764       // the interfaces are already loaded.
 765     }
 766   }
 767
 768   /**
 769    * perform initialization of this class and its not-yet-initialized superclasses (top down),
 770    * which includes calling clinit() methods
 771    *
 772    * This is overridden here to model a questionable yet consequential behavior of hotspot, which
 773    * is holding derived class locks when initializing base classes. The generic implementation in
 774    * ClassInfo uses non-nested locks (i.e. A.clinit() only synchronizes on A.class) and hence cannot
 775    * produce the same static init deadlocks as hotspot. In order to catch such defects we implement
 776    * nested locking here.
 777    *
 778    * The main difference is that the generic implementation only pushes DCSFs for required clinits
 779    * and otherwise doesn't lock anything. Here, we create one static init specific DCSF which wraps
 780    * all clinits in nested monitorenter/exits. We create this even if there is no clinit so that we
 781    * mimic hotspot locking.
 782    *
 783    * Note this scheme also enables us to get rid of the automatic clinit sync (they don't have
 784    * a 0x20 sync modifier in classfiles)
 785    *
 786    * @return true if client needs to re-execute because we pushed DirectCallStackFrames
 787    */
 788   @Override
 789   public boolean initializeClass(ThreadInfo ti) {
 790     if (needsInitialization(ti)) {
 791       if (nestedInit && StringSetMatcher.isMatch(name, includeNestedInit, excludeNestedInit)) {
 792         registerClass(ti); // this is recursively upwards
 793         int nOps = 2 * (getNumberOfSuperClasses() + 1); // this is just an upper bound for the number of operands we need
 794
 795         MethodInfo miInitialize = new MethodInfo("[initializeClass]", "()V", Modifier.STATIC, 0, nOps);
 796         JVMDirectCallStackFrame frame = new JVMDirectCallStackFrame(miInitialize, null);
 797         JVMCodeBuilder cb = getSystemCodeBuilder(null, miInitialize);
 798
 799         addClassInit(ti, frame, cb); // this is recursively upwards until we hit a initialized superclass
 800         cb.directcallreturn();
 801         cb.installCode();
 802
 803         // this is normally initialized in the ctor, but at that point we don't have the code yet
 804         frame.setPC(miInitialize.getFirstInsn());
 805
 806         ti.pushFrame(frame);
 807         return true; // client has to re-execute, we pushed a stackframe
 808
 809
 810       } else { // use generic initialization without nested locks (directly calling clinits)
 811         return super.initializeClass(ti);
 812       }
 813
 814     } else {
 815       return false; // nothing to do
 816     }
 817   }
 818
 819   protected void addClassInit (ThreadInfo ti, JVMDirectCallStackFrame frame, JVMCodeBuilder cb){
 820     int clsObjRef = getClassObjectRef();
 821
 822     frame.pushRef(clsObjRef);
 823     cb.monitorenter();
 824
 825     if (superClass != null && superClass.needsInitialization(ti)) {
 826       ((JVMClassInfo) superClass).addClassInit(ti, frame, cb);      // go recursive
 827     }
 828
 829     if (getMethod("<clinit>()V", false) != null) { // do we have a clinit
 830       cb.invokeclinit(this);
 831     } else {
 832       cb.finishclinit(this);
 833       // we can't just do call ci.setInitialized() since that has to be deferred
 834     }
 835
 836     frame.pushRef(clsObjRef);
 837     cb.monitorexit();
 838   }
 839
 840   //--- call processing
 841
 842   protected JVMCodeBuilder getSystemCodeBuilder (ClassFile cf, MethodInfo mi){
 843     JVMSystemClassLoaderInfo sysCl = (JVMSystemClassLoaderInfo) ClassLoaderInfo.getCurrentSystemClassLoader();
 844     JVMCodeBuilder cb = sysCl.getSystemCodeBuilder(cf, mi);
 845
 846     return cb;
 847   }
 848
 849   /**
 850    * to be called from super proxy ctor
 851    * this needs to be in the VM specific ClassInfo because we need to create code
 852    */
 853   @Override
 854   protected void setAnnotationValueGetterCode (MethodInfo pmi, FieldInfo fi){
 855     JVMCodeBuilder cb = getSystemCodeBuilder(null, pmi);
 856
 857     cb.aload(0);
 858     cb.getfield( pmi.getName(), name, pmi.getReturnType());
 859     if (fi.isReference()) {
 860       cb.areturn();
 861     } else {
 862       if (fi.getStorageSize() == 1) {
 863         cb.ireturn();
 864       } else {
 865         cb.lreturn();
 866       }
 867     }
 868
 869     cb.installCode();
 870   }
 871
 872   @Override
 873   protected void setDirectCallCode (MethodInfo miDirectCall, MethodInfo miCallee){
 874     JVMCodeBuilder cb = getSystemCodeBuilder(null, miDirectCall);
 875
 876     String calleeName = miCallee.getName();
 877     String calleeSig = miCallee.getSignature();
 878
 879     if (miCallee.isStatic()){
 880       if (miCallee.isClinit()) {
 881         cb.invokeclinit(this);
 882       } else {
 883         cb.invokestatic( name, calleeName, calleeSig);
 884       }
 885     } else if (name.equals("<init>") || miCallee.isPrivate()){
 886       cb.invokespecial( name, calleeName, calleeSig);
 887     } else {
 888       cb.invokevirtual( name, calleeName, calleeSig);
 889     }
 890
 891     cb.directcallreturn();
 892
 893     cb.installCode();
 894   }
 895
 896   @Override
 897   protected void setNativeCallCode (NativeMethodInfo miNative){
 898     JVMCodeBuilder cb = getSystemCodeBuilder(null, miNative);
 899
 900     cb.executenative(miNative);
 901     cb.nativereturn();
 902
 903     cb.installCode();
 904   }
 905
 906   @Override
 907   protected void setRunStartCode (MethodInfo miStub, MethodInfo miRun){
 908     JVMCodeBuilder cb = getSystemCodeBuilder(null, miStub);
 909
 910     cb.runStart( miStub);
 911     cb.invokevirtual( name, miRun.getName(), miRun.getSignature());
 912     cb.directcallreturn();
 913
 914     cb.installCode();
 915   }
 916
 917   /**
 918    * This method creates the body of the function object method that captures the
 919    * lambda behavior.
 920    */
 921   @Override
 922   protected void setLambdaDirectCallCode (MethodInfo miDirectCall, BootstrapMethodInfo bootstrapMethod) {
 923
 924     MethodInfo miCallee = bootstrapMethod.getLambdaBody();
 925     String samSignature = bootstrapMethod.getSamDescriptor();
 926     JVMCodeBuilder cb = getSystemCodeBuilder(null, miDirectCall);
 927
 928     String calleeName = miCallee.getName();
 929     String calleeSig = miCallee.getSignature();
 930
 931     ClassInfo callerCi = miDirectCall.getClassInfo();
 932
 933     // loading free variables, which are used in the body of the lambda
 934     // expression and captured by the lexical scope. These variables
 935     // are stored by the fields of the synthetic function object class
 936     int n = callerCi.getNumberOfInstanceFields();
 937     for(int i=0; i<n; i++) {
 938       cb.aload(0);
 939       FieldInfo fi = callerCi.getInstanceField(i);
 940
 941       cb.getfield(fi.getName(), callerCi.getName(), Types.getTypeSignature(fi.getSignature(), false));
 942     }
 943
 944     // adding bytecode instructions to load input parameters of the lambda expression
 945     n = miDirectCall.getArgumentsSize();
 946     for(int i=1; i<n; i++) {
 947       cb.aload(i);
 948     }
 949
 950     String calleeClass = miCallee.getClassName();
 951
 952     // adding the bytecode instruction to invoke lambda method
 953     switch (bootstrapMethod.getLambdaRefKind()) {
 954     case ClassFile.REF_INVOKESTATIC:
 955       cb.invokestatic(calleeClass, calleeName, calleeSig);
 956       break;
 957     case ClassFile.REF_INVOKEINTERFACE:
 958       cb.invokeinterface(calleeClass, calleeName, calleeSig);
 959       break;
 960     case ClassFile.REF_INVOKEVIRTUAL:
 961       cb.invokevirtual(calleeClass, calleeName, calleeSig);
 962       break;
 963     case ClassFile.REF_NEW_INVOKESPECIAL:
 964       cb.new_(calleeClass);
 965       cb.invokespecial(calleeClass, calleeName, calleeSig);
 966       break;
 967     case ClassFile.REF_INVOKESPECIAL:
 968       cb.invokespecial(calleeClass, calleeName, calleeSig);
 969       break;
 970     }
 971
 972     String returnType = Types.getReturnTypeSignature(samSignature);
 973     int  len = returnType.length();
 974     char c = returnType.charAt(0);
 975
 976     // adding a return statement for function object method
 977     if (len == 1) {
 978       switch (c) {
 979       case 'B':
 980       case 'I':
 981       case 'C':
 982       case 'Z':
 983       case 'S':
 984         cb.ireturn();
 985         break;
 986       case 'D':
 987         cb.dreturn();
 988         break;
 989       case 'J':
 990         cb.lreturn();
 991         break;
 992       case 'F':
 993         cb.freturn();
 994         break;
 995       case 'V':
 996         cb.return_();
 997         break;
 998       }
 999     } else {
1000       cb.areturn();
1001     }
1002
1003     cb.installCode();
1004   }
1005
1006   // create a stack frame that has properly initialized arguments
1007   @Override
1008   public StackFrame createStackFrame (ThreadInfo ti, MethodInfo callee){
1009
1010     if (callee.isMJI()){
1011       NativeMethodInfo nativeCallee = (NativeMethodInfo) callee;
1012       JVMNativeStackFrame calleeFrame = new JVMNativeStackFrame( nativeCallee);
1013       calleeFrame.setArguments( ti);
1014       return calleeFrame;
1015
1016     } else {
1017       JVMStackFrame calleeFrame = new JVMStackFrame( callee);
1018       calleeFrame.setCallArguments( ti);
1019       return calleeFrame;
1020     }
1021   }
1022
1023   @Override
1024   public DirectCallStackFrame createDirectCallStackFrame (ThreadInfo ti, MethodInfo miCallee, int nLocals){
1025     int nOperands = miCallee.getNumberOfCallerStackSlots();
1026
1027     MethodInfo miDirect = new MethodInfo(miCallee, nLocals, nOperands);
1028     setDirectCallCode( miDirect, miCallee);
1029
1030     return new JVMDirectCallStackFrame( miDirect, miCallee);
1031   }
1032
1033   /**
1034    * while this is a normal DirectCallStackFrame, it has different code which has to be created here
1035    */
1036   @Override
1037   public DirectCallStackFrame createRunStartStackFrame (ThreadInfo ti, MethodInfo miRun){
1038     MethodInfo miDirect = new MethodInfo( miRun, 0, 1);
1039     setRunStartCode( miDirect, miRun);
1040
1041     return new JVMDirectCallStackFrame( miDirect, miRun);
1042   }
1043
1044 }