|
Java example source code file (Items.java)
The Items.java Java example source code/* * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.sun.tools.javac.jvm; import com.sun.tools.javac.code.*; import com.sun.tools.javac.code.Symbol.*; import com.sun.tools.javac.code.Type.*; import com.sun.tools.javac.jvm.Code.*; import com.sun.tools.javac.tree.JCTree; import com.sun.tools.javac.util.Assert; import static com.sun.tools.javac.jvm.ByteCodes.*; /** A helper class for code generation. Items are objects * that stand for addressable entities in the bytecode. Each item * supports a fixed protocol for loading the item on the stack, storing * into it, converting it into a jump condition, and several others. * There are many individual forms of items, such as local, static, * indexed, or instance variables, values on the top of stack, the * special values this or super, etc. Individual items are represented as * inner classes in class Items. * * <p>This is NOT part of any supported API. * If you write code that depends on this, you do so at your own risk. * This code and its internal interfaces are subject to change or * deletion without notice.</b> */ public class Items { /** The current constant pool. */ Pool pool; /** The current code buffer. */ Code code; /** The current symbol table. */ Symtab syms; /** Type utilities. */ Types types; /** Items that exist only once (flyweight pattern). */ private final Item voidItem; private final Item thisItem; private final Item superItem; private final Item[] stackItem = new Item[TypeCodeCount]; public Items(Pool pool, Code code, Symtab syms, Types types) { this.code = code; this.pool = pool; this.types = types; voidItem = new Item(VOIDcode) { public String toString() { return "void"; } }; thisItem = new SelfItem(false); superItem = new SelfItem(true); for (int i = 0; i < VOIDcode; i++) stackItem[i] = new StackItem(i); stackItem[VOIDcode] = voidItem; this.syms = syms; } /** Make a void item */ Item makeVoidItem() { return voidItem; } /** Make an item representing `this'. */ Item makeThisItem() { return thisItem; } /** Make an item representing `super'. */ Item makeSuperItem() { return superItem; } /** Make an item representing a value on stack. * @param type The value's type. */ Item makeStackItem(Type type) { return stackItem[Code.typecode(type)]; } /** Make an item representing a dynamically invoked method. * @param member The represented symbol. */ Item makeDynamicItem(Symbol member) { return new DynamicItem(member); } /** Make an item representing an indexed expression. * @param type The expression's type. */ Item makeIndexedItem(Type type) { return new IndexedItem(type); } /** Make an item representing a local variable. * @param v The represented variable. */ LocalItem makeLocalItem(VarSymbol v) { return new LocalItem(v.erasure(types), v.adr); } /** Make an item representing a local anonymous variable. * @param type The represented variable's type. * @param reg The represented variable's register. */ private LocalItem makeLocalItem(Type type, int reg) { return new LocalItem(type, reg); } /** Make an item representing a static variable or method. * @param member The represented symbol. */ Item makeStaticItem(Symbol member) { return new StaticItem(member); } /** Make an item representing an instance variable or method. * @param member The represented symbol. * @param nonvirtual Is the reference not virtual? (true for constructors * and private members). */ Item makeMemberItem(Symbol member, boolean nonvirtual) { return new MemberItem(member, nonvirtual); } /** Make an item representing a literal. * @param type The literal's type. * @param value The literal's value. */ Item makeImmediateItem(Type type, Object value) { return new ImmediateItem(type, value); } /** Make an item representing an assignment expression. * @param lhs The item representing the assignment's left hand side. */ Item makeAssignItem(Item lhs) { return new AssignItem(lhs); } /** Make an item representing a conditional or unconditional jump. * @param opcode The jump's opcode. * @param trueJumps A chain encomassing all jumps that can be taken * if the condition evaluates to true. * @param falseJumps A chain encomassing all jumps that can be taken * if the condition evaluates to false. */ CondItem makeCondItem(int opcode, Chain trueJumps, Chain falseJumps) { return new CondItem(opcode, trueJumps, falseJumps); } /** Make an item representing a conditional or unconditional jump. * @param opcode The jump's opcode. */ CondItem makeCondItem(int opcode) { return makeCondItem(opcode, null, null); } /** The base class of all items, which implements default behavior. */ abstract class Item { /** The type code of values represented by this item. */ int typecode; Item(int typecode) { this.typecode = typecode; } /** Generate code to load this item onto stack. */ Item load() { throw new AssertionError(); } /** Generate code to store top of stack into this item. */ void store() { throw new AssertionError("store unsupported: " + this); } /** Generate code to invoke method represented by this item. */ Item invoke() { throw new AssertionError(this); } /** Generate code to use this item twice. */ void duplicate() {} /** Generate code to avoid having to use this item. */ void drop() {} /** Generate code to stash a copy of top of stack - of typecode toscode - * under this item. */ void stash(int toscode) { stackItem[toscode].duplicate(); } /** Generate code to turn item into a testable condition. */ CondItem mkCond() { load(); return makeCondItem(ifne); } /** Generate code to coerce item to given type code. * @param targetcode The type code to coerce to. */ Item coerce(int targetcode) { if (typecode == targetcode) return this; else { load(); int typecode1 = Code.truncate(typecode); int targetcode1 = Code.truncate(targetcode); if (typecode1 != targetcode1) { int offset = targetcode1 > typecode1 ? targetcode1 - 1 : targetcode1; code.emitop0(i2l + typecode1 * 3 + offset); } if (targetcode != targetcode1) { code.emitop0(int2byte + targetcode - BYTEcode); } return stackItem[targetcode]; } } /** Generate code to coerce item to given type. * @param targettype The type to coerce to. */ Item coerce(Type targettype) { return coerce(Code.typecode(targettype)); } /** Return the width of this item on stack as a number of words. */ int width() { return 0; } public abstract String toString(); } /** An item representing a value on stack. */ class StackItem extends Item { StackItem(int typecode) { super(typecode); } Item load() { return this; } void duplicate() { code.emitop0(width() == 2 ? dup2 : dup); } void drop() { code.emitop0(width() == 2 ? pop2 : pop); } void stash(int toscode) { code.emitop0( (width() == 2 ? dup_x2 : dup_x1) + 3 * (Code.width(toscode) - 1)); } int width() { return Code.width(typecode); } public String toString() { return "stack(" + typecodeNames[typecode] + ")"; } } /** An item representing an indexed expression. */ class IndexedItem extends Item { IndexedItem(Type type) { super(Code.typecode(type)); } Item load() { code.emitop0(iaload + typecode); return stackItem[typecode]; } void store() { code.emitop0(iastore + typecode); } void duplicate() { code.emitop0(dup2); } void drop() { code.emitop0(pop2); } void stash(int toscode) { code.emitop0(dup_x2 + 3 * (Code.width(toscode) - 1)); } int width() { return 2; } public String toString() { return "indexed(" + ByteCodes.typecodeNames[typecode] + ")"; } } /** An item representing `this' or `super'. */ class SelfItem extends Item { /** Flag which determines whether this item represents `this' or `super'. */ boolean isSuper; SelfItem(boolean isSuper) { super(OBJECTcode); this.isSuper = isSuper; } Item load() { code.emitop0(aload_0); return stackItem[typecode]; } public String toString() { return isSuper ? "super" : "this"; } } /** An item representing a local variable. */ class LocalItem extends Item { /** The variable's register. */ int reg; /** The variable's type. */ Type type; LocalItem(Type type, int reg) { super(Code.typecode(type)); Assert.check(reg >= 0); this.type = type; this.reg = reg; } Item load() { if (reg <= 3) code.emitop0(iload_0 + Code.truncate(typecode) * 4 + reg); else code.emitop1w(iload + Code.truncate(typecode), reg); return stackItem[typecode]; } void store() { if (reg <= 3) code.emitop0(istore_0 + Code.truncate(typecode) * 4 + reg); else code.emitop1w(istore + Code.truncate(typecode), reg); code.setDefined(reg); } void incr(int x) { if (typecode == INTcode && x >= -32768 && x <= 32767) { code.emitop1w(iinc, reg, x); } else { load(); if (x >= 0) { makeImmediateItem(syms.intType, x).load(); code.emitop0(iadd); } else { makeImmediateItem(syms.intType, -x).load(); code.emitop0(isub); } makeStackItem(syms.intType).coerce(typecode); store(); } } public String toString() { return "localItem(type=" + type + "; reg=" + reg + ")"; } } /** An item representing a static variable or method. */ class StaticItem extends Item { /** The represented symbol. */ Symbol member; StaticItem(Symbol member) { super(Code.typecode(member.erasure(types))); this.member = member; } Item load() { code.emitop2(getstatic, pool.put(member)); return stackItem[typecode]; } void store() { code.emitop2(putstatic, pool.put(member)); } Item invoke() { MethodType mtype = (MethodType)member.erasure(types); int rescode = Code.typecode(mtype.restype); code.emitInvokestatic(pool.put(member), mtype); return stackItem[rescode]; } public String toString() { return "static(" + member + ")"; } } /** An item representing a dynamic call site. */ class DynamicItem extends StaticItem { DynamicItem(Symbol member) { super(member); } Item load() { assert false; return null; } void store() { assert false; } Item invoke() { // assert target.hasNativeInvokeDynamic(); MethodType mtype = (MethodType)member.erasure(types); int rescode = Code.typecode(mtype.restype); code.emitInvokedynamic(pool.put(member), mtype); return stackItem[rescode]; } public String toString() { return "dynamic(" + member + ")"; } } /** An item representing an instance variable or method. */ class MemberItem extends Item { /** The represented symbol. */ Symbol member; /** Flag that determines whether or not access is virtual. */ boolean nonvirtual; MemberItem(Symbol member, boolean nonvirtual) { super(Code.typecode(member.erasure(types))); this.member = member; this.nonvirtual = nonvirtual; } Item load() { code.emitop2(getfield, pool.put(member)); return stackItem[typecode]; } void store() { code.emitop2(putfield, pool.put(member)); } Item invoke() { MethodType mtype = (MethodType)member.externalType(types); int rescode = Code.typecode(mtype.restype); if ((member.owner.flags() & Flags.INTERFACE) != 0 && !nonvirtual) { code.emitInvokeinterface(pool.put(member), mtype); } else if (nonvirtual) { code.emitInvokespecial(pool.put(member), mtype); } else { code.emitInvokevirtual(pool.put(member), mtype); } return stackItem[rescode]; } void duplicate() { stackItem[OBJECTcode].duplicate(); } void drop() { stackItem[OBJECTcode].drop(); } void stash(int toscode) { stackItem[OBJECTcode].stash(toscode); } int width() { return 1; } public String toString() { return "member(" + member + (nonvirtual ? " nonvirtual)" : ")"); } } /** An item representing a literal. */ class ImmediateItem extends Item { /** The literal's value. */ Object value; ImmediateItem(Type type, Object value) { super(Code.typecode(type)); this.value = value; } private void ldc() { int idx = pool.put(value); if (typecode == LONGcode || typecode == DOUBLEcode) { code.emitop2(ldc2w, idx); } else { code.emitLdc(idx); } } Item load() { switch (typecode) { case INTcode: case BYTEcode: case SHORTcode: case CHARcode: int ival = ((Number)value).intValue(); if (-1 <= ival && ival <= 5) code.emitop0(iconst_0 + ival); else if (Byte.MIN_VALUE <= ival && ival <= Byte.MAX_VALUE) code.emitop1(bipush, ival); else if (Short.MIN_VALUE <= ival && ival <= Short.MAX_VALUE) code.emitop2(sipush, ival); else ldc(); break; case LONGcode: long lval = ((Number)value).longValue(); if (lval == 0 || lval == 1) code.emitop0(lconst_0 + (int)lval); else ldc(); break; case FLOATcode: float fval = ((Number)value).floatValue(); if (isPosZero(fval) || fval == 1.0 || fval == 2.0) code.emitop0(fconst_0 + (int)fval); else { ldc(); } break; case DOUBLEcode: double dval = ((Number)value).doubleValue(); if (isPosZero(dval) || dval == 1.0) code.emitop0(dconst_0 + (int)dval); else ldc(); break; case OBJECTcode: ldc(); break; default: Assert.error(); } return stackItem[typecode]; } //where /** Return true iff float number is positive 0. */ private boolean isPosZero(float x) { return x == 0.0f && 1.0f / x > 0.0f; } /** Return true iff double number is positive 0. */ private boolean isPosZero(double x) { return x == 0.0d && 1.0d / x > 0.0d; } CondItem mkCond() { int ival = ((Number)value).intValue(); return makeCondItem(ival != 0 ? goto_ : dontgoto); } Item coerce(int targetcode) { if (typecode == targetcode) { return this; } else { switch (targetcode) { case INTcode: if (Code.truncate(typecode) == INTcode) return this; else return new ImmediateItem( syms.intType, ((Number)value).intValue()); case LONGcode: return new ImmediateItem( syms.longType, ((Number)value).longValue()); case FLOATcode: return new ImmediateItem( syms.floatType, ((Number)value).floatValue()); case DOUBLEcode: return new ImmediateItem( syms.doubleType, ((Number)value).doubleValue()); case BYTEcode: return new ImmediateItem( syms.byteType, (int)(byte)((Number)value).intValue()); case CHARcode: return new ImmediateItem( syms.charType, (int)(char)((Number)value).intValue()); case SHORTcode: return new ImmediateItem( syms.shortType, (int)(short)((Number)value).intValue()); default: return super.coerce(targetcode); } } } public String toString() { return "immediate(" + value + ")"; } } /** An item representing an assignment expressions. */ class AssignItem extends Item { /** The item representing the assignment's left hand side. */ Item lhs; AssignItem(Item lhs) { super(lhs.typecode); this.lhs = lhs; } Item load() { lhs.stash(typecode); lhs.store(); return stackItem[typecode]; } void duplicate() { load().duplicate(); } void drop() { lhs.store(); } void stash(int toscode) { Assert.error(); } int width() { return lhs.width() + Code.width(typecode); } public String toString() { return "assign(lhs = " + lhs + ")"; } } /** An item representing a conditional or unconditional jump. */ class CondItem extends Item { /** A chain encomassing all jumps that can be taken * if the condition evaluates to true. */ Chain trueJumps; /** A chain encomassing all jumps that can be taken * if the condition evaluates to false. */ Chain falseJumps; /** The jump's opcode. */ int opcode; /* * An abstract syntax tree of this item. It is needed * for branch entries in 'CharacterRangeTable' attribute. */ JCTree tree; CondItem(int opcode, Chain truejumps, Chain falsejumps) { super(BYTEcode); this.opcode = opcode; this.trueJumps = truejumps; this.falseJumps = falsejumps; } Item load() { Chain trueChain = null; Chain falseChain = jumpFalse(); if (!isFalse()) { code.resolve(trueJumps); code.emitop0(iconst_1); trueChain = code.branch(goto_); } if (falseChain != null) { code.resolve(falseChain); code.emitop0(iconst_0); } code.resolve(trueChain); return stackItem[typecode]; } void duplicate() { load().duplicate(); } void drop() { load().drop(); } void stash(int toscode) { Assert.error(); } CondItem mkCond() { return this; } Chain jumpTrue() { if (tree == null) return Code.mergeChains(trueJumps, code.branch(opcode)); // we should proceed further in -Xjcov mode only int startpc = code.curCP(); Chain c = Code.mergeChains(trueJumps, code.branch(opcode)); code.crt.put(tree, CRTable.CRT_BRANCH_TRUE, startpc, code.curCP()); return c; } Chain jumpFalse() { if (tree == null) return Code.mergeChains(falseJumps, code.branch(Code.negate(opcode))); // we should proceed further in -Xjcov mode only int startpc = code.curCP(); Chain c = Code.mergeChains(falseJumps, code.branch(Code.negate(opcode))); code.crt.put(tree, CRTable.CRT_BRANCH_FALSE, startpc, code.curCP()); return c; } CondItem negate() { CondItem c = new CondItem(Code.negate(opcode), falseJumps, trueJumps); c.tree = tree; return c; } int width() { // a CondItem doesn't have a size on the stack per se. throw new AssertionError(); } boolean isTrue() { return falseJumps == null && opcode == goto_; } boolean isFalse() { return trueJumps == null && opcode == dontgoto; } public String toString() { return "cond(" + Code.mnem(opcode) + ")"; } } } Other Java examples (source code examples)Here is a short list of links related to this Java Items.java source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.