| /* |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package org.apache.flex.abc; |
| |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_Multiname; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_MultinameA; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_MultinameL; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_MultinameLA; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_Qname; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_QnameA; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_RTQname; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_RTQnameA; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_RTQnameL; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_RTQnameLA; |
| import static org.apache.flex.abc.ABCConstants.CONSTANT_TypeName; |
| import static org.apache.flex.abc.ABCConstants.OP_applytype; |
| import static org.apache.flex.abc.ABCConstants.OP_astype; |
| import static org.apache.flex.abc.ABCConstants.OP_bkptline; |
| import static org.apache.flex.abc.ABCConstants.OP_call; |
| import static org.apache.flex.abc.ABCConstants.OP_callproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_callproplex; |
| import static org.apache.flex.abc.ABCConstants.OP_callpropvoid; |
| import static org.apache.flex.abc.ABCConstants.OP_callstatic; |
| import static org.apache.flex.abc.ABCConstants.OP_callsuper; |
| import static org.apache.flex.abc.ABCConstants.OP_callsupervoid; |
| import static org.apache.flex.abc.ABCConstants.OP_coerce; |
| import static org.apache.flex.abc.ABCConstants.OP_construct; |
| import static org.apache.flex.abc.ABCConstants.OP_constructprop; |
| import static org.apache.flex.abc.ABCConstants.OP_constructsuper; |
| import static org.apache.flex.abc.ABCConstants.OP_debug; |
| import static org.apache.flex.abc.ABCConstants.OP_debugfile; |
| import static org.apache.flex.abc.ABCConstants.OP_debugline; |
| import static org.apache.flex.abc.ABCConstants.OP_declocal; |
| import static org.apache.flex.abc.ABCConstants.OP_declocal_i; |
| import static org.apache.flex.abc.ABCConstants.OP_deleteproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_dxns; |
| import static org.apache.flex.abc.ABCConstants.OP_finddef; |
| import static org.apache.flex.abc.ABCConstants.OP_findproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_findpropstrict; |
| import static org.apache.flex.abc.ABCConstants.OP_getdescendants; |
| import static org.apache.flex.abc.ABCConstants.OP_getglobalslot; |
| import static org.apache.flex.abc.ABCConstants.OP_getlex; |
| import static org.apache.flex.abc.ABCConstants.OP_getlocal; |
| import static org.apache.flex.abc.ABCConstants.OP_getlocal0; |
| import static org.apache.flex.abc.ABCConstants.OP_getproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_getscopeobject; |
| import static org.apache.flex.abc.ABCConstants.OP_getslot; |
| import static org.apache.flex.abc.ABCConstants.OP_getsuper; |
| import static org.apache.flex.abc.ABCConstants.OP_hasnext2; |
| import static org.apache.flex.abc.ABCConstants.OP_inclocal; |
| import static org.apache.flex.abc.ABCConstants.OP_inclocal_i; |
| import static org.apache.flex.abc.ABCConstants.OP_initproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_istype; |
| import static org.apache.flex.abc.ABCConstants.OP_kill; |
| import static org.apache.flex.abc.ABCConstants.OP_lookupswitch; |
| import static org.apache.flex.abc.ABCConstants.OP_newarray; |
| import static org.apache.flex.abc.ABCConstants.OP_newcatch; |
| import static org.apache.flex.abc.ABCConstants.OP_newclass; |
| import static org.apache.flex.abc.ABCConstants.OP_newfunction; |
| import static org.apache.flex.abc.ABCConstants.OP_newobject; |
| import static org.apache.flex.abc.ABCConstants.OP_pushbyte; |
| import static org.apache.flex.abc.ABCConstants.OP_pushdouble; |
| import static org.apache.flex.abc.ABCConstants.OP_pushint; |
| import static org.apache.flex.abc.ABCConstants.OP_pushnamespace; |
| import static org.apache.flex.abc.ABCConstants.OP_pushscope; |
| import static org.apache.flex.abc.ABCConstants.OP_pushshort; |
| import static org.apache.flex.abc.ABCConstants.OP_pushstring; |
| import static org.apache.flex.abc.ABCConstants.OP_pushuint; |
| import static org.apache.flex.abc.ABCConstants.OP_returnvoid; |
| import static org.apache.flex.abc.ABCConstants.OP_setglobalslot; |
| import static org.apache.flex.abc.ABCConstants.OP_setlocal; |
| import static org.apache.flex.abc.ABCConstants.OP_setproperty; |
| import static org.apache.flex.abc.ABCConstants.OP_setslot; |
| import static org.apache.flex.abc.ABCConstants.OP_setsuper; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Class; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Const; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Function; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Getter; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Method; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Setter; |
| import static org.apache.flex.abc.ABCConstants.TRAIT_Var; |
| |
| import java.io.ByteArrayOutputStream; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Vector; |
| import java.util.concurrent.locks.Lock; |
| import java.util.concurrent.locks.ReadWriteLock; |
| import java.util.concurrent.locks.ReentrantLock; |
| import java.util.concurrent.locks.ReentrantReadWriteLock; |
| |
| import org.apache.flex.abc.graph.IBasicBlock; |
| import org.apache.flex.abc.instructionlist.InstructionList; |
| import org.apache.flex.abc.semantics.ClassInfo; |
| import org.apache.flex.abc.semantics.ExceptionInfo; |
| import org.apache.flex.abc.semantics.InstanceInfo; |
| import org.apache.flex.abc.semantics.Instruction; |
| import org.apache.flex.abc.semantics.Label; |
| import org.apache.flex.abc.semantics.Metadata; |
| import org.apache.flex.abc.semantics.MethodBodyInfo; |
| import org.apache.flex.abc.semantics.MethodInfo; |
| import org.apache.flex.abc.semantics.Name; |
| import org.apache.flex.abc.semantics.Namespace; |
| import org.apache.flex.abc.semantics.Nsset; |
| import org.apache.flex.abc.semantics.PooledValue; |
| import org.apache.flex.abc.semantics.ScriptInfo; |
| import org.apache.flex.abc.semantics.Trait; |
| import org.apache.flex.abc.semantics.Traits; |
| import org.apache.flex.abc.visitors.IABCVisitor; |
| import org.apache.flex.abc.visitors.IClassVisitor; |
| import org.apache.flex.abc.visitors.IDiagnosticsVisitor; |
| import org.apache.flex.abc.visitors.IMetadataVisitor; |
| import org.apache.flex.abc.visitors.IMethodBodyVisitor; |
| import org.apache.flex.abc.visitors.IMethodVisitor; |
| import org.apache.flex.abc.visitors.IScriptVisitor; |
| import org.apache.flex.abc.visitors.ITraitVisitor; |
| import org.apache.flex.abc.visitors.ITraitsVisitor; |
| import org.apache.flex.abc.visitors.NilVisitors; |
| |
| /** |
| * The ABCEmitter is an IABCVisitor that collects information about |
| * the ABC and emits it as a byte array. |
| */ |
| public final class ABCEmitter implements IABCVisitor |
| { |
| private static final int VERSION_NONE = -1; |
| |
| // Size of a S24 branch offset. |
| private static final int SIZEOF_S24 = 3; |
| |
| /** |
| * Construct a new ABCEmitter, using the default |
| * diagnostics interface which ignores diagnostics. |
| */ |
| public ABCEmitter() |
| { |
| this(NilVisitors.NIL_DIAGNOSTICS_VISITOR); |
| } |
| |
| /** |
| * Construct a new ABCEmitter using the specified diagnostics interface. |
| * @param diagnosticsVisitor - a sink for diagnostics. |
| */ |
| public ABCEmitter(IDiagnosticsVisitor diagnosticsVisitor) |
| { |
| this.w = new ABCWriter(); |
| this.lock = new ReentrantLock(); |
| this.visitEndCalled = false; |
| this.diagnosticsVisitor = diagnosticsVisitor; |
| } |
| |
| private ABCWriter w; |
| |
| /** |
| * Name pool, has default zero entry. |
| */ |
| final Pool<Name> namePool = new Pool<Name>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * String pool, has default zero entry. |
| */ |
| final Pool<String> stringPool = new Pool<String>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * int pool, has default zero entry. |
| */ |
| final Pool<Integer> intPool = new Pool<Integer>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * uint pool, has default zero entry. |
| */ |
| final Pool<Long> uintPool = new Pool<Long>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * double pool, has default zero entry. |
| */ |
| final Pool<Double> doublePool = new Pool<Double>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * namespace pool, has default zero entry. |
| */ |
| final Pool<Namespace> nsPool = new Pool<Namespace>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * namespace set pool, has default zero entry. |
| */ |
| final Pool<Nsset> nssetPool = new Pool<Nsset>(Pool.DefaultType.HasDefaultZero); |
| |
| /** |
| * metadata pool, does not have default zero entry. |
| */ |
| final Pool<Metadata> metadataPool = new Pool<Metadata>(Pool.DefaultType.NoDefaultZero); |
| |
| /** |
| * Visitors of classes defined in this ABC. |
| */ |
| private Collection<EmitterClassVisitor> definedClasses = new ArrayList<EmitterClassVisitor>(); |
| |
| /** |
| * MethodInfos defined in this ABC. These are stored in a dual-indexed store |
| * so the method info number of a MethodInfo can be quickly retrieved. |
| */ |
| private final EntryOrderedStore<MethodInfo> methodInfos = new EntryOrderedStore<MethodInfo>(); |
| |
| /** |
| * Lock used to protect the method info pool stored in the |
| * {@link #methodInfos} field. |
| */ |
| private final ReadWriteLock methodInfosLock = new ReentrantReadWriteLock(); |
| |
| /** |
| * Method bodies defined in this ABC. |
| */ |
| private final Vector<MethodBodyInfo> methodBodies = new Vector<MethodBodyInfo>(); |
| |
| /** |
| * Scripts defined in this ABC. There is normally one. |
| */ |
| private final Vector<ScriptInfo> scriptInfos = new Vector<ScriptInfo>(); |
| |
| private int versionABCMajor = VERSION_NONE; |
| |
| private int versionABCMinor = VERSION_NONE; |
| |
| /** |
| * determines whether the ABCEmitter should throw exceptions when it |
| * encounters jumps to nowhere, or just try and repair and keep going. |
| */ |
| private boolean allowBadJumps = false; |
| |
| /** |
| * Should the emitter serialize method bodies to ABC as soon as possible, or |
| * serialize them as it emits the final ABC? |
| */ |
| private boolean eagerlyEmitMethodBodies = true; |
| |
| /** |
| * Lock used to enforce concurrency rules of this class. |
| * <p> |
| * This lock is used to ensure that vistEnd calls are only made on the same |
| * thread that called {@link #visit(int, int)}. |
| * <p> |
| * When running with asserts enabled this lock is used to cause an assertion |
| * failure when the currency rules of this class are violated. |
| * <p> |
| * When running with asserts disabled this lock is used to cause a deadlock |
| * when the currency rules of this class are violated. |
| * |
| * @see #assertLockHeld() |
| */ |
| private final ReentrantLock lock; |
| |
| /** |
| * Flag set in visitEnd(), checked in verifyEmitterStatus() |
| */ |
| private boolean visitEndCalled; |
| |
| private final IDiagnosticsVisitor diagnosticsVisitor; |
| |
| /** |
| * Emit bytecode. |
| * @return the ABC bytecode corresponding to the ABC structures |
| * visited by this emitter or its subsidiary visitors. |
| * @throws Exception if the emitter is unable to generate valid bytecode. |
| */ |
| public byte[] emit() throws Exception |
| { |
| if (getMajorVersion() == VERSION_NONE || getMinorVersion() == VERSION_NONE) |
| throw new IllegalStateException("No abc version specified"); |
| |
| // First sort the classes into dependency order. |
| this.definedClasses = ClassDependencySort.getSorted(this.definedClasses); |
| |
| w.writeU16(getMinorVersion()); |
| w.writeU16(getMajorVersion()); |
| |
| w.writeU30(this.intPool.getNominalSize()); |
| for (int x : this.intPool.getValues()) |
| { |
| w.writeU30(x); |
| } |
| |
| w.writeU30(this.uintPool.getNominalSize()); |
| for (long x : this.uintPool.getValues()) |
| { |
| w.writeU30((int)x); |
| } |
| |
| w.writeU30(this.doublePool.getNominalSize()); |
| for (double x : this.doublePool.getValues()) |
| { |
| w.write64(Double.doubleToLongBits(x)); |
| } |
| |
| w.writeU30(this.stringPool.getNominalSize()); |
| for (String s : this.stringPool.getValues()) |
| { |
| byte[] stringBytes = s.getBytes("UTF-8"); |
| w.writeU30(stringBytes.length); |
| w.write(stringBytes); |
| } |
| |
| w.writeU30(this.nsPool.getNominalSize()); |
| for (Namespace ns : this.nsPool.getValues()) |
| { |
| emitNamespace(ns); |
| } |
| |
| w.writeU30(this.nssetPool.getNominalSize()); |
| for (Nsset nsset : this.nssetPool.getValues()) |
| { |
| w.writeU30(nsset.length()); |
| for (Namespace ns : nsset) |
| { |
| w.writeU30(this.nsPool.id(ns)); |
| } |
| } |
| |
| w.writeU30(this.namePool.getNominalSize()); |
| for (Name n : this.namePool.getValues()) |
| { |
| w.write(n.getKind()); |
| switch (n.getKind()) |
| { |
| case CONSTANT_Qname: |
| case CONSTANT_QnameA: |
| { |
| w.writeU30(this.nsPool.id(n.getSingleQualifier())); |
| w.writeU30(this.stringPool.id(n.getBaseName())); |
| break; |
| } |
| case CONSTANT_Multiname: |
| case CONSTANT_MultinameA: |
| { |
| w.writeU30(this.stringPool.id(n.getBaseName())); |
| w.writeU30(this.nssetPool.id(n.getQualifiers())); |
| break; |
| } |
| case CONSTANT_RTQname: |
| case CONSTANT_RTQnameA: |
| { |
| w.writeU30(this.stringPool.id(n.getBaseName())); |
| break; |
| } |
| case CONSTANT_MultinameL: |
| case CONSTANT_MultinameLA: |
| { |
| w.writeU30(this.nssetPool.id(n.getQualifiers())); |
| break; |
| } |
| case CONSTANT_RTQnameL: |
| case CONSTANT_RTQnameLA: |
| { |
| break; |
| } |
| case CONSTANT_TypeName: |
| { |
| w.writeU30(this.namePool.id(n.getTypeNameBase())); |
| w.writeU30(1); // only 1 type parameter is currently supposed in AVM2 |
| w.writeU30(this.namePool.id(n.getTypeNameParameter())); |
| break; |
| } |
| default: |
| { |
| assert (false) : "Unimplemented name kind " + n.getKind(); |
| throw new IllegalArgumentException("Not implemented."); |
| } |
| } |
| } |
| |
| // See the comment in EmitterMethodInfoVisitor.visit |
| // to understand why we have this lock here. |
| // The short answer is because multiple threads |
| // need to simultaneously add method infos to the method |
| // info pool. |
| final Lock methodInfosReadLock = methodInfosLock.readLock(); |
| methodInfosReadLock.lock(); |
| try |
| { |
| w.writeU30(this.methodInfos.size()); |
| |
| for (MethodInfo mi : this.methodInfos) |
| emitMethodInfo(mi); |
| } |
| finally |
| { |
| methodInfosReadLock.unlock(); |
| } |
| |
| w.writeU30(this.metadataPool.getNominalSize()); |
| for (Metadata md : this.metadataPool.values) |
| { |
| // name |
| w.writeU30(this.stringPool.id(md.getName())); |
| |
| // items count |
| assert md.getKeys().length == md.getValues().length; |
| w.writeU30(md.getKeys().length); |
| |
| // metadata keys |
| for (final String key : md.getKeys()) |
| { |
| final int string_index = stringPool.id(key); |
| w.writeU30(string_index); |
| } |
| |
| // metadata values |
| for (final String value : md.getValues()) |
| { |
| final int string_index = stringPool.id(value); |
| w.writeU30(string_index); |
| } |
| } |
| |
| w.writeU30(this.definedClasses.size()); |
| for (EmitterClassVisitor clz : this.definedClasses) |
| { |
| InstanceInfo ii = clz.instanceInfo; |
| |
| w.writeU30(namePool.id(ii.name)); |
| w.writeU30(namePool.id(ii.superName)); |
| w.write(ii.flags); |
| |
| if (ii.hasProtectedNs()) |
| w.writeU30(this.nsPool.id(ii.protectedNs)); |
| w.writeU30(ii.interfaceNames.length); |
| |
| for (Name i : ii.interfaceNames) |
| w.writeU30(this.namePool.id(i)); |
| w.writeU30(getMethodId(ii.iInit)); |
| |
| emitTraits(clz.instanceTraits); |
| } |
| |
| for (EmitterClassVisitor clz : this.definedClasses) |
| { |
| w.writeU30(getMethodId(clz.classInfo.cInit)); |
| emitTraits(clz.classTraits); |
| } |
| |
| w.writeU30(this.scriptInfos.size()); |
| for (ScriptInfo s : this.scriptInfos) |
| { |
| emitScriptInfo(s); |
| } |
| |
| w.writeU30(this.methodBodies.size()); |
| for (MethodBodyInfo mb : this.methodBodies) |
| { |
| emitMethodBody(mb); |
| } |
| |
| return w.getDirectByteArray(); |
| } |
| |
| private int getMajorVersion() |
| { |
| return versionABCMajor; |
| } |
| |
| private int getMinorVersion() |
| { |
| return versionABCMinor; |
| } |
| |
| /** |
| * Emit ABC bytes for a Traits entry. |
| * |
| * @param traits - the Traits to emit. |
| * @see #poolTraitValues(Traits) which puts these values into the pools. |
| */ |
| private void emitTraits(Traits traits) |
| { |
| w.writeU30(traits.getTraitCount()); |
| |
| for (Trait t : traits) |
| { |
| w.writeU30(namePool.id(t.getNameAttr("name"))); |
| |
| // Get the kind byte with its flags set in the high nibble. |
| w.write(t.getFullKindByte()); |
| |
| switch (t.getKind()) |
| { |
| case TRAIT_Var: |
| case TRAIT_Const: |
| { |
| w.writeU30(t.getIntAttr(Trait.TRAIT_SLOT)); |
| w.writeU30(namePool.id(t.getNameAttr(Trait.TRAIT_TYPE))); |
| |
| // Emit the Trait's initial value, if it has one. |
| Object trait_value = t.getAttr(Trait.SLOT_VALUE); |
| if (trait_value != null) |
| { |
| if (trait_value instanceof String) |
| { |
| w.writeU30(stringPool.id((String)trait_value)); |
| w.write(ABCConstants.CONSTANT_Utf8); |
| } |
| else if (trait_value instanceof Namespace) |
| { |
| w.writeU30(nsPool.id((Namespace)trait_value)); |
| w.write(ABCConstants.CONSTANT_Namespace); |
| } |
| else if (trait_value instanceof Double) |
| { |
| w.writeU30(doublePool.id((Double)trait_value)); |
| w.write(ABCConstants.CONSTANT_Double); |
| } |
| else if (trait_value instanceof Integer) |
| { |
| w.writeU30(intPool.id((Integer)trait_value)); |
| w.write(ABCConstants.CONSTANT_Int); |
| } |
| else if (trait_value instanceof Long) |
| { |
| w.writeU30(uintPool.id((Long)trait_value)); |
| w.write(ABCConstants.CONSTANT_UInt); |
| } |
| else if (trait_value.equals(Boolean.TRUE)) |
| { |
| w.writeU30(ABCConstants.CONSTANT_True); |
| w.write(ABCConstants.CONSTANT_True); |
| } |
| else if (trait_value.equals(Boolean.FALSE)) |
| { |
| w.writeU30(ABCConstants.CONSTANT_False); |
| w.write(ABCConstants.CONSTANT_False); |
| } |
| else if (trait_value == ABCConstants.NULL_VALUE) |
| { |
| w.writeU30(ABCConstants.CONSTANT_Null); |
| w.write(ABCConstants.CONSTANT_Null); |
| } |
| else if (trait_value == ABCConstants.UNDEFINED_VALUE) |
| { |
| // Undefined is a special case; it has no kind byte. |
| w.writeU30(0); |
| } |
| else |
| { |
| throw new IllegalStateException("Unrecognized initializer type: " + trait_value.getClass().toString()); |
| } |
| } |
| else |
| { |
| w.writeU30(0); |
| } |
| |
| break; |
| } |
| case TRAIT_Method: |
| case TRAIT_Function: |
| case TRAIT_Getter: |
| case TRAIT_Setter: |
| { |
| if (t.hasAttr(Trait.TRAIT_DISP)) |
| w.writeU30(t.getIntAttr(Trait.TRAIT_DISP)); |
| else |
| w.writeU30(0); |
| |
| w.writeU30(this.getMethodId((MethodInfo)t.getAttr(Trait.TRAIT_METHOD))); |
| break; |
| } |
| case TRAIT_Class: |
| { |
| if (t.hasAttr(Trait.TRAIT_SLOT)) |
| w.writeU30(t.getIntAttr(Trait.TRAIT_SLOT)); |
| else |
| w.writeU30(0); |
| w.writeU30(this.getClassId(((ClassInfo)t.getAttr(Trait.TRAIT_CLASS)))); |
| break; |
| } |
| default: |
| { |
| throw new IllegalArgumentException("Unknown trait kind " + t.getKind()); |
| } |
| } |
| |
| if (t.hasMetadata()) |
| { |
| Vector<Metadata> metadata = t.getMetadata(); |
| w.writeU30(metadata.size()); |
| for (Metadata m : metadata) |
| { |
| w.writeU30(metadataPool.id(m)); |
| } |
| } |
| } |
| } |
| |
| private int getMethodId(MethodInfo info) |
| { |
| Lock methodInfosReadLock = methodInfosLock.readLock(); |
| methodInfosReadLock.lock(); |
| try |
| { |
| return methodInfos.getId(info); |
| } |
| finally |
| { |
| methodInfosReadLock.unlock(); |
| } |
| } |
| |
| /** |
| * @return the class ID of the given ClassInfo. |
| * @throws IllegalArgumentException if the class is not found. |
| */ |
| private int getClassId(ClassInfo info) |
| { |
| int id_index = 0; |
| for (EmitterClassVisitor candidate : this.definedClasses) |
| { |
| if (candidate.classInfo == info) |
| return id_index; |
| else |
| id_index++; |
| } |
| |
| throw new IllegalArgumentException("Unable to find ClassInfo index for " + info); |
| } |
| |
| private void emitScriptInfo(ScriptInfo info) |
| { |
| final MethodInfo scriptInit = info.getInit(); |
| final int nRequiredArguments = |
| scriptInit.getParamTypes().size() - scriptInit.getDefaultValues().size(); |
| if (nRequiredArguments > 0) |
| diagnosticsVisitor.scriptInitWithRequiredArguments(info, scriptInit); |
| w.writeU30(getMethodId(scriptInit)); |
| emitTraits(info.getTraits()); |
| } |
| |
| private void emitMethodInfo(MethodInfo info) |
| { |
| final Collection<Name> paramTypes = info.getParamTypes(); |
| final int nParamTypes = paramTypes.size(); |
| w.writeU30(nParamTypes); |
| w.writeU30(namePool.id(info.getReturnType())); |
| |
| for (Name n : paramTypes) |
| { |
| w.writeU30(namePool.id(n)); |
| } |
| |
| w.writeU30(this.stringPool.id(info.getMethodName())); |
| w.write(info.getFlags()); |
| |
| if (info.hasOptional()) |
| { |
| Collection<PooledValue> defaults = info.getDefaultValues(); |
| final int nDefaults = defaults.size(); |
| |
| if (nDefaults > nParamTypes) |
| this.diagnosticsVisitor.tooManyDefaultParameters(info); |
| |
| w.writeU30(nDefaults); |
| for (PooledValue v : defaults) |
| { |
| w.writeU30(v.getPoolIndex()); |
| w.write(v.getKind()); |
| } |
| } |
| |
| if (info.hasParamNames()) |
| { |
| List<String> paramNames = info.getParamNames(); |
| final int nParamNames = paramNames.size(); |
| if (nParamTypes != nParamNames) |
| this.diagnosticsVisitor.incorrectNumberOfParameterNames(info); |
| |
| for (String param_name : info.getParamNames()) |
| w.writeU30(stringPool.id(param_name)); |
| } |
| } |
| |
| private void emitMethodBody(MethodBodyInfo f) throws Exception |
| { |
| MethodInfo signature = f.getMethodInfo(); |
| |
| w.writeU30(getMethodId(signature)); |
| // Note: computeFrameCounts() called at MethodBodyInfo.visitEnd(). |
| w.writeU30(f.getMaxStack()); |
| |
| int max_local = f.getLocalCount(); |
| if (signature.getParamCount() > max_local) |
| max_local = signature.getParamCount(); |
| |
| w.writeU30(max_local); |
| |
| w.writeU30(f.getInitScopeDepth()); |
| w.writeU30(f.getMaxScopeDepth()); |
| |
| if (!f.hasBytecode()) |
| emitCode(f); |
| |
| w.write(f.getBytecode()); |
| |
| emitTraits(f.getTraits()); |
| } |
| |
| private void emitCode(MethodBodyInfo f) throws Exception |
| { |
| ABCWriter result = new ABCWriter(); |
| Map<IBasicBlock, ABCWriter> writers = new HashMap<IBasicBlock, ABCWriter>(); |
| |
| // generate linear code sequences within the basic blocks, |
| // and compute the offset of each block from the method start. |
| Map<IBasicBlock, Integer> block_offsets = new HashMap<IBasicBlock, Integer>(); |
| int code_len = 0; |
| |
| // First, generate code for each block. |
| // Keep a running tally of the code length, |
| // which corresponds to the starting position |
| // of each block. |
| for (IBasicBlock b : f.getCfg().getBlocksInEntryOrder()) |
| { |
| block_offsets.put(b, code_len); |
| ABCWriter blockWriter = new ABCWriter(); |
| writers.put(b, blockWriter); |
| |
| emitBlock(b, blockWriter); |
| |
| code_len += blockWriter.size(); |
| |
| // Blocks with no instructions are |
| // valid assembly constructs. |
| if (b.size() == 0) |
| continue; |
| |
| // If the last instruction in the block |
| // is a jump, leave room for the instruction, |
| // but don't emit it yet. |
| Instruction last = b.get(b.size() - 1); |
| |
| if (last.isBranch()) |
| { |
| if (last.getOpcode() == OP_lookupswitch) |
| { |
| // Switch table contains a U30 case count and S24 offsets. |
| int switch_size = 1 + sizeOfU30(last.getOperandCount()) + SIZEOF_S24 * last.getOperandCount(); |
| code_len += switch_size; |
| } |
| else |
| { |
| assert (null != last.getTarget()); |
| // Reserve space for a branch instruction. |
| code_len += 4; |
| } |
| } |
| } |
| |
| // Note: Can't compute code_start until we've seen |
| // how big this U30 is. |
| result.writeU30(code_len); |
| int code_start = result.size(); |
| |
| // Now we can resolve labels to their code offsets. |
| // Copy the linear code sequences into the main ABCWriter, |
| // and emit the branch and lookupswitch instructions. |
| for (IBasicBlock b : f.getCfg().getBlocksInEntryOrder()) |
| { |
| writers.get(b).writeTo(result); |
| if (b.size() > 0) |
| { |
| Instruction last = b.get(b.size() - 1); |
| |
| if (last.isBranch()) |
| { |
| if (OP_lookupswitch == last.getOpcode()) |
| { |
| emitLookupswitch(result, code_start, f, last, block_offsets); |
| } |
| else |
| { |
| assert (last.getTarget() != null); |
| |
| emitBranch(result, last.getOpcode(), f.getBlock(last.getTarget(), !allowBadJumps), code_start, block_offsets, code_len); |
| } |
| } |
| } |
| } |
| |
| emitExceptionInfo(f, result, block_offsets); |
| |
| f.setBytecode(result.getDirectByteArray()); |
| } |
| |
| private void emitBranch(ABCWriter writer, int opcode, IBasicBlock target, int code_start, Map<IBasicBlock, Integer> block_offsets, int code_len) |
| { |
| writer.write(opcode); |
| |
| // Branch offset computed from the instruction following the branch. |
| int from = writer.size() + SIZEOF_S24; |
| |
| // Convert the target offset relative to the start of the ABC, as |
| // the "from" address is expressed in this fashion. |
| // if we can't determine the target then jump past the end of the method - this is to allow |
| // malformed ABCs to be successfully processed by AET. |
| int to = code_start + (target != null ? block_offsets.get(target) : code_len + 1); |
| |
| writer.writeS24(to - from); |
| } |
| |
| void emitBlock(IBasicBlock b, ABCWriter blockWriter) |
| { |
| for (int i = 0; i < b.size() && !b.get(i).isBranch(); i++) |
| { |
| Instruction insn = b.get(i); |
| |
| blockWriter.write(insn.getOpcode()); |
| switch (insn.getOpcode()) |
| { |
| case OP_hasnext2: |
| { |
| blockWriter.writeU30((Integer)insn.getOperand(0)); |
| blockWriter.writeU30((Integer)insn.getOperand(1)); |
| break; |
| } |
| case OP_findproperty: |
| case OP_findpropstrict: |
| case OP_getlex: |
| case OP_getsuper: |
| case OP_setsuper: |
| case OP_deleteproperty: |
| case OP_getdescendants: |
| case OP_getproperty: |
| case OP_setproperty: |
| case OP_initproperty: |
| case OP_istype: |
| case OP_coerce: |
| case OP_astype: |
| case OP_finddef: |
| { |
| blockWriter.writeU30(namePool.id((Name)insn.getOperand(0))); |
| break; |
| } |
| case OP_callproperty: |
| case OP_callproplex: |
| case OP_callpropvoid: |
| case OP_callsuper: |
| case OP_callsupervoid: |
| case OP_constructprop: |
| { |
| blockWriter.writeU30(namePool.id((Name)insn.getOperand(0))); |
| blockWriter.writeU30((Integer)insn.getOperand(1)); |
| break; |
| } |
| case OP_constructsuper: |
| case OP_call: |
| case OP_construct: |
| case OP_newarray: |
| case OP_newobject: |
| case OP_getlocal: |
| case OP_setlocal: |
| case OP_getslot: |
| case OP_setslot: |
| case OP_kill: |
| case OP_inclocal: |
| case OP_declocal: |
| case OP_inclocal_i: |
| case OP_declocal_i: |
| case OP_newcatch: |
| case OP_getglobalslot: |
| case OP_setglobalslot: |
| case OP_applytype: |
| case OP_getscopeobject: |
| case OP_pushshort: |
| { |
| blockWriter.writeU30(insn.getImmediate()); |
| break; |
| } |
| case OP_pushbyte: |
| { |
| blockWriter.write(insn.getImmediate()); |
| break; |
| } |
| case OP_newclass: |
| { |
| blockWriter.writeU30(getClassId((ClassInfo)insn.getOperand(0))); |
| break; |
| } |
| case OP_newfunction: |
| { |
| blockWriter.writeU30(getMethodId((MethodInfo)insn.getOperand(0))); |
| break; |
| } |
| case OP_callstatic: |
| { |
| blockWriter.writeU30(getMethodId((MethodInfo)insn.getOperand(0))); |
| blockWriter.writeU30((Integer)(insn.getOperand(1))); |
| break; |
| } |
| case OP_pushstring: |
| case OP_dxns: |
| case OP_debugfile: |
| { |
| blockWriter.writeU30(stringPool.id(insn.getOperand(0).toString())); |
| break; |
| } |
| case OP_pushnamespace: |
| { |
| blockWriter.writeU30(nsPool.id((Namespace)insn.getOperand(0))); |
| break; |
| } |
| case OP_pushint: |
| { |
| blockWriter.writeU30(intPool.id((Integer)insn.getOperand(0))); |
| break; |
| } |
| case OP_pushuint: |
| { |
| blockWriter.writeU30(uintPool.id((Long)insn.getOperand(0))); |
| break; |
| } |
| case OP_pushdouble: |
| { |
| blockWriter.writeU30(doublePool.id((Double)insn.getOperand(0))); |
| break; |
| } |
| case OP_debugline: |
| case OP_bkptline: |
| { |
| blockWriter.writeU30(insn.getImmediate()); |
| break; |
| } |
| case OP_debug: |
| { |
| blockWriter.write((Integer)(insn.getOperand(0))); |
| blockWriter.writeU30(stringPool.id(insn.getOperand(1).toString())); |
| blockWriter.write((Integer)insn.getOperand(2)); |
| blockWriter.writeU30(0); |
| break; |
| } |
| } |
| } |
| } |
| |
| private void emitNamespace(Namespace ns) |
| { |
| w.write(ns.getKind()); |
| w.writeU30(stringPool.id(ns.getVersionedName())); |
| } |
| |
| private void emitExceptionInfo(MethodBodyInfo f, ABCWriter w, Map<IBasicBlock, Integer> pos) |
| { |
| w.writeU30(f.getExceptions().size()); |
| |
| for (ExceptionInfo ex : f.getExceptions()) |
| { |
| if ( ex.isLive() ) |
| { |
| w.writeU30(pos.get(f.getBlock(ex.getFrom()))); |
| w.writeU30(pos.get(f.getBlock(ex.getTo()))); |
| w.writeU30(pos.get(f.getBlock(ex.getTarget()))); |
| w.writeU30(namePool.id(ex.getExceptionType())); |
| w.writeU30(namePool.id(ex.getCatchVar())); |
| } |
| } |
| } |
| |
| void emitLookupswitch(ABCWriter out, int code_start, MethodBodyInfo f, |
| Instruction switch_insn, Map<IBasicBlock, Integer> block_offsets) |
| { |
| int case_size = switch_insn.getOperandCount() - 1; // Last Label reserved for the default |
| |
| // "The base location is the address of the lookupswitch instruction itself." - AVM2 |
| int base_loc = out.size() - code_start; |
| |
| out.write(OP_lookupswitch); |
| |
| // The last label is the default case. |
| Label default_case = (Label)switch_insn.getOperand(case_size); |
| int default_offset = (block_offsets.get(f.getBlock(default_case)) - base_loc); |
| out.writeS24(default_offset); |
| |
| out.writeU30(case_size - 1); |
| |
| for (int i = 0; i < case_size; i++) |
| { |
| int branch_offset = (block_offsets.get(f.getBlock((Label)switch_insn.getOperand(i))) - base_loc); |
| out.writeS24(branch_offset); |
| } |
| } |
| |
| static class ABCWriter extends ByteArrayOutputStream |
| { |
| void rewind(int n) |
| { |
| super.count -= n; |
| } |
| |
| void writeU16(int i) |
| { |
| write(i); |
| write(i >> 8); |
| } |
| |
| void writeS24(int i) |
| { |
| writeU16(i); |
| write(i >> 16); |
| } |
| |
| void write64(long i) |
| { |
| writeS24((int)i); |
| writeS24((int)(i >> 24)); |
| writeU16((int)(i >> 48)); |
| } |
| |
| void writeU30(int v) |
| { |
| if (v < 128 && v >= 0) |
| { |
| write(v); |
| } |
| else if (v < 16384 && v >= 0) |
| { |
| write(v & 0x7F | 0x80); |
| write(v >> 7); |
| } |
| else if (v < 2097152 && v >= 0) |
| { |
| write(v & 0x7F | 0x80); |
| write(v >> 7 | 0x80); |
| write(v >> 14); |
| } |
| else if (v < 268435456 && v >= 0) |
| { |
| write(v & 0x7F | 0x80); |
| write(v >> 7 | 0x80); |
| write(v >> 14 | 0x80); |
| write(v >> 21); |
| } |
| else |
| { |
| write(v & 0x7F | 0x80); |
| write(v >> 7 | 0x80); |
| write(v >> 14 | 0x80); |
| write(v >> 21 | 0x80); |
| write(v >>> 28); |
| } |
| } |
| |
| int sizeOfU30(int v) |
| { |
| if (v < 128 && v >= 0) |
| return 1; |
| |
| else if (v < 16384 && v >= 0) |
| return 2; |
| |
| else if (v < 2097152 && v >= 0) |
| return 3; |
| |
| else if (v < 268435456 && v >= 0) |
| return 4; |
| |
| else |
| return 5; |
| } |
| |
| |
| /** |
| * Get the byte array contained within this stream. Note: flush may need to be called |
| * @return the byte array |
| */ |
| public byte[] getDirectByteArray() |
| { |
| // only return the buffer directly if the length of the buffer |
| // is the same as the count, as the buffer can be bigger than the |
| // count, and in this case, we return an array which is larger than |
| // expected, so we need to truncate it with a copy. |
| if (buf.length == count) |
| return buf; |
| else |
| return super.toByteArray(); |
| } |
| |
| /** |
| * Ensure toByteArray() is never called. |
| */ |
| @Override |
| public byte[] toByteArray() |
| { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| /** |
| * Find all the operands in a method body and make sure they find their way |
| * into the appropriate pool. |
| * |
| * @param mi - the method body. |
| * @post any runtime multinames have a dummy Name operand. |
| */ |
| void poolOperands(MethodBodyInfo mbi) |
| { |
| for (IBasicBlock b : mbi.getCfg().getBlocksInEntryOrder()) |
| { |
| for (Instruction insn : b.getInstructions()) |
| { |
| switch (insn.getOpcode()) |
| { |
| case OP_findproperty: |
| case OP_findpropstrict: |
| case OP_getlex: |
| case OP_getdescendants: |
| case OP_initproperty: |
| case OP_istype: |
| case OP_coerce: |
| case OP_astype: |
| case OP_finddef: |
| case OP_deleteproperty: |
| case OP_getproperty: |
| case OP_setproperty: |
| case OP_getsuper: |
| case OP_setsuper: |
| { |
| visitPooledName((Name)insn.getOperand(0)); |
| break; |
| } |
| case OP_callproperty: |
| case OP_callproplex: |
| case OP_callpropvoid: |
| case OP_callsuper: |
| case OP_callsupervoid: |
| case OP_constructprop: |
| { |
| visitPooledName((Name)insn.getOperand(0)); |
| break; |
| } |
| case OP_pushstring: |
| case OP_dxns: |
| case OP_debugfile: |
| { |
| stringPool.add(insn.getOperand(0).toString()); |
| break; |
| } |
| case OP_pushnamespace: |
| { |
| visitPooledNamespace((Namespace)insn.getOperand(0)); |
| break; |
| } |
| case OP_pushint: |
| { |
| intPool.add((Integer)insn.getOperand(0)); |
| break; |
| } |
| case OP_pushuint: |
| { |
| uintPool.add((Long)insn.getOperand(0)); |
| break; |
| } |
| case OP_pushdouble: |
| { |
| doublePool.add((Double)insn.getOperand(0)); |
| break; |
| } |
| case OP_debug: |
| { |
| stringPool.add(insn.getOperand(1).toString()); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Pool all the objects referenced by a Traits that need to be added to the |
| * various constant pools. These objects include: |
| * <ul> |
| * <li>The {@link Name} object for the qualified name of each {@link Trait}. |
| * </li> |
| * <li>The {@link Name} object that refers to the class or interface of each |
| * {@link Trait} with a type annotation.</li> |
| * <li>The {@link Metadata} objects that decorate each {@link Trait}.</li> |
| * <li>The {@link String}, {@link Namespace}, {@link Double}, |
| * {@link Integer}, or {@link Long} objects that specify the |
| * initial value of each {@link Trait}.</li> |
| * </ul> |
| */ |
| private void poolTraitsConstants(Traits ts) |
| { |
| for (Trait t : ts) |
| { |
| Name traitName = t.getNameAttr(Trait.TRAIT_NAME); |
| visitPooledName(traitName); |
| |
| if (t.hasAttr(Trait.TRAIT_TYPE)) |
| visitPooledName(t.getNameAttr(Trait.TRAIT_TYPE)); |
| |
| for (Metadata md : t.getMetadata()) |
| visitPooledMetadata(md); |
| |
| if (t.hasAttr(Trait.SLOT_VALUE)) |
| { |
| Object trait_value = t.getAttr(Trait.SLOT_VALUE); |
| if (trait_value == null) |
| { |
| // No action required; the pool ID resolution logic |
| // handles a null pointer by returning the nil pool value. |
| } |
| else if (trait_value instanceof String) |
| { |
| visitPooledString((String)trait_value); |
| } |
| else if (trait_value instanceof Namespace) |
| { |
| visitPooledNamespace((Namespace)trait_value); |
| } |
| else if (trait_value instanceof Double) |
| { |
| visitPooledDouble((Double)trait_value); |
| } |
| else if (trait_value instanceof Integer) |
| { |
| visitPooledInt((Integer)trait_value); |
| } |
| else if (trait_value instanceof Long) |
| { |
| visitPooledUInt((Long)trait_value); |
| } |
| else if (trait_value.equals(ABCConstants.UNDEFINED_VALUE) |
| || trait_value.equals(ABCConstants.NULL_VALUE) |
| || trait_value.equals(Boolean.TRUE) |
| || trait_value.equals(Boolean.FALSE)) |
| { |
| // Nothing to do, predefined value. |
| } |
| else |
| { |
| throw new IllegalStateException("Unrecognized initializer type: " + trait_value.getClass().toString()); |
| } |
| } |
| } |
| } |
| |
| @Override |
| public void visit(int majorVersion, int minorVersion) |
| { |
| verifyEmitterStatus(); |
| |
| this.lock.lock(); |
| |
| assert this.lock.getHoldCount() == 1 : "The hold count should be 1, beacuse this method should only be called once!"; |
| |
| if (versionABCMajor == VERSION_NONE) |
| { |
| versionABCMajor = majorVersion; |
| versionABCMinor = minorVersion; |
| } |
| else if (versionABCMajor != majorVersion || versionABCMinor != minorVersion) |
| { |
| throw new IllegalArgumentException("abc versions do not match"); |
| } |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| assertLockHeld(); |
| |
| this.visitEndCalled = true; |
| } |
| |
| @Override |
| public IClassVisitor visitClass(InstanceInfo iinfo, ClassInfo cinfo) |
| { |
| verifyEmitterStatus(); |
| |
| EmitterClassVisitor result = new EmitterClassVisitor(iinfo, cinfo); |
| result.visit(); |
| return result; |
| } |
| |
| @Override |
| public IScriptVisitor visitScript() |
| { |
| verifyEmitterStatus(); |
| |
| return new EmitterScriptInfo(); |
| } |
| |
| @Override |
| public IMethodVisitor visitMethod(MethodInfo minfo) |
| { |
| verifyEmitterStatus(); |
| |
| return new EmitterMethodInfoVisitor(minfo); |
| } |
| |
| @Override |
| public void visitPooledDouble(Double d) |
| { |
| verifyEmitterStatus(); |
| |
| this.doublePool.add(d); |
| } |
| |
| @Override |
| public void visitPooledInt(Integer i) |
| { |
| verifyEmitterStatus(); |
| |
| this.intPool.add(i); |
| } |
| |
| @Override |
| public void visitPooledMetadata(Metadata md) |
| { |
| verifyEmitterStatus(); |
| |
| this.metadataPool.add(md); |
| |
| visitPooledString(md.getName()); |
| |
| for (String key : md.getKeys()) |
| visitPooledString(key); |
| |
| for (String value : md.getValues()) |
| visitPooledString(value); |
| } |
| |
| @Override |
| public void visitPooledName(Name n) |
| { |
| verifyEmitterStatus(); |
| |
| if (null == n) |
| return; |
| |
| final int kind = n.getKind(); |
| |
| if (kind != ABCConstants.CONSTANT_TypeName) |
| { |
| this.namePool.add(n); |
| |
| visitPooledString(n.getBaseName()); |
| if ((kind == ABCConstants.CONSTANT_Qname) || (kind == ABCConstants.CONSTANT_QnameA)) |
| visitPooledNamespace(n.getSingleQualifier()); |
| else |
| visitPooledNsSet(n.getQualifiers()); |
| } |
| else |
| { |
| visitPooledName(n.getTypeNameBase()); |
| visitPooledName(n.getTypeNameParameter()); |
| this.namePool.add(n); |
| } |
| } |
| |
| @Override |
| public void visitPooledNamespace(Namespace ns) |
| { |
| verifyEmitterStatus(); |
| |
| this.nsPool.add(ns); |
| |
| if (ns != null) |
| visitPooledString(ns.getVersionedName()); |
| } |
| |
| @Override |
| public void visitPooledNsSet(Nsset nss) |
| { |
| verifyEmitterStatus(); |
| |
| this.nssetPool.add(nss); |
| |
| if (nss != null) |
| { |
| for (Namespace ns : nss) |
| { |
| visitPooledNamespace(ns); |
| } |
| } |
| } |
| |
| @Override |
| public void visitPooledString(String s) |
| { |
| verifyEmitterStatus(); |
| |
| this.stringPool.add(s); |
| } |
| |
| @Override |
| public void visitPooledUInt(Long l) |
| { |
| verifyEmitterStatus(); |
| |
| this.uintPool.add(l); |
| } |
| |
| public static int sizeOfU30(int v) |
| { |
| if (v < 128 && v >= 0) |
| return 1; |
| |
| else if (v < 16384 && v >= 0) |
| return 2; |
| |
| else if (v < 2097152 && v >= 0) |
| return 3; |
| |
| else if (v < 268435456 && v >= 0) |
| return 4; |
| |
| else |
| return 5; |
| |
| } |
| |
| private class EmitterClassVisitor implements IClassVisitor, ClassDependencySort.IInstanceInfoProvider |
| { |
| EmitterClassVisitor(InstanceInfo iinfo, ClassInfo cinfo) |
| { |
| this.classInfo = cinfo; |
| if (null == cinfo.classTraits) |
| cinfo.classTraits = new Traits(); |
| this.classTraits = cinfo.classTraits; |
| |
| this.instanceInfo = iinfo; |
| |
| if (null == iinfo.traits) |
| iinfo.traits = new Traits(); |
| this.instanceTraits = iinfo.traits; |
| if (null == iinfo.interfaceNames) |
| iinfo.interfaceNames = new Name[0]; |
| } |
| |
| ClassInfo classInfo; |
| Traits classTraits; |
| InstanceInfo instanceInfo; |
| Traits instanceTraits; |
| |
| @Override |
| public void visit() |
| { |
| verifyEmitterStatus(); |
| } |
| |
| @Override |
| public ITraitsVisitor visitClassTraits() |
| { |
| verifyEmitterStatus(); |
| return new EmitterTraitsVisitor(this.classTraits); |
| } |
| |
| @Override |
| public ITraitsVisitor visitInstanceTraits() |
| { |
| verifyEmitterStatus(); |
| return new EmitterTraitsVisitor(this.instanceTraits); |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| |
| assertLockHeld(); |
| definedClasses.add(this); |
| if (null == classInfo.cInit) |
| { |
| classInfo.cInit = new MethodInfo(); |
| MethodBodyInfo m_cinit = new MethodBodyInfo(); |
| m_cinit.setMethodInfo(classInfo.cInit); |
| |
| IMethodVisitor mv = visitMethod(classInfo.cInit); |
| mv.visit(); |
| IMethodBodyVisitor mbv = mv.visitBody(m_cinit); |
| mbv.visit(); |
| mbv.visitInstruction(OP_returnvoid); |
| mbv.visitEnd(); |
| mv.visitEnd(); |
| } |
| |
| visitPooledName(instanceInfo.name); |
| visitPooledName(instanceInfo.superName); |
| |
| if (instanceInfo.hasProtectedNs()) |
| visitPooledNamespace(instanceInfo.protectedNs); |
| |
| if (null == instanceInfo.iInit) |
| { |
| instanceInfo.iInit = new MethodInfo(); |
| MethodBodyInfo iinit = new MethodBodyInfo(); |
| iinit.setMethodInfo(instanceInfo.iInit); |
| |
| IMethodVisitor mv = visitMethod(instanceInfo.iInit); |
| mv.visit(); |
| |
| // Interfaces need an instance init method, |
| // but it doesn't have a body. |
| if (0 == (instanceInfo.flags & ABCConstants.CLASS_FLAG_interface)) |
| { |
| IMethodBodyVisitor mbv = mv.visitBody(iinit); |
| mbv.visit(); |
| mbv.visitInstruction(OP_getlocal0); |
| mbv.visitInstruction(OP_pushscope); |
| mbv.visitInstruction(OP_getlocal0); |
| mbv.visitInstruction(ABCConstants.OP_constructsuper, 0); |
| mbv.visitInstruction(OP_returnvoid); |
| mbv.visitEnd(); |
| } |
| mv.visitEnd(); |
| } |
| |
| if (instanceInfo.interfaceNames != null) |
| { |
| for (Name interface_name : instanceInfo.interfaceNames) |
| { |
| visitPooledName(interface_name); |
| } |
| } |
| } |
| |
| @Override |
| public InstanceInfo getInstanceInfo() |
| { |
| return this.instanceInfo; |
| } |
| } |
| |
| private class EmitterTraitsVisitor implements ITraitsVisitor |
| { |
| EmitterTraitsVisitor(Traits traits) |
| { |
| this.traits = traits; |
| } |
| |
| Traits traits; |
| |
| @Override |
| public ITraitVisitor visitClassTrait(int kind, Name name, int slot_id, ClassInfo clazz) |
| { |
| verifyEmitterStatus(); |
| |
| Trait t = createTrait(kind, name); |
| if (slot_id != 0) |
| t.addAttr(Trait.TRAIT_SLOT, slot_id); |
| t.addAttr(Trait.TRAIT_CLASS, clazz); |
| |
| return new EmitterTraitVisitor(t); |
| } |
| |
| @Override |
| public ITraitVisitor visitMethodTrait(int kind, Name name, int dispId, MethodInfo method) |
| { |
| verifyEmitterStatus(); |
| |
| Trait t = createTrait(kind, name); |
| t.addAttr(Trait.TRAIT_METHOD, method); |
| if (dispId != 0) |
| t.addAttr(Trait.TRAIT_DISP, dispId); |
| return new EmitterTraitVisitor(t); |
| } |
| |
| @Override |
| public ITraitVisitor visitSlotTrait(int kind, Name name, int slotId, Name slotType, Object slotValue) |
| { |
| verifyEmitterStatus(); |
| |
| Trait t = createTrait(kind, name); |
| t.addAttr(Trait.TRAIT_SLOT, slotId); |
| t.addAttr(Trait.TRAIT_TYPE, slotType); |
| t.addAttr(Trait.SLOT_VALUE, slotValue); |
| if (slotType != null) |
| visitPooledName(slotType); |
| return new EmitterTraitVisitor(t); |
| } |
| |
| @Override |
| public void visit() |
| { |
| verifyEmitterStatus(); |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| |
| assertLockHeld(); |
| poolTraitsConstants(traits); |
| } |
| |
| @Override |
| public Traits getTraits() |
| { |
| return this.traits; |
| } |
| |
| private Trait createTrait(int kind, Name name) |
| { |
| verifyEmitterStatus(); |
| |
| Trait t = new Trait(kind, name); |
| traits.add(t); |
| return t; |
| } |
| } |
| |
| private class EmitterTraitVisitor implements ITraitVisitor |
| { |
| EmitterTraitVisitor(Trait t) |
| { |
| this.t = t; |
| } |
| |
| Trait t; |
| |
| @Override |
| public IMetadataVisitor visitMetadata(int count) |
| { |
| verifyEmitterStatus(); |
| |
| return new IMetadataVisitor() |
| { |
| |
| @Override |
| public void visit(Metadata md) |
| { |
| verifyEmitterStatus(); |
| |
| t.addMetadata(md); |
| } |
| }; |
| } |
| |
| @Override |
| public void visitAttribute(String attr_name, Object attr_value) |
| { |
| verifyEmitterStatus(); |
| |
| this.t.addAttr(attr_name, attr_value); |
| } |
| |
| @Override |
| public void visitStart() |
| { |
| verifyEmitterStatus(); |
| |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| |
| // We do not need to assert that the lock is held, because this method is empty, |
| // but if this method ever started doing anything we would not want clients to |
| // be broken. |
| assertLockHeld(); |
| } |
| } |
| |
| private class EmitterMethodBodyInfo implements IMethodBodyVisitor |
| { |
| EmitterMethodBodyInfo(MethodBodyInfo mbinfo) |
| { |
| this.mbi = mbinfo; |
| } |
| |
| MethodBodyInfo mbi; |
| |
| @Override |
| public void visit() |
| { |
| verifyEmitterStatus(); |
| |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| |
| assertLockHeld(); |
| poolOperands(mbi); |
| methodBodies.add(mbi); |
| |
| for (ExceptionInfo exceptionInfo : mbi.getExceptions()) |
| { |
| visitPooledName(exceptionInfo.getExceptionType()); |
| visitPooledName(exceptionInfo.getCatchVar()); |
| } |
| } |
| |
| @Override |
| public void visitInstruction(int opcode) |
| { |
| verifyEmitterStatus(); |
| |
| this.mbi.insn(opcode); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode, int immediate_operand) |
| { |
| verifyEmitterStatus(); |
| |
| this.mbi.insn(opcode, immediate_operand); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode, Object single_operand) |
| { |
| verifyEmitterStatus(); |
| |
| this.mbi.insn(opcode, single_operand); |
| } |
| |
| @Override |
| public void visitInstruction(int opcode, Object[] operands) |
| { |
| verifyEmitterStatus(); |
| |
| this.mbi.insn(opcode, operands); |
| } |
| |
| @Override |
| public void visitInstruction(Instruction insn) |
| { |
| verifyEmitterStatus(); |
| |
| this.mbi.insn(insn); |
| } |
| |
| @Override |
| public ITraitsVisitor visitTraits() |
| { |
| verifyEmitterStatus(); |
| |
| return new EmitterTraitsVisitor(this.mbi.getTraits()); |
| } |
| |
| @Override |
| public int visitException(Label from, Label to, Label target, Name ex_type, Name ex_var) |
| { |
| verifyEmitterStatus(); |
| |
| return mbi.addExceptionInfo(new ExceptionInfo(from, to, target, ex_type, ex_var)); |
| } |
| |
| @Override |
| public void visitInstructionList(InstructionList new_list) |
| { |
| verifyEmitterStatus(); |
| |
| mbi.setInstructionList(new_list); |
| } |
| |
| @Override |
| public void labelCurrent(Label l) |
| { |
| mbi.labelCurrent(l); |
| } |
| |
| @Override |
| public void labelNext(Label l) |
| { |
| mbi.labelNext(l); |
| } |
| } |
| |
| private class EmitterScriptInfo implements IScriptVisitor |
| { |
| EmitterScriptInfo() |
| { |
| this.si = new ScriptInfo(); |
| } |
| |
| final ScriptInfo si; |
| |
| @Override |
| public void visit() |
| { |
| verifyEmitterStatus(); |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| assertLockHeld(); |
| scriptInfos.add(this.si); |
| } |
| |
| @Override |
| public void visitInit(MethodInfo init_method) |
| { |
| verifyEmitterStatus(); |
| |
| si.setInit(init_method); |
| } |
| |
| @Override |
| public ITraitsVisitor visitTraits() |
| { |
| verifyEmitterStatus(); |
| |
| return new EmitterTraitsVisitor(si.getTraits()); |
| } |
| } |
| |
| private class EmitterMethodInfoVisitor implements IMethodVisitor |
| { |
| EmitterMethodInfoVisitor(MethodInfo mi) |
| { |
| assert (mi != null); |
| this.mi = mi; |
| } |
| |
| final MethodInfo mi; |
| |
| MethodBodyInfo mbi; |
| |
| @Override |
| public void visit() |
| { |
| verifyEmitterStatus(); |
| |
| // We need to grab a lock before adding the method |
| // info to the method pool because this method ( the visit method ) |
| // can be called from any number of threads at the same time for the |
| // same emitter. This is the only place where we mutate emitter |
| // state from a method other than visitEnd. |
| // |
| // We need to add the method info to the method pool here |
| // so that the EmitterMethodBodyInfo.visitEnd call for other |
| // methods can compute a method id for the method info |
| // associated with this EmitterMethodInfoVisitor before |
| // visitEnd has been called on this EmitterMethodInfoVisitor. |
| final Lock methodInfosWriteLock = methodInfosLock.writeLock(); |
| methodInfosWriteLock.lock(); |
| try |
| { |
| methodInfos.add(mi); |
| } |
| finally |
| { |
| methodInfosWriteLock.unlock(); |
| } |
| } |
| |
| @Override |
| public IMethodBodyVisitor visitBody(MethodBodyInfo mbi) |
| { |
| verifyEmitterStatus(); |
| |
| this.mbi = mbi; |
| return new EmitterMethodBodyInfo(mbi); |
| } |
| |
| @Override |
| public void visitEnd() |
| { |
| verifyEmitterStatus(); |
| |
| assertLockHeld(); |
| |
| for (Name param_type_name : mi.getParamTypes()) |
| visitPooledName(param_type_name); |
| |
| if ((mbi != null) && (mi.isNative())) |
| diagnosticsVisitor.nativeMethodWithMethodBody(mi, mbi); |
| |
| visitPooledString(mi.getMethodName()); |
| visitPooledName(mi.getReturnType()); |
| |
| for (Name ptype : mi.getParamTypes()) |
| { |
| visitPooledName(ptype); |
| } |
| |
| if (mi.hasOptional()) |
| { |
| for (PooledValue v : mi.getDefaultValues()) |
| { |
| v.setPoolIndex(visitPooledValue(v)); |
| } |
| } |
| |
| if (mi.hasParamNames()) |
| { |
| for (String param_name : mi.getParamNames()) |
| { |
| visitPooledString(param_name); |
| } |
| } |
| |
| // Save the method body as compressed ABC bytecode, |
| // if so indicated. EmitterMethodBodyInfo.visitEnd() |
| // does not do this because the method body needs the |
| // type names and default values pooled in this method. |
| if (this.mbi != null) |
| { |
| this.mbi.computeFrameCounts(ABCEmitter.this.diagnosticsVisitor); |
| |
| // Don't eagerly emit (to ABC blobs) method bodies that |
| // contain newclass instructions. The class declarations |
| // are the one ABC header structure that may be sorted even |
| // without optimization (to reorder the declarations in |
| // dependency order). If that happens then the indices |
| // in the newclass instructions would be invalid. |
| if (eagerlyEmitMethodBodies && !this.mbi.hasNewclassInstruction()) |
| { |
| try |
| { |
| emitCode(this.mbi); |
| } |
| catch (RuntimeException uncheckedSNAFU) |
| { |
| throw uncheckedSNAFU; |
| } |
| catch (Exception checkedSNAFU) |
| { |
| // TODO: The AET needs an error/warnings interface. |
| // For now, "report" by rethrowing wrapped in an |
| // unchecked exception. |
| throw new IllegalStateException(checkedSNAFU); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Record a PooledValue's value in the appropriate constant pool. |
| * |
| * @return the pool index. |
| * @see #PooledValue.setPoolIndex() which consumes the index. |
| */ |
| private int visitPooledValue(PooledValue value) |
| { |
| switch (value.getKind()) |
| { |
| case ABCConstants.CONSTANT_Int: |
| { |
| visitPooledInt(value.getIntegerValue()); |
| return this.intPool.id(value.getIntegerValue()); |
| } |
| case ABCConstants.CONSTANT_UInt: |
| { |
| visitPooledUInt(value.getLongValue()); |
| return this.uintPool.id(value.getLongValue()); |
| } |
| case ABCConstants.CONSTANT_Double: |
| { |
| visitPooledDouble(value.getDoubleValue()); |
| return this.doublePool.id(value.getDoubleValue()); |
| } |
| case ABCConstants.CONSTANT_Utf8: |
| { |
| visitPooledString(value.getStringValue()); |
| return this.stringPool.id(value.getStringValue()); |
| } |
| // The kind and index for a manifest CONSTANT are identical. |
| case ABCConstants.CONSTANT_True: |
| { |
| return ABCConstants.CONSTANT_True; |
| } |
| case ABCConstants.CONSTANT_False: |
| { |
| return ABCConstants.CONSTANT_False; |
| } |
| case ABCConstants.CONSTANT_Undefined: |
| { |
| return ABCConstants.CONSTANT_Undefined; |
| } |
| case ABCConstants.CONSTANT_Null: |
| { |
| return ABCConstants.CONSTANT_Null; |
| } |
| // All these variants of namespace are stored in the same pool. |
| case ABCConstants.CONSTANT_Namespace: |
| case ABCConstants.CONSTANT_PackageNs: |
| case ABCConstants.CONSTANT_PackageInternalNs: |
| case ABCConstants.CONSTANT_ProtectedNs: |
| case ABCConstants.CONSTANT_ExplicitNamespace: |
| case ABCConstants.CONSTANT_StaticProtectedNs: |
| case ABCConstants.CONSTANT_PrivateNs: |
| { |
| visitPooledNamespace(value.getNamespaceValue()); |
| return this.nsPool.id(value.getNamespaceValue()); |
| } |
| default: |
| { |
| throw new IllegalStateException("Unrecognized initializer type: " + value.getKind()); |
| } |
| } |
| } |
| |
| /** |
| * Allow invalid jump instructions for legacy ABCs. |
| * @param b - true if the caller wishes to allow bad jumps. |
| */ |
| public void setAllowBadJumps(boolean b) |
| { |
| this.allowBadJumps = b; |
| } |
| |
| /** |
| * Lock used to enforce concurrency rules of this class. |
| * <p> |
| * This method is used to ensure that vistEnd calls are only made on the |
| * same thread that called {@link #visit(int, int)}. |
| * <p> |
| * When running with asserts enabled this method will cause an assertion |
| * failure when the currency rules of this class are violated. |
| * <p> |
| * When running with asserts disabled this method will cause a deadlock when |
| * the currency rules of this class are violated. |
| * |
| * @see #lock() |
| */ |
| private void assertLockHeld() |
| { |
| assert this.lock.isHeldByCurrentThread() : "A visitEnd method was called from a thread other than the thread that called IABCVisitor.visit!"; |
| // lock immediately followed by unlock should be a NOP, unless |
| // some other thread holds the lock ( which the assert above guards against when |
| // running with asserts enabled ). |
| lock.lock(); |
| lock.unlock(); |
| } |
| |
| /** |
| * verifyEmitterStatus() verifies that the emitter has not seen a visitEnd() |
| * call. |
| */ |
| private void verifyEmitterStatus() |
| { |
| if (this.visitEndCalled) |
| throw new IllegalStateException("An ABCEmitter can only emit once visitEnd has been called."); |
| } |
| } |
