Java Code Examples for org.objectweb.asm.Opcodes#ACC_SUPER

/**
 * Generates and returns the bytecode for an exception class.
 * 
 * @param name The name of the class to generate.
 * @param superName The name of the superclass.
 * @return The bytecode for the new class.
 */
public static byte[] generateExceptionClass(String name, String superName) {
    ClassWriter out = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
    
    // This class only exists to be a type - the superclasses always do everything.
    // (common access for all classes we generate - public and "super", meaning post-1.1 invokestatic).
    int access = Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER;
    // We ignore generics, so null signature.
    String signature = null;
    // We implement no interfaces.
    String[] interfaces = new String[0];
    out.visit(CLASS_VERSION, access, name, signature, superName, interfaces);
    
    // Generate the constructors.
    populateExceptionConstructors(out, superName);
    
    // Finish this and dump the bytes.
    out.visitEnd();
    return out.toByteArray();
}
 

/**
     * Turns this class into an override class that can be loaded by our custom class loader:
     *<ul>
     *   <li>Make the class name be OriginalName$starkoverride</li>
     *   <li>Ensure the class derives from java.lang.Object, no other inheritance</li>
     *   <li>Ensure the class has a public parameterless constructor that is a noop.</li>
     *</ul>
     */
    @Override
    public void visit(int version, int access, String name, String signature, String superName,
                      String[] interfaces) {
        super.visit(version, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER,
                name + OVERRIDE_SUFFIX, signature, "java/lang/Object",
                new String[]{CHANGE_TYPE.getInternalName()});

//        if (DEBUG) {
//            System.out.println(">>>>>>>> Processing " + name + "<<<<<<<<<<<<<");
//        }

        visitedClassName = name;
        visitedSuperName = superName;
        instanceToStaticDescPrefix = "(L" + visitedClassName + ";";

        // Create empty constructor
        MethodVisitor mv = super
                .visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
        mv.visitCode();
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V",
                false);
        mv.visitInsn(Opcodes.RETURN);
        mv.visitMaxs(0, 0);
        mv.visitEnd();

        super.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_STATIC,
                "$starkObsolete", "Z", null, null);
    }
 

/**
 * Generates and returns the bytecode for a wrapper class.
 * 
 * @param name The name of the class to generate.
 * @param superName The name of the superclass.
 * @return The bytecode for the new class.
 */
public static byte[] generateWrapperClass(String name, String superName) {
    ClassWriter out = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
    
    // This class only exists to be a type - the superclasses always do everything.
    // (common access for all classes we generate - public and "super", meaning post-1.1 invokestatic).
    int access = Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER;
    // We ignore generics, so null signature.
    String signature = null;
    // We implement no interfaces.
    String[] interfaces = new String[0];
    out.visit(CLASS_VERSION, access, name, signature, superName, interfaces);
    
    // Generate the singular constructor.
    MethodVisitor methodVisitor = out.visitMethod(Opcodes.ACC_PUBLIC, INIT_NAME, ONE_ARG_DESCRIPTOR, null, null);
    methodVisitor.visitCode();
    methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
    methodVisitor.visitVarInsn(Opcodes.ALOAD, 1);
    methodVisitor.visitMethodInsn(Opcodes.INVOKESPECIAL, superName, INIT_NAME, ONE_ARG_DESCRIPTOR, false);
    methodVisitor.visitInsn(Opcodes.RETURN);
    methodVisitor.visitMaxs(2, 2);
    methodVisitor.visitEnd();
    
    // Finish this and dump the bytes.
    out.visitEnd();
    return out.toByteArray();
}
 

/**
 * Generates and returns the bytecode for a "legacy-style" exception class.  That is, the kind which have their own getCause and getException implementations.
 * In our implementation, we will strictly wrap the super-class, and append a getException method.
 * 
 * @param name The name of the class to generate.
 * @param superName The name of the superclass.
 * @return The bytecode for the new class.
 */
public static byte[] generateLegacyExceptionClass(String name, String superName) {
    ClassWriter out = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
    
    // This class only exists to be a type - the superclasses always do everything.
    // (common access for all classes we generate - public and "super", meaning post-1.1 invokestatic).
    int access = Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER;
    // We ignore generics, so null signature.
    String signature = null;
    // We implement no interfaces.
    String[] interfaces = new String[0];
    out.visit(CLASS_VERSION, access, name, signature, superName, interfaces);
    
    // Generate the constructors.
    populateExceptionConstructors(out, superName);
    
    // Generate the getException method.
    {
        // NOTE:  These methods need to exist with the UserClassMappingVisitor.mapMethodName("" prefixes, since the shadow library is post-shadow.
        String returnThrowable = "()L" + PackageConstants.kShadowSlashPrefix + "java/lang/Throwable;";
        // This method does not require a charge energy call since it's calling avm_getCause and the billing is done there
        MethodVisitor methodVisitor = out.visitMethod(Opcodes.ACC_PUBLIC, NamespaceMapper.mapMethodName("getException"), returnThrowable, null, null);
        methodVisitor.visitCode();
        methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
        methodVisitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, name, NamespaceMapper.mapMethodName("getCause"), returnThrowable, false);
        methodVisitor.visitInsn(Opcodes.ARETURN);
        methodVisitor.visitMaxs(1, 1);
        methodVisitor.visitEnd();
    }
    
    // Finish this and dump the bytes.
    out.visitEnd();
    return out.toByteArray();
}
 

public static int transformClassAccessForInstantRun(int access) {
    IncrementalVisitor.AccessRight accessRight = IncrementalVisitor.AccessRight.fromNodeAccess(access);
    int fixedVisibility = accessRight == IncrementalVisitor.AccessRight.PACKAGE_PRIVATE
            ? access | Opcodes.ACC_PUBLIC
            : access;

    // TODO: only do this on KitKat?
    return fixedVisibility | Opcodes.ACC_SUPER;
}
 

private static void readClassIndex(
    Map<ClassIndex, File> indexes, InputStream in, File file, boolean allowSuper)
    throws IOException {

  ClassReader classReader = new ClassReader(in);
  String className = ClassNameUtils.replaceSlash(classReader.getClassName());

  boolean projectOutput = file.isDirectory();

  int access = classReader.getAccess();

  boolean isPublic = (Opcodes.ACC_PUBLIC & access) == Opcodes.ACC_PUBLIC;
  boolean isProtected = (Opcodes.ACC_PROTECTED & access) == Opcodes.ACC_PROTECTED;

  boolean isInterface = (Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE;
  boolean isAnnotation = (Opcodes.ACC_ANNOTATION & access) == Opcodes.ACC_ANNOTATION;

  boolean isSuper = false;

  if (allowSuper) {
    isSuper = (Opcodes.ACC_SUPER & access) == Opcodes.ACC_SUPER;
  }
  if (projectOutput || (isPublic || isProtected || isSuper)) {
    String pkg = ClassNameUtils.getPackage(className);
    boolean onlyClassName = !preloadClassPackages.contains(pkg);
    ClassAnalyzeVisitor classAnalyzeVisitor =
        new ClassAnalyzeVisitor(className, onlyClassName, false);
    classReader.accept(classAnalyzeVisitor, 0);
    ClassIndex classIndex = classAnalyzeVisitor.getClassIndex();
    if (!classIndex.isAnonymous) {
      classIndex.setInterface(isInterface);
      classIndex.setAnnotation(isAnnotation);
      indexes.put(classIndex, file);
      if (!onlyClassName) {
        innerCache.putIfAbsent(className, classAnalyzeVisitor.getMembers());
      }
    }
  }
}
 

/**
 * Turns this class into an override class that can be loaded by our custom class loader:
 * <ul>
 * <li>Make the class name be OriginalName$override</li>
 * <li>Ensure the class derives from java.lang.Object, no other inheritance</li></li>
 * <li>Ensure the class has a public parameterless constructor that is a noop.</li></li>
 * </ul>
 */
@Override
public void visit(int version, int access, String name, String signature, String superName,
                  String[] interfaces) {
    super.visit(version, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER,
            name + OVERRIDE_SUFFIX, signature, "java/lang/Object",
            new String[]{CHANGE_TYPE.getInternalName()});

    if (DEBUG) {
        System.out.println(">>>>>>>> Processing " + name + "<<<<<<<<<<<<<");
    }

    visitedClassName = name;
    visitedSuperName = superName;
    instanceToStaticDescPrefix = "(L" + visitedClassName + ";";

    // Create empty constructor
    MethodVisitor mv = super
            .visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
    mv.visitCode();
    mv.visitVarInsn(Opcodes.ALOAD, 0);
    mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V",
            false);
    mv.visitInsn(Opcodes.RETURN);
    mv.visitMaxs(0, 0);
    mv.visitEnd();

    super.visitField(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_STATIC,
            "$obsolete", "Z", null, null);
}
 

@Override
public void visit(int version, int access, String name,
		String signature, String superName, String[] interfaces) {
	if(!superName.equals("java/lang/Object"))
	{
		System.err.println("WARNING: " + name + " already has a super class which will be overwritten: " + superName 
				+ "\nThis means that some other mod might no longer work properly!");
	}
	super.visit(version, access+Opcodes.ACC_SUPER, name, signature, EntityObject.class.getName().replace('.', '/'), interfaces);
}
 

public ClassCode(ClassNode classNode) {
    version = classNode.version;
    access = classNode.access;
    name = classNode.name;
    signature = classNode.signature;
    superName = classNode.superName;
    interfaces = ListUtils.emptyIfNull(classNode.interfaces);
    sourceFile = classNode.sourceFile;
    sourceDebug = classNode.sourceDebug;
    module = classNode.module;
    outerClass = classNode.outerClass;
    outerMethod = classNode.outerMethod;
    outerMethodDesc = classNode.outerMethodDesc;
    visibleAnnotations = ListUtils.emptyIfNull(classNode.visibleAnnotations);
    invisibleAnnotations = ListUtils.emptyIfNull(classNode.invisibleAnnotations);
    visibleTypeAnnotations = ListUtils.emptyIfNull(classNode.visibleTypeAnnotations);
    invisibleTypeAnnotations = ListUtils.emptyIfNull(classNode.invisibleTypeAnnotations);
    attrs = ListUtils.emptyIfNull(classNode.attrs);
    innerClasses = ListUtils.emptyIfNull(classNode.innerClasses);
    nestHostClass = classNode.nestHostClass;
    nestMembers = ListUtils.emptyIfNull(classNode.nestMembers);
    //fields = ListUtils.emptyIfNull(classNode.fields);
    //methods = ListUtils.emptyIfNull(classNode.methods);
    final List<FieldNode> fieldNodes = ListUtils.emptyIfNull(classNode.fields);
    fields = new LinkedHashMap<>(hashMapInitialCapacity(fieldNodes.size()));
    for (FieldNode fieldNode : fieldNodes) {
        final FieldCode fieldCode = new FieldCode(fieldNode);
        fields.put(fieldCode.name, fieldCode);
    }
    final List<MethodNode> methodNodes = ListUtils.emptyIfNull(classNode.methods);
    methods = new ArrayList<>(arrayListInitialCapacity(methodNodes.size()));
    methodMap = new LinkedHashMap<>(hashMapInitialCapacity(methodNodes.size() * 2));
    for (MethodNode methodNode : methodNodes) {
        final MethodCode methodCode = new MethodCode(this, methodNode);
        methods.add(methodCode);
        methodMap.put(methodCode.nameDesc, methodCode);
        if (!methodMap.containsKey(methodCode.name)) {
            methodMap.put(methodCode.name, methodCode);
        }
    }
    variableType = VariableType.valueOf(name);
    isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
    isSuper = (access & Opcodes.ACC_SUPER) != 0;
    isAbstract = (access & Opcodes.ACC_ABSTRACT) != 0;
    isV1_6 = (version & Opcodes.V1_6) != 0;
    isV1_8 = (version & Opcodes.V1_8) != 0;
    simpleName = getSimpleName();
}
 

public ClassCode(ClassNode classNode) {
    version = classNode.version;
    access = classNode.access;
    name = classNode.name;
    signature = classNode.signature;
    superName = classNode.superName;
    interfaces = ListUtils.emptyIfNull(classNode.interfaces);
    sourceFile = classNode.sourceFile;
    sourceDebug = classNode.sourceDebug;
    module = classNode.module;
    outerClass = classNode.outerClass;
    outerMethod = classNode.outerMethod;
    outerMethodDesc = classNode.outerMethodDesc;
    visibleAnnotations = ListUtils.emptyIfNull(classNode.visibleAnnotations);
    invisibleAnnotations = ListUtils.emptyIfNull(classNode.invisibleAnnotations);
    visibleTypeAnnotations = ListUtils.emptyIfNull(classNode.visibleTypeAnnotations);
    invisibleTypeAnnotations = ListUtils.emptyIfNull(classNode.invisibleTypeAnnotations);
    attrs = ListUtils.emptyIfNull(classNode.attrs);
    innerClasses = ListUtils.emptyIfNull(classNode.innerClasses);
    nestHostClassExperimental = classNode.nestHostClassExperimental;
    nestMembersExperimental = ListUtils.emptyIfNull(classNode.nestMembersExperimental);
    //fields = ListUtils.emptyIfNull(classNode.fields);
    //methods = ListUtils.emptyIfNull(classNode.methods);
    final List<FieldNode> fieldNodes = ListUtils.emptyIfNull(classNode.fields);
    fields = new LinkedHashMap<>(hashMapInitialCapacity(fieldNodes.size()));
    for (FieldNode fieldNode : fieldNodes) {
        final FieldCode fieldCode = new FieldCode(fieldNode);
        fields.put(fieldCode.name, fieldCode);
    }
    final List<MethodNode> methodNodes = ListUtils.emptyIfNull(classNode.methods);
    methods = new ArrayList<>(arrayListInitialCapacity(methodNodes.size()));
    methodMap = new LinkedHashMap<>(hashMapInitialCapacity(methodNodes.size() * 2));
    for (MethodNode methodNode : methodNodes) {
        final MethodCode methodCode = new MethodCode(this, methodNode);
        methods.add(methodCode);
        methodMap.put(methodCode.nameDesc, methodCode);
        if (!methodMap.containsKey(methodCode.name)) {
            methodMap.put(methodCode.name, methodCode);
        }
    }
    variableType = VariableType.valueOf(name);
    isInterface = (access & Opcodes.ACC_INTERFACE) != 0;
    isSuper = (access & Opcodes.ACC_SUPER) != 0;
    isAbstract = (access & Opcodes.ACC_ABSTRACT) != 0;
    isV1_6 = (version & Opcodes.V1_6) != 0;
    isV1_8 = (version & Opcodes.V1_8) != 0;
    simpleName = getSimpleName();
}
 

static void appendAccess(final int access, final StringBuilder sb) {
  if ((access & Opcodes.ACC_PUBLIC) != 0) {
    sb.append("public ");
  }
  if ((access & Opcodes.ACC_PRIVATE) != 0) {
    sb.append("private ");
  }
  if ((access & Opcodes.ACC_PROTECTED) != 0) {
    sb.append("protected ");
  }
  if ((access & Opcodes.ACC_FINAL) != 0) {
    if ((access & ACCESS_MODULE) == 0) {
      sb.append("final ");
    } else {
      sb.append("transitive ");
    }
  }
  if ((access & Opcodes.ACC_STATIC) != 0) {
    sb.append("static ");
  }
  if ((access & Opcodes.ACC_SUPER) != 0) {
    if ((access & ACCESS_CLASS) == 0) {
      if ((access & ACCESS_MODULE_REQUIRES) != 0) {
        sb.append("transitive ");
      } else {
        if ((access & ACCESS_MODULE) == 0) {
          sb.append("synchronized ");
        } else {
          sb.append("open ");
        }
      }
    } else {
      sb.append("super ");
    }
  }
  if ((access & Opcodes.ACC_VOLATILE) != 0) {
    if ((access & ACCESS_FIELD) == 0) {
      sb.append("bridge ");
    } else {
      if ((access & ACCESS_MODULE_REQUIRES) == 0) {
        sb.append("volatile ");
      } else {
        sb.append("static ");
      }
    }
  }
  if ((access & Opcodes.ACC_TRANSIENT) != 0) {
    if ((access & ACCESS_FIELD) == 0) {
      sb.append("varargs ");
    } else {
      sb.append("transient ");
    }
  }
  if ((access & Opcodes.ACC_NATIVE) != 0) {
    sb.append("native ");
  }
  if ((access & Opcodes.ACC_STRICT) != 0) {
    sb.append("strict ");
  }
  if ((access & Opcodes.ACC_INTERFACE) != 0) {
    sb.append("interface ");
  }
  if ((access & Opcodes.ACC_ABSTRACT) != 0) {
    sb.append("abstract ");
  }
  if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
    sb.append("synthetic ");
  }
  if ((access & Opcodes.ACC_ANNOTATION) != 0) {
    sb.append("annotation ");
  }
  if ((access & Opcodes.ACC_ENUM) != 0) {
    sb.append("enum ");
  }
  if ((access & Opcodes.ACC_DEPRECATED) != 0) {
    sb.append("deprecated ");
  }
  if ((access & Opcodes.ACC_MANDATED) != 0) {
    if ((access & ACCESS_CLASS) == 0) {
      sb.append("module ");
    } else {
      sb.append("mandated ");
    }
  }
}
 

/**
 * Utility method to get the access modifiers of a Host
 * @param modVal The bitset representation of the Host's modifiers
 * @param host The Host (SootClass, SootField or SootMethod) the modifiers are to be retrieved from
 * @return A bitset representation of the Host's modifiers in ASM's internal representation
 */
protected static int getModifiers(int modVal, Host host) {
	int modifier = 0;
	// Retrieve visibility-modifier
	if (Modifier.isPublic(modVal)) {
		modifier |= Opcodes.ACC_PUBLIC;
	} else if (Modifier.isPrivate(modVal)) {
		modifier |= Opcodes.ACC_PRIVATE;
	} else if (Modifier.isProtected(modVal)) {
		modifier |= Opcodes.ACC_PROTECTED;
	}
	// Retrieve static-modifier
	if (Modifier.isStatic(modVal)
			&& ((host instanceof SootField) || (host instanceof SootMethod))) {
		modifier |= Opcodes.ACC_STATIC;
	}
	// Retrieve final-modifier
	if (Modifier.isFinal(modVal)) {
		modifier |= Opcodes.ACC_FINAL;
	}
	// Retrieve synchronized-modifier
	if (Modifier.isSynchronized(modVal) && host instanceof SootMethod) {
		modifier |= Opcodes.ACC_SYNCHRONIZED;
	}
	// Retrieve volatile/bridge-modifier
	if (Modifier.isVolatile(modVal) && !(host instanceof SootClass)) {
		modifier |= Opcodes.ACC_VOLATILE;
	}
	// Retrieve transient/varargs-modifier
	if (Modifier.isTransient(modVal) && !(host instanceof SootClass)) {
		modifier |= Opcodes.ACC_TRANSIENT;
	}
	// Retrieve native-modifier
	if (Modifier.isNative(modVal) && host instanceof SootMethod) {
		modifier |= Opcodes.ACC_NATIVE;
	}
	// Retrieve interface-modifier
	if (Modifier.isInterface(modVal) && host instanceof SootClass) {
		modifier |= Opcodes.ACC_INTERFACE;
	} else if (host instanceof SootClass) {
		/*
		 * For all classes except for interfaces the super-flag should be
		 * set. See JVM 8-Specification section 4.1, page 72.
		 */
		modifier |= Opcodes.ACC_SUPER;
	}
	// Retrieve abstract-modifier
	if (Modifier.isAbstract(modVal) && !(host instanceof SootField)) {
		modifier |= Opcodes.ACC_ABSTRACT;
	}
	// Retrieve strictFP-modifier
	if (Modifier.isStrictFP(modVal) && host instanceof SootMethod) {
		modifier |= Opcodes.ACC_STRICT;
	}
	/*
	 * Retrieve synthetic-modifier. Class not present in source-code but
	 * generated by e.g. compiler TODO Do we need both checks?
	 */
	if (Modifier.isSynthetic(modVal) || host.hasTag("SyntheticTag")) {
		modifier |= Opcodes.ACC_SYNTHETIC;
	}
	// Retrieve annotation-modifier
	if (Modifier.isAnnotation(modVal) && host instanceof SootClass) {
		modifier |= Opcodes.ACC_ANNOTATION;
	}
	// Retrieve enum-modifier
	if (Modifier.isEnum(modVal) && !(host instanceof SootMethod)) {
		modifier |= Opcodes.ACC_ENUM;
	}
	return modifier;
}
 

protected void parseClassHeader() throws Exception {
	int access = parseAccessFlags();
	if(access == 0)
		throw new Exception("Error: Got zero access modifier while parsing class header!");
	
	if(!nextToken().equals("class"))
		throw new Exception("Error: Did not find class identifier while parsing class header!");
	
	String className = nextToken();
	String superClassName = null;
	List<String> impl = new ArrayList<String>();
	String value;
	
	//Extending, implementing or done?
	boolean implement = false;
	while(true)
	{
		value = nextToken();
		
		if(implement)
		{
			if(value.equals("{")) //Done reading implements
				break;
			impl.add(value);
			continue;
		}

		if(value.equals("implements"))
			implement = true;
		else if(value.equals("extends"))
			superClassName = nextToken();
		else if(value.equals("{")) //Done reading header info
			break;
	}
	
	//Write header
	/*if(superClassName != null)
	{
		access += Opcodes.ACC_SUPER;
		System.out.println("super access: " + superClassName);
	}
	else*/
	access += Opcodes.ACC_SUPER; //Seems this is always set after Java 1.1?
	if(superClassName == null)
		superClassName = "java/lang/Object";
	
	System.out.println("Writing class header:"
			+ "\nAccess: " + Integer.toHexString(access).toUpperCase()
			+ "\nName: " + className
			+ "\nSuper class: " + superClassName
			+ "\nImplements: " + impl);
	
	String[] implNames = null;
	if(impl.size() != 0)
		implNames = impl.toArray(new String[impl.size()]);
	
	cl.visit(classVersion, access, className, null, superClassName, implNames);
}
 

@SuppressWarnings("unused")
private static String getAccessModifiers(int access){
	LinkedList<String> modifiers = new LinkedList<String>();
	if((Opcodes.ACC_ABSTRACT & access) == Opcodes.ACC_ABSTRACT){
		modifiers.add("abstract");
	}
	if((Opcodes.ACC_ANNOTATION & access) == Opcodes.ACC_ANNOTATION){
		modifiers.add("annotation");
	}
	if((Opcodes.ACC_BRIDGE & access) == Opcodes.ACC_BRIDGE){
		modifiers.add("bridge");
	}
	if((Opcodes.ACC_DEPRECATED & access) == Opcodes.ACC_DEPRECATED){
		modifiers.add("deprecated");
	}
	if((Opcodes.ACC_ENUM & access) == Opcodes.ACC_ENUM){
		modifiers.add("enum");
	}
	if((Opcodes.ACC_FINAL & access) == Opcodes.ACC_FINAL){
		modifiers.add("final");
	}
	if((Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE){
		modifiers.add("interface");
	}
	if((Opcodes.ACC_MANDATED & access) == Opcodes.ACC_MANDATED){
		modifiers.add("mandated");
	}
	if((Opcodes.ACC_NATIVE & access) == Opcodes.ACC_NATIVE){
		modifiers.add("native");
	}
	if((Opcodes.ACC_PRIVATE & access) == Opcodes.ACC_PRIVATE){
		modifiers.add("private");
	}
	if((Opcodes.ACC_PROTECTED & access) == Opcodes.ACC_PROTECTED){
		modifiers.add("protected");
	}
	if((Opcodes.ACC_PUBLIC & access) == Opcodes.ACC_PUBLIC){
		modifiers.add("public");
	}
	if((Opcodes.ACC_STATIC & access) == Opcodes.ACC_STATIC){
		modifiers.add("static");
	}
	if((Opcodes.ACC_STRICT & access) == Opcodes.ACC_STRICT){
		modifiers.add("strict");
	}
	if((Opcodes.ACC_SUPER & access) == Opcodes.ACC_SUPER){
		modifiers.add("super");
	}
	if((Opcodes.ACC_SYNCHRONIZED & access) == Opcodes.ACC_SYNCHRONIZED){
		modifiers.add("synchronized");
	}
	if((Opcodes.ACC_SYNTHETIC & access) == Opcodes.ACC_SYNTHETIC){
		modifiers.add("synthetic");
	}
	if((Opcodes.ACC_TRANSIENT & access) == Opcodes.ACC_TRANSIENT){
		modifiers.add("transient");
	}
	if((Opcodes.ACC_VARARGS & access) == Opcodes.ACC_VARARGS){
		modifiers.add("varargs");
	}
	if((Opcodes.ACC_VOLATILE & access) == Opcodes.ACC_VOLATILE){
		modifiers.add("volatile");
	}
	return modifiers.toString();
}
 

@SuppressWarnings("unused")
private static String getAccessModifiers(int access){
	LinkedList<String> modifiers = new LinkedList<String>();
	if((Opcodes.ACC_ABSTRACT & access) == Opcodes.ACC_ABSTRACT){
		modifiers.add("abstract");
	}
	if((Opcodes.ACC_ANNOTATION & access) == Opcodes.ACC_ANNOTATION){
		modifiers.add("annotation");
	}
	if((Opcodes.ACC_BRIDGE & access) == Opcodes.ACC_BRIDGE){
		modifiers.add("bridge");
	}
	if((Opcodes.ACC_DEPRECATED & access) == Opcodes.ACC_DEPRECATED){
		modifiers.add("deprecated");
	}
	if((Opcodes.ACC_ENUM & access) == Opcodes.ACC_ENUM){
		modifiers.add("enum");
	}
	if((Opcodes.ACC_FINAL & access) == Opcodes.ACC_FINAL){
		modifiers.add("final");
	}
	if((Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE){
		modifiers.add("interface");
	}
	if((Opcodes.ACC_MANDATED & access) == Opcodes.ACC_MANDATED){
		modifiers.add("mandated");
	}
	if((Opcodes.ACC_NATIVE & access) == Opcodes.ACC_NATIVE){
		modifiers.add("native");
	}
	if((Opcodes.ACC_PRIVATE & access) == Opcodes.ACC_PRIVATE){
		modifiers.add("private");
	}
	if((Opcodes.ACC_PROTECTED & access) == Opcodes.ACC_PROTECTED){
		modifiers.add("protected");
	}
	if((Opcodes.ACC_PUBLIC & access) == Opcodes.ACC_PUBLIC){
		modifiers.add("public");
	}
	if((Opcodes.ACC_STATIC & access) == Opcodes.ACC_STATIC){
		modifiers.add("static");
	}
	if((Opcodes.ACC_STRICT & access) == Opcodes.ACC_STRICT){
		modifiers.add("strict");
	}
	if((Opcodes.ACC_SUPER & access) == Opcodes.ACC_SUPER){
		modifiers.add("super");
	}
	if((Opcodes.ACC_SYNCHRONIZED & access) == Opcodes.ACC_SYNCHRONIZED){
		modifiers.add("synchronized");
	}
	if((Opcodes.ACC_SYNTHETIC & access) == Opcodes.ACC_SYNTHETIC){
		modifiers.add("synthetic");
	}
	if((Opcodes.ACC_TRANSIENT & access) == Opcodes.ACC_TRANSIENT){
		modifiers.add("transient");
	}
	if((Opcodes.ACC_VARARGS & access) == Opcodes.ACC_VARARGS){
		modifiers.add("varargs");
	}
	if((Opcodes.ACC_VOLATILE & access) == Opcodes.ACC_VOLATILE){
		modifiers.add("volatile");
	}
	return modifiers.toString();
}
 

/**
 * Gets the class access flags (see JVMS8 4.1) for the given type element, augmented by the
 * special ASM pseudo-access flag for @Deprecated types.
 */
public int getAccessFlags(TypeElement typeElement) {
  ElementKind kind;
  try {
    kind = typeElement.getKind();
  } catch (CannotInferException e) {
    Preconditions.checkState(typeElement.getNestingKind().isNested());

    // We cannot know the access flags of an inferred type element. However, the only
    // flag that matters in the InnerClasses table is ACC_STATIC. When reading the
    // InnerClasses table, the compiler may create ClassSymbols for types it hasn't
    // seen before, and the absence of ACC_STATIC will cause it to mark those
    // ClassSymbols as inner classes, and it will not correct that when later loading
    // the class from its definitive class file. However, it is safe to mark
    // everything with ACC_STATIC, because the compiler *will* properly update
    // non-static classes when loading their definitive class files.
    // (http://hg.openjdk.java.net/jdk8u/jdk8u/langtools/file/9986bf97a48d/src/share/classes/com/sun/tools/javac/jvm/ClassReader.java#l2272)
    return Opcodes.ACC_STATIC;
  }

  int result = getCommonAccessFlags(typeElement);
  switch (kind) {
    case ANNOTATION_TYPE:
      // No ACC_SUPER here per JVMS 4.1
      result = result | Opcodes.ACC_ANNOTATION;
      result = result | Opcodes.ACC_INTERFACE;
      result = result | Opcodes.ACC_ABSTRACT;
      break;
    case ENUM:
      result = result | Opcodes.ACC_SUPER; // JVMS 4.1
      result = result | Opcodes.ACC_ENUM;

      if (isAbstractEnum(typeElement)) {
        result = result & ~Opcodes.ACC_FINAL | Opcodes.ACC_ABSTRACT;
      }
      break;
    case INTERFACE:
      // No ACC_SUPER here per JVMS 4.1
      result = result | Opcodes.ACC_ABSTRACT;
      result = result | Opcodes.ACC_INTERFACE;
      break;
      // $CASES-OMITTED$
    default:
      result = result | Opcodes.ACC_SUPER; // JVMS 4.1
      break;
  }

  return result;
}