jdk-sandbox: comparison src/java.xml/share/classes/com/sun/org/apache/xalan/internal/xsltc/compiler/util/MethodGenerator.java

equal deleted inserted replaced

-:d07d5f7cab35
+:e1a6c0168741
 /*
 * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved.
+* @LastModified: Oct 2017
 */
 /*
 * 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.
 * $Id: MethodGenerator.java,v 1.2.4.1 2005/09/05 11:16:47 pvedula Exp $
 */
 package com.sun.org.apache.xalan.internal.xsltc.compiler.util;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.Stack;
 import com.sun.org.apache.bcel.internal.Const;
 import com.sun.org.apache.bcel.internal.classfile.Field;
 import com.sun.org.apache.bcel.internal.classfile.Method;
 import com.sun.org.apache.bcel.internal.generic.ALOAD;
 import com.sun.org.apache.bcel.internal.generic.ASTORE;
 import com.sun.org.apache.bcel.internal.generic.FLOAD;
 import com.sun.org.apache.bcel.internal.generic.FSTORE;
 import com.sun.org.apache.bcel.internal.generic.GETFIELD;
 import com.sun.org.apache.bcel.internal.generic.GOTO;
 import com.sun.org.apache.bcel.internal.generic.ICONST;
-import com.sun.org.apache.bcel.internal.generic.IfInstruction;
 import com.sun.org.apache.bcel.internal.generic.ILOAD;
-import com.sun.org.apache.bcel.internal.generic.IndexedInstruction;
 import com.sun.org.apache.bcel.internal.generic.INVOKEINTERFACE;
 import com.sun.org.apache.bcel.internal.generic.INVOKESPECIAL;
 import com.sun.org.apache.bcel.internal.generic.INVOKESTATIC;
 import com.sun.org.apache.bcel.internal.generic.INVOKEVIRTUAL;
 import com.sun.org.apache.bcel.internal.generic.ISTORE;
+import com.sun.org.apache.bcel.internal.generic.IfInstruction;
+import com.sun.org.apache.bcel.internal.generic.IndexedInstruction;
 import com.sun.org.apache.bcel.internal.generic.Instruction;
 import com.sun.org.apache.bcel.internal.generic.InstructionConst;
 import com.sun.org.apache.bcel.internal.generic.InstructionHandle;
 import com.sun.org.apache.bcel.internal.generic.InstructionList;
 import com.sun.org.apache.bcel.internal.generic.InstructionTargeter;
+import com.sun.org.apache.bcel.internal.generic.LLOAD;
+import com.sun.org.apache.bcel.internal.generic.LSTORE;
 import com.sun.org.apache.bcel.internal.generic.LocalVariableGen;
 import com.sun.org.apache.bcel.internal.generic.LocalVariableInstruction;
-import com.sun.org.apache.bcel.internal.generic.LLOAD;
-import com.sun.org.apache.bcel.internal.generic.LSTORE;
 import com.sun.org.apache.bcel.internal.generic.MethodGen;
 import com.sun.org.apache.bcel.internal.generic.NEW;
 import com.sun.org.apache.bcel.internal.generic.PUTFIELD;
 import com.sun.org.apache.bcel.internal.generic.RET;
 import com.sun.org.apache.bcel.internal.generic.Select;
 import com.sun.org.apache.bcel.internal.generic.TargetLostException;
 import com.sun.org.apache.bcel.internal.generic.Type;
 import com.sun.org.apache.xalan.internal.xsltc.compiler.Pattern;
 import com.sun.org.apache.xalan.internal.xsltc.compiler.XSLTC;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Stack;
 /**
 * @author Jacek Ambroziak
 * @author Santiago Pericas-Geertsen
 */
 * {@link #outline(InstructionHandle,InstructionHandle,String,ClassGenerator)},
 * this class keeps track of all local variables defined by the method.</p>
 */
 protected class LocalVariableRegistry {
 /**
-* <p>A <code>java.lang.ArrayList</code> of all
+* <p>A <code>java.lang.List</code> of all
 * {@link LocalVariableGen}s created for this method, indexed by the
 * slot number of the local variable.  The JVM stack frame of local
 * variables is divided into "slots".  A single slot can be used to
 * store more than one variable in a method, without regard to type, so
 * long as the byte code keeps the ranges of the two disjoint.</p>
 * <code>LocalVariableGen</code>; if more than one occurs, the
 * corresponding entry contains all such <code>LocalVariableGen</code>s
 * registered for the same slot; and if none occurs, the entry will be
 * <code>null</code>.
 */
-protected ArrayList _variables = new ArrayList();
+protected List<Object> _variables = new ArrayList<>();
 /**
 * Maps a name to a {@link LocalVariableGen}
 */
-protected HashMap _nameToLVGMap = new HashMap();
+protected Map<String, Object> _nameToLVGMap = new HashMap<>();
 /**
 * Registers a {@link org.apache.bcel.generic.LocalVariableGen}
 * for this method.
 * <p><b>Preconditions:</b>
 * <code>LocalVariableGen</code> with the same slot index previously
 * registered for this method.  <b><em>(Unchecked.)</em></b></li>
 * </ul></p>
 * @param lvg The variable to be registered
 */
+@SuppressWarnings("unchecked")
 protected void registerLocalVariable(LocalVariableGen lvg) {
 int slot = lvg.getIndex();
 int registrySize = _variables.size();
 // _variables just contains null padding, store the
 // LocalVariableGen directly.
 Object localsInSlot = _variables.get(slot);
 if (localsInSlot != null) {
 if (localsInSlot instanceof LocalVariableGen) {
-ArrayList listOfLocalsInSlot = new ArrayList();
+List<LocalVariableGen> listOfLocalsInSlot = new ArrayList<>();
-listOfLocalsInSlot.add(localsInSlot);
+listOfLocalsInSlot.add((LocalVariableGen)localsInSlot);
 listOfLocalsInSlot.add(lvg);
 _variables.set(slot, listOfLocalsInSlot);
 } else {
-((ArrayList) localsInSlot).add(lvg);
+((List<LocalVariableGen>) localsInSlot).add(lvg);
 }
 } else {
 _variables.set(slot, lvg);
 }
 }
 LocalVariableGen lvg = (LocalVariableGen)localsInSlot;
 if (offsetInLocalVariableGenRange(lvg, offset)) {
 return lvg;
 }
 } else {
-ArrayList listOfLocalsInSlot = (ArrayList) localsInSlot;
+@SuppressWarnings("unchecked")
-int size = listOfLocalsInSlot.size();
+List<LocalVariableGen> listOfLocalsInSlot =
+(List<LocalVariableGen>) localsInSlot;
-for (int i = 0; i < size; i++) {
-LocalVariableGen lvg =
+for (LocalVariableGen lvg : listOfLocalsInSlot) {
-(LocalVariableGen)listOfLocalsInSlot.get(i);
 if (offsetInLocalVariableGenRange(lvg, offset)) {
 return lvg;
 }
 }
 }
 * set, which causes problems for outlining..</p>
 * <p>See also {@link #lookUpByName(String)} and
 * {@link #removeByNameTracking(LocalVariableGen)}</P
 * @param lvg a <code>LocalVariableGen</code>
 */
+@SuppressWarnings("unchecked")
 protected void registerByName(LocalVariableGen lvg) {
 Object duplicateNameEntry = _nameToLVGMap.get(lvg.getName());
 if (duplicateNameEntry == null) {
 _nameToLVGMap.put(lvg.getName(), lvg);
 } else {
-ArrayList sameNameList;
+List<LocalVariableGen> sameNameList;
 if (duplicateNameEntry instanceof ArrayList) {
-sameNameList = (ArrayList) duplicateNameEntry;
+sameNameList = (List<LocalVariableGen>)duplicateNameEntry;
 sameNameList.add(lvg);
 } else {
-sameNameList = new ArrayList();
+sameNameList = new ArrayList<>();
-sameNameList.add(duplicateNameEntry);
+sameNameList.add((LocalVariableGen)duplicateNameEntry);
 sameNameList.add(lvg);
 }
 _nameToLVGMap.put(lvg.getName(), sameNameList);
 }
 * {@link LocalVariableGen} to itself.
 * See also {@link #registerByName(LocalVariableGen)} and
 * {@link #lookUpByName(String)}
 * @param lvg a <code>LocalVariableGen</code>
 */
+@SuppressWarnings("unchecked")
 protected void removeByNameTracking(LocalVariableGen lvg) {
 Object duplicateNameEntry = _nameToLVGMap.get(lvg.getName());
 if (duplicateNameEntry instanceof ArrayList) {
-ArrayList sameNameList = (ArrayList) duplicateNameEntry;
+List<LocalVariableGen> sameNameList =
+(List<LocalVariableGen>)duplicateNameEntry;
 for (int i = 0; i < sameNameList.size(); i++) {
 if (sameNameList.get(i) == lvg) {
 sameNameList.remove(i);
 break;
 }
 * <p>See also {@link #registerByName(LocalVariableGen)} and
 * {@link #removeByNameTracking(LocalVariableGen)}</p>
 * @param name
 * @return
 */
+@SuppressWarnings("unchecked")
 protected LocalVariableGen lookUpByName(String name) {
 LocalVariableGen lvg = null;
 Object duplicateNameEntry = _nameToLVGMap.get(name);
 if (duplicateNameEntry instanceof ArrayList) {
-ArrayList sameNameList = (ArrayList) duplicateNameEntry;
+List<LocalVariableGen> sameNameList =
+(List<LocalVariableGen>)duplicateNameEntry;
 for (int i = 0; i < sameNameList.size(); i++) {
-lvg = (LocalVariableGen)sameNameList.get(i);
+lvg = sameNameList.get(i);
-if (lvg.getName() == name) {
+if (lvg.getName() == null ? name == null : lvg.getName().equals(name)) {
 break;
 }
 }
 } else {
 lvg = (LocalVariableGen) duplicateNameEntry;
 * declared should be returned (<code>true</code>) or only those not
 * removed (<code>false</code>)
 * @return an array of <code>LocalVariableGen</code> containing all the
 * local variables
 */
+@SuppressWarnings("unchecked")
 protected LocalVariableGen[] getLocals(boolean includeRemoved) {
 LocalVariableGen[] locals = null;
-ArrayList allVarsEverDeclared = new ArrayList();
+List<LocalVariableGen> allVarsEverDeclared = new ArrayList<>();
 if (includeRemoved) {
 int slotCount = allVarsEverDeclared.size();
 for (int i = 0; i < slotCount; i++) {
 Object slotEntries = _variables.get(i);
 if (slotEntries != null) {
 if (slotEntries instanceof ArrayList) {
-ArrayList slotList = (ArrayList) slotEntries;
+List<LocalVariableGen> slotList =
+(List<LocalVariableGen>)slotEntries;
 for (int j = 0; j < slotList.size(); j++) {
 allVarsEverDeclared.add(slotList.get(i));
 }
 } else {
-allVarsEverDeclared.add(slotEntries);
+allVarsEverDeclared.add((LocalVariableGen)slotEntries);
 }
 }
 }
 } else {
-Iterator nameVarsPairsIter = _nameToLVGMap.entrySet().iterator();
+for (Map.Entry<String, Object> nameVarsPair : _nameToLVGMap.entrySet()) {
-while (nameVarsPairsIter.hasNext()) {
-Map.Entry nameVarsPair =
-(Map.Entry) nameVarsPairsIter.next();
 Object vars = nameVarsPair.getValue();
 if (vars != null) {
 if (vars instanceof ArrayList) {
-ArrayList varsList = (ArrayList) vars;
+List<LocalVariableGen> varsList =
+(List<LocalVariableGen>) vars;
 for (int i = 0; i < varsList.size(); i++) {
 allVarsEverDeclared.add(varsList.get(i));
 }
 } else {
-allVarsEverDeclared.add(vars);
+allVarsEverDeclared.add((LocalVariableGen)vars);
 }
 }
 }
 }
 /**
 * Used to keep track of an outlineable chunk of instructions in the
 * current method.  See {@link OutlineableChunkStart} and
 * {@link OutlineableChunkEnd} for more information.
 */
-private class Chunk implements Comparable {
+private class Chunk implements Comparable<Object> {
 /**
 * {@link InstructionHandle} of the first instruction in the outlineable
 * chunk.
 */
 private InstructionHandle m_start;
 * Find the outlineable chunks in this method that would be the best choices
 * to outline, based on size and position in the method.
 * @param classGen The {@link ClassGen} with which the generated methods
 *                 will be associated
 * @param totalMethodSize the size of the bytecode in the original method
-* @return a <code>java.util.ArrayList</code> containing the
+* @return a <code>java.util.List</code> containing the
 *  {@link MethodGenerator.Chunk}s that may be outlined from this method
 */
-private ArrayList getCandidateChunks(ClassGenerator classGen,
+private List<Chunk> getCandidateChunks(ClassGenerator classGen,
 int totalMethodSize) {
-Iterator instructions = getInstructionList().iterator();
+Iterator<InstructionHandle> instructions = getInstructionList().iterator();
-ArrayList candidateChunks = new ArrayList();
+List<Chunk> candidateChunks = new ArrayList<>();
-ArrayList currLevelChunks = new ArrayList();
+List<InstructionHandle> currLevelChunks = new ArrayList<>();
-Stack subChunkStack = new Stack();
+Stack<List<InstructionHandle>> subChunkStack = new Stack<>();
 boolean openChunkAtCurrLevel = false;
 boolean firstInstruction = true;
 InstructionHandle currentHandle;
 // OutlineableChunkStart, this represents the first chunk
 // nested within that previous chunk - push the list of chunks
 // from the outer level onto the stack
 if (openChunkAtCurrLevel) {
 subChunkStack.push(currLevelChunks);
-currLevelChunks = new ArrayList();
+currLevelChunks = new ArrayList<>();
 }
 openChunkAtCurrLevel = true;
 currLevelChunks.add(currentHandle);
 // Close off an open chunk
 } else if (currentHandle == null
 || inst instanceof OutlineableChunkEnd) {
-ArrayList nestedSubChunks = null;
+List<InstructionHandle> nestedSubChunks = null;
 // If the last MarkerInstruction encountered was an
 // OutlineableChunkEnd, it means that the current instruction
 // marks the end of a chunk that contained child chunks.
 // Those children might need to be examined below in case they
 // are better candidates for outlining than the current chunk.
 if (!openChunkAtCurrLevel) {
 nestedSubChunks = currLevelChunks;
-currLevelChunks = (ArrayList)subChunkStack.pop();
+currLevelChunks = (List<InstructionHandle>)subChunkStack.pop();
 }
 // Get the handle for the start of this chunk (the last entry
 // in currLevelChunks)
 InstructionHandle chunkStart =
 childChunks[i] = new Chunk(start, end);
 }
 // Merge adjacent siblings
-ArrayList mergedChildChunks =
+List<Chunk> mergedChildChunks =
 mergeAdjacentChunks(childChunks);
 // Add chunks that mean minimum size requirements
 // to the list of candidate chunks for outlining
-for (int i = 0; i < mergedChildChunks.size(); i++) {
+for (Chunk mergedChunk : mergedChildChunks) {
-Chunk mergedChunk =
-(Chunk)mergedChildChunks.get(i);
 int mergedSize = mergedChunk.getChunkSize();
 if (mergedSize >= MINIMUM_OUTLINEABLE_CHUNK_SIZE
 && mergedSize <= TARGET_METHOD_SIZE) {
 candidateChunks.add(mergedChunk);
 * Merge adjacent sibling chunks to produce larger candidate chunks for
 * outlining
 * @param chunks array of sibling {@link MethodGenerator.Chunk}s that are
 *               under consideration for outlining.  Chunks must be in
 *               the order encountered in the {@link InstructionList}
-* @return a <code>java.util.ArrayList</code> of
+* @return a <code>java.util.List</code> of
 *         <code>MethodGenerator.Chunk</code>s maximally merged
 */
-private ArrayList mergeAdjacentChunks(Chunk[] chunks) {
+private List<Chunk> mergeAdjacentChunks(Chunk[] chunks) {
 int[] adjacencyRunStart = new int[chunks.length];
 int[] adjacencyRunLength = new int[chunks.length];
 boolean[] chunkWasMerged = new boolean[chunks.length];
 int maximumRunOfChunks = 0;
 int startOfCurrentRun;
 int numAdjacentRuns = 0;
-ArrayList mergedChunks = new ArrayList();
+List<Chunk> mergedChunks = new ArrayList<>();
 startOfCurrentRun = 0;
 // Loop through chunks, and record in adjacencyRunStart where each
 // run of adjacent chunks begins and how many are in that run.  For
 * @return an array of the outlined <code>Method</code>s and the original
 *         method itself
 */
 public Method[] outlineChunks(ClassGenerator classGen,
 int originalMethodSize) {
-ArrayList methodsOutlined = new ArrayList();
+List<Method> methodsOutlined = new ArrayList<>();
 int currentMethodSize = originalMethodSize;
 int outlinedCount = 0;
 boolean moreMethodsOutlined;
 String originalMethodName = getName();
 // Loop until the original method comes in under the JVM limit or
 // the loop was unable to outline any more methods
 do {
 // Get all the best candidates for outlining, and sort them in
 // ascending order of size
-ArrayList candidateChunks = getCandidateChunks(classGen,
+List<Chunk> candidateChunks = getCandidateChunks(classGen,
 currentMethodSize);
 Collections.sort(candidateChunks);
 moreMethodsOutlined = false;
 // Keeps track of the mapping from instruction handles in the old
 // method to instruction handles in the outlined method.  Only need
 // to track instructions that are targeted by something else in the
 // generated BCEL
-HashMap targetMap   = new HashMap();
+HashMap<InstructionHandle, InstructionHandle> targetMap = new HashMap<>();
 // Keeps track of the mapping from local variables in the old method
 // to local variables in the outlined method.
-HashMap localVarMap = new HashMap();
+HashMap<LocalVariableGen, LocalVariableGen> localVarMap = new HashMap<>();
-HashMap revisedLocalVarStart = new HashMap();
+HashMap<LocalVariableGen, InstructionHandle> revisedLocalVarStart = new HashMap<>();
-HashMap revisedLocalVarEnd = new HashMap();
+HashMap<LocalVariableGen, InstructionHandle> revisedLocalVarEnd = new HashMap<>();
 // Pass 1: Make copies of all instructions, append them to the new list
 // and associate old instruction references with the new ones, i.e.,
 // a 1:1 mapping.  The special marker instructions are not copied.
 // Also, identify local variables whose values need to be copied into or
 int oldLocalVarIndex = lvi.getIndex();
 LocalVariableGen oldLVG =
 getLocalVariableRegistry()
 .lookupRegisteredLocalVariable(oldLocalVarIndex,
 ih.getPosition());
-LocalVariableGen newLVG =
+LocalVariableGen newLVG = localVarMap.get(oldLVG);
-(LocalVariableGen)localVarMap.get(oldLVG);
 // Has the code already mapped this local variable to a
 // local in the new method?
 if (localVarMap.get(oldLVG) == null) {
 // Determine whether the local variable needs to be
 BranchInstruction bc      = (BranchInstruction)c;
 BranchInstruction bi      = (BranchInstruction)i;
 InstructionHandle itarget = bi.getTarget(); // old target
 // New target must be in targetMap
-InstructionHandle newTarget =
+InstructionHandle newTarget = targetMap.get(itarget);
-(InstructionHandle)targetMap.get(itarget);
 bc.setTarget(newTarget);
 // Handle LOOKUPSWITCH or TABLESWITCH which may have many
 // target instructions
 InstructionHandle[] itargets = ((Select)bi).getTargets();
 InstructionHandle[] ctargets = ((Select)bc).getTargets();
 // Update all targets
 for (int j=0; j < itargets.length; j++) {
-ctargets[j] =
+ctargets[j] = targetMap.get(itargets[j]);
-(InstructionHandle)targetMap.get(itargets[j]);
 }
 }
 }  else if (i instanceof LocalVariableInstruction
 || i instanceof RET) {
 // For any instruction that touches a local variable,
 int oldLocalVarIndex = lvi.getIndex();
 LocalVariableGen oldLVG =
 getLocalVariableRegistry()
 .lookupRegisteredLocalVariable(oldLocalVarIndex,
 ih.getPosition());
-LocalVariableGen newLVG =
+LocalVariableGen newLVG = localVarMap.get(oldLVG);
-(LocalVariableGen)localVarMap.get(oldLVG);
 int newLocalVarIndex;
 if (newLVG == null) {
 // Create new variable based on old variable - use same
 // name and type, but we will let the variable be active
 for (int idx = 0; idx < targeters.length; idx++) {
 InstructionTargeter targeter = targeters[idx];
 if (targeter instanceof LocalVariableGen
 && ((LocalVariableGen)targeter).getEnd()==ih) {
-Object newLVG = localVarMap.get(targeter);
+LocalVariableGen newLVG = localVarMap.get(targeter);
 if (newLVG != null) {
-outlinedMethodGen.removeLocalVariable(
+outlinedMethodGen.removeLocalVariable(newLVG);
-(LocalVariableGen)newLVG);
 }
 }
 }
 }
 }
 // POP the reference to the CopyLocals object from the stack
 oldMethCopyOutIL.append(InstructionConst.POP);
-// Now that the generation of the outlined code is complete, update
+for (Map.Entry<LocalVariableGen, InstructionHandle> lvgRangeStartPair :
-// the old local variables with new start and end ranges, as required.
+revisedLocalVarStart.entrySet()) {
-Iterator revisedLocalVarStartPairIter = revisedLocalVarStart.entrySet()
+LocalVariableGen lvg = lvgRangeStartPair.getKey();
-.iterator();
+InstructionHandle startInst = lvgRangeStartPair.getValue();
-while (revisedLocalVarStartPairIter.hasNext()) {
-Map.Entry lvgRangeStartPair =
-(Map.Entry)revisedLocalVarStartPairIter.next();
-LocalVariableGen lvg = (LocalVariableGen)lvgRangeStartPair.getKey();
-InstructionHandle startInst =
-(InstructionHandle)lvgRangeStartPair.getValue();
 lvg.setStart(startInst);
+}
-}
+for (Map.Entry<LocalVariableGen, InstructionHandle> lvgRangeEndPair :
-Iterator revisedLocalVarEndPairIter = revisedLocalVarEnd.entrySet()
+revisedLocalVarEnd.entrySet()) {
-.iterator();
+LocalVariableGen lvg = lvgRangeEndPair.getKey();
-while (revisedLocalVarEndPairIter.hasNext()) {
+InstructionHandle endInst = lvgRangeEndPair.getValue();
-Map.Entry lvgRangeEndPair =
-(Map.Entry)revisedLocalVarEndPairIter.next();
-LocalVariableGen lvg = (LocalVariableGen)lvgRangeEndPair.getKey();
-InstructionHandle endInst =
-(InstructionHandle)lvgRangeEndPair.getValue();
 lvg.setEnd(endInst);
 }
 xsltc.dumpClass(copyAreaCG.getJavaClass());

changeset 47359	e1a6c0168741
parent 47216	71c04702a3d5
child 47712	bde0215f1f70