rev 52889 : 8214023: Update Graal

   1 /*
   2  * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 
  25 package jdk.tools.jaotc;
  26 
  27 import java.util.HashMap;
  28 import java.util.HashSet;
  29 import java.util.Set;
  30 
  31 import org.graalvm.compiler.hotspot.meta.HotSpotInvokeDynamicPlugin.DynamicTypeStore;
  32 
  33 import jdk.vm.ci.hotspot.HotSpotConstantPool;
  34 import jdk.vm.ci.hotspot.HotSpotConstantPoolObject;
  35 import jdk.vm.ci.hotspot.HotSpotObjectConstant;
  36 import jdk.vm.ci.hotspot.HotSpotResolvedJavaMethod;
  37 import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
  38 import jdk.vm.ci.meta.JavaConstant;
  39 
  40 final class AOTDynamicTypeStore implements DynamicTypeStore {
  41 
  42     public static class Location {
  43         private HotSpotResolvedObjectType holder;
  44         private int cpi;
  45 
  46         Location(HotSpotResolvedObjectType holder, int cpi) {
  47             this.holder = holder;
  48             this.cpi = cpi;
  49         }
  50 
  51         public HotSpotResolvedObjectType getHolder() {
  52             return holder;
  53         }
  54 
  55         public int getCpi() {
  56             return cpi;
  57         }
  58 
  59         @Override
  60         public String toString() {
  61             return getHolder().getName() + "@" + cpi;
  62         }
  63 
  64         @Override
  65         public int hashCode() {
  66             return holder.hashCode() + getClass().hashCode() + cpi;
  67         }
  68 
  69         @Override
  70         public boolean equals(Object o) {
  71             if (this == o) {
  72                 return true;
  73             }
  74             if (getClass() != o.getClass()) {
  75                 return false;
  76             }
  77             Location l = (Location) o;
  78             return cpi == l.cpi && holder.equals(l.holder);
  79         }
  80     }
  81 
  82     public static class AdapterLocation extends Location {
  83         private int methodId;
  84 
  85         AdapterLocation(HotSpotResolvedObjectType holder, int cpi, int methodId) {
  86             super(holder, cpi);
  87             this.methodId = methodId;
  88         }
  89 
  90         public int getMethodId() {
  91             return methodId;
  92         }
  93 
  94         @Override
  95         public String toString() {
  96             return "adapter:" + methodId + "@" + super.toString();
  97         }
  98     }
  99 
 100     public static class AppendixLocation extends Location {
 101         AppendixLocation(HotSpotResolvedObjectType holder, int cpi) {
 102             super(holder, cpi);
 103         }
 104 
 105         @Override
 106         public String toString() {
 107             return "appendix@" + super.toString();
 108         }
 109     }
 110 
 111     private HashMap<HotSpotResolvedObjectType, HashSet<Location>> typeMap = new HashMap<>();
 112     private HashMap<HotSpotResolvedObjectType, HashSet<HotSpotResolvedObjectType>> holderMap = new HashMap<>();
 113 
 114     public Set<HotSpotResolvedObjectType> getDynamicTypes() {
 115         synchronized (typeMap) {
 116             return typeMap.keySet();
 117         }
 118     }
 119 
 120     public Set<HotSpotResolvedObjectType> getDynamicHolders() {
 121         synchronized (holderMap) {
 122             return holderMap.keySet();
 123         }
 124     }
 125 
 126     @Override
 127     public void recordAdapter(int opcode, HotSpotResolvedObjectType holder, int index, HotSpotResolvedJavaMethod adapter) {
 128         int cpi = ((HotSpotConstantPool) holder.getConstantPool()).rawIndexToConstantPoolIndex(index, opcode);
 129         int methodId = adapter.methodIdnum();
 130         HotSpotResolvedObjectType adapterType = adapter.getDeclaringClass();
 131         recordDynamicTypeLocation(new AdapterLocation(holder, cpi, methodId), adapterType);
 132     }
 133 
 134     @Override
 135     public JavaConstant recordAppendix(int opcode, HotSpotResolvedObjectType holder, int index, JavaConstant appendix) {
 136         int cpi = ((HotSpotConstantPool) holder.getConstantPool()).rawIndexToConstantPoolIndex(index, opcode);
 137         HotSpotResolvedObjectType appendixType = ((HotSpotObjectConstant) appendix).getType();
 138         recordDynamicTypeLocation(new AppendixLocation(holder, cpi), appendixType);
 139         // Make the constant locatable
 140         return HotSpotConstantPoolObject.forObject(holder, cpi, appendix);
 141     }
 142 
 143     private static <T> void recordDynamicMapValue(HashMap<HotSpotResolvedObjectType, HashSet<T>> map, HotSpotResolvedObjectType type, T v) {
 144         synchronized (map) {
 145             HashSet<T> set = map.get(type);
 146             if (set == null) {
 147                 set = new HashSet<>();
 148                 map.put(type, set);
 149             }
 150             set.add(v);
 151         }
 152     }
 153 
 154     private void recordDynamicTypeLocation(Location l, HotSpotResolvedObjectType type) {
 155         recordDynamicMapValue(typeMap, type, l);
 156         HotSpotResolvedObjectType holder = l.getHolder();
 157         recordDynamicMapValue(holderMap, holder, type);
 158     }
 159 
 160     public Set<Location> getDynamicClassLocationsForType(HotSpotResolvedObjectType type) {
 161         synchronized (typeMap) {
 162             return typeMap.get(type);
 163         }
 164     }
 165 
 166     public Set<HotSpotResolvedObjectType> getDynamicTypesForHolder(HotSpotResolvedObjectType holder) {
 167         synchronized (holderMap) {
 168             return holderMap.get(holder);
 169         }
 170     }
 171 
 172 }
--- EOF ---