gen.java

GJC（Generic Java Compiler）编译器

/**
 * @(#)Gen.java	1.97 03/01/23
 *
 * Copyright 2003 Sun Microsystems, Inc. All rights reserved.
 * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 */
package com.sun.tools.javac.v8.comp;
import java.io.IOException;

import com.sun.tools.javac.v8.util.*;

import com.sun.tools.javac.v8.code.*;

import com.sun.tools.javac.v8.tree.*;

import com.sun.tools.javac.v8.code.Symbol.*;

import com.sun.tools.javac.v8.code.Type.*;

import com.sun.tools.javac.v8.code.Code.*;

import com.sun.tools.javac.v8.tree.Tree.*;

import com.sun.tools.javac.v8.comp.Items.*;


/**
 * This pass maps flat Java (i.e. without inner classes) to bytecodes.
 */
public class Gen extends Tree.Visitor implements Flags, Kinds, TypeTags,
ByteCodes, CRTFlags {
    private static final Context.Key genKey = new Context.Key();
    private final Log log;
    private final Symtab syms;
    private final Check chk;
    private final Resolve rs;
    private final TreeMaker make;
    private final ClassWriter writer;
    private final Name.Table names;
    private final Target target;
    private final boolean generateIproxies;

    /**
     * A type that serves as the expected type for all method expressions.
     */
    private final Type methodType;

    public static Gen instance(Context context) {
        Gen instance = (Gen) context.get(genKey);
        if (instance == null)
            instance = new Gen(context);
        return instance;
    }

    private Gen(Context context) {
        super();
        context.put(genKey, this);
        names = Name.Table.instance(context);
        log = Log.instance(context);
        syms = Symtab.instance(context);
        chk = Check.instance(context);
        rs = Resolve.instance(context);
        make = TreeMaker.instance(context);
        writer = ClassWriter.instance(context);
        target = Target.instance(context);
        methodType = new MethodType(null, null, null, syms.methodClass);
        Options options = Options.instance(context);
        lineDebugInfo = options.get("-g:") == null || options.get("-g:lines") != null;
        varDebugInfo = options.get("-g:") == null ? options.get("-g") != null :
                options.get("-g:vars") != null;
        genCrt = options.get("-Xjcov") != null;
        generateIproxies = target.requiresIproxy() || options.get("miranda") != null;
        int setjsrlimit = 10;
        String jsrlimitString = (String) options.get("jsrlimit");
        if (jsrlimitString != null) {
            try {
                setjsrlimit = Integer.parseInt(jsrlimitString);
            } catch (NumberFormatException ex) {
            }
        }
        this.jsrlimit = setjsrlimit;
    }

    /**
      * Switches
      */
    private final boolean lineDebugInfo;
    private final boolean varDebugInfo;
    private final boolean genCrt;

    /**
     * Default limit of (approximate) size of finalizer to inline.
     *  Zero means always use jsr.  100 or greater means never use
     *  jsr.
     */
    private final int jsrlimit;
    private Pool pool = new Pool();

    /**
     * Code buffer, set by genMethod.
     */
    private Code code;

    /**
     * Items structure, set by genMethod.
     */
    private Items items;

    /**
     * Environment for symbol lookup, set by genClass
     */
    private Env attrEnv;

    /**
     * The top level tree.
     */
    private TopLevel toplevel;

    /**
     * The number of code-gen errors in this class.
     */
    private int nerrs = 0;

    /**
     * A hash table mapping syntax trees to their ending source positions.
     */
    private Hashtable endPositions;

    /**
     * Generate code to load an integer constant.
     *  @param n     The integer to be loaded.
     */
    void loadIntConst(int n) {
        items.makeImmediateItem(syms.intType, new Integer(n)).load();
    }

    /**
      * The opcode that loads a zero constant of a given type code.
      *  @param tc   The given type code (@see ByteCode).
      */
    public static int zero(int tc) {
        switch (tc) {
        case INTcode:

        case BYTEcode:

        case SHORTcode:

        case CHARcode:
            return iconst_0;

        case LONGcode:
            return lconst_0;

        case FLOATcode:
            return fconst_0;

        case DOUBLEcode:
            return dconst_0;

        default:
            throw new AssertionError("zero");

        }
    }

    /**
      * The opcode that loads a one constant of a given type code.
      *  @param tc   The given type code (@see ByteCode).
      */
    public static int one(int tc) {
        return zero(tc) + 1;
    }

    /**
      * Generate code to load -1 of the given type code (either int or long).
      *  @param tc   The given type code (@see ByteCode).
      */
    void emitMinusOne(int tc) {
        if (tc == LONGcode) {
            items.makeImmediateItem(syms.longType, new Long(-1)).load();
        } else {
            code.emitop(iconst_m1);
        }
    }

    /**
      * Construct a symbol to reflect the qualifying type that should
      *  appear in the byte code as per JLS 13.1.
      *
      *  For target >= 1.2: Clone a method with the qualifier as owner (except
      *  for those cases where we need to work around VM bugs).
      *
      *  For target <= 1.1: If qualified variable or method is defined in a
      *  non-accessible class, clone it with the qualifier class as owner.
      *
      *  @param sym    The accessed symbol
      *  @param site   The qualifier's type.
      */
    Symbol binaryQualifier(Symbol sym, Type site) {
        if (site.tag == ARRAY) {
            if (sym == syms.lengthVar || sym.owner != syms.arrayClass)
                return sym;
            Symbol qualifier = target.arrayBinaryCompatibility() ?
                    new ClassSymbol(Flags.PUBLIC, site.tsym.name, site,
                    syms.noSymbol) : syms.objectType.tsym;
            return sym.clone(qualifier);
        }
        if (sym.owner == site.tsym ||
                (sym.flags() & (STATIC | SYNTHETIC)) == (STATIC | SYNTHETIC)) {
            return sym;
        }
        if (!target.obeyBinaryCompatibility())
            return rs.isAccessible(attrEnv, (TypeSymbol) sym.owner) ? sym :
                    sym.clone(site.tsym);
        if (!target.interfaceFieldsBinaryCompatibility()) {
            if ((sym.owner.flags() & INTERFACE) != 0 && sym.kind == VAR)
                return sym;
        }
        if (sym.owner == syms.objectType.tsym)
            return sym;
        if (!target.interfaceObjectOverridesBinaryCompatibility()) {
            if ((sym.owner.flags() & INTERFACE) != 0 &&
                    syms.objectType.tsym.members().lookup(sym.name).scope != null)
                return sym;
        }
        return sym.clone(site.tsym);
    }

    /**
      * Insert a reference to given type in the constant pool,
      *  checking for an array with too many dimensions;
      *  return the reference's index.
      *  @param type   The type for which a reference is inserted.
      */
    int makeRef(int pos, Type type) {
        checkDimension(pos, type);
        return pool.put(type.tag == CLASS ? (Object) type.tsym : (Object) type);
    }

    /**
      * Check if the given type is an array with too many dimensions.
      */
    private void checkDimension(int pos, Type t) {
        switch (t.tag) {
        case METHOD:
            checkDimension(pos, t.restype());
            for (List args = t.argtypes(); args.nonEmpty(); args = args.tail)
                checkDimension(pos, (Type) args.head);
            break;

        case ARRAY:
            if (t.dimensions() > ClassFile.MAX_DIMENSIONS) {
                log.error(pos, "limit.dimensions");
                nerrs++;
            }
            break;

        default:
            break;

        }
    }

    /**
      * Create a tempory variable.
      *  @param type   The variable's type.
      */
    LocalItem makeTemp(Type type) {
        return (LocalItem) items.makeLocalItem(type, code.newLocal(type));
    }

    /**
      * Generate code to call a non-private method or constructor.
      *  @param pos         Position to be used for error reporting.
      *  @param site        The type of which the method is a member.
      *  @param name        The method's name.
      *  @param argtypes    The method's argument types.
      *  @param isStatic    A flag that indicates whether we call a
      *                     static or instance method.
      */
    void callMethod(int pos, Type site, Name name, List argtypes, boolean isStatic) {
        Symbol msym = rs.resolveInternalMethod(pos, attrEnv, site, name, argtypes);
        if (isStatic)
            items.makeStaticItem(msym).invoke();
        else
            items.makeMemberItem(msym, name == names.init).invoke();
    }

    /**
      * Is the given method definition an access method
      *  resulting from a qualified super? This is signified by an odd
      *  access code.
      */
    private boolean isAccessSuper(MethodDef enclMethod) {
        return (enclMethod.flags & SYNTHETIC) != 0 &&
                isOddAccessName(enclMethod.name);
    }

    /**
      * Does given name start with "access$" and end in an odd digit?
      */
    private boolean isOddAccessName(Name name) {
        return name.startsWith(names.accessDollar) &&
                (name.byteAt(name.len - 1) & 1) == 1;
    }

    /**
      * Generate code to invoke the finalizer associated with given
      *  environment.
      *  Any calls to finalizers are appended to the environments `cont' chain.
      *  Mark beginning of gap in catch all range for finalizer.
      */
    void genFinalizer(Env env) {
        if (code.isAlive() && ((Gen.GenContext) env.info).finalize != null)
            ((Gen.GenContext) env.info).finalize.gen();
    }

    /**
      * Generate code to call all finalizers of structures aborted by
      *  a non-local
      *  exit.  Return target environment of the non-local exit.
      *  @param target      The tree representing the structure that's aborted
      *  @param env         The environment current at the non-local exit.
      */
    Env unwind(Tree target, Env env) {
        Env env1 = env;
        while (true) {
            genFinalizer(env1);
            if (env1.tree == target)
                break;
            env1 = env1.next;
        }
        return env1;
    }

    /**
      * Mark end of gap in catch-all range for finalizer.
      *  @param env   the environment which might contain the finalizer
      *               (if it does, env.info.gaps != null).
      */
    void endFinalizerGap(Env env) {
        if (((Gen.GenContext) env.info).gaps != null &&
                ((Gen.GenContext) env.info).gaps.length() % 2 == 1)
            ((Gen.GenContext) env.info).gaps.append(new Integer(code.curPc()));
    }

    /**
      * Mark end of all gaps in catch-all ranges for finalizers of environments
      *  lying between, and including to two environments.
      *  @param from    the most deeply nested environment to mark
      *  @param to      the least deeply nested environment to mark
      */
    void endFinalizerGaps(Env from, Env to) {
        Env last = null;
        while (last != to) {
            endFinalizerGap(from);
            last = from;
            from = from.next;
        }
    }