1 /*
   2  * Copyright (c) 2015, 2016, 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 package jdk.vm.ci.hotspot.aarch64;
  24 
  25 import static jdk.vm.ci.aarch64.AArch64.lr;
  26 import static jdk.vm.ci.aarch64.AArch64.r0;
  27 import static jdk.vm.ci.aarch64.AArch64.r1;
  28 import static jdk.vm.ci.aarch64.AArch64.r2;
  29 import static jdk.vm.ci.aarch64.AArch64.r3;
  30 import static jdk.vm.ci.aarch64.AArch64.r4;
  31 import static jdk.vm.ci.aarch64.AArch64.r5;
  32 import static jdk.vm.ci.aarch64.AArch64.r6;
  33 import static jdk.vm.ci.aarch64.AArch64.r7;
  34 import static jdk.vm.ci.aarch64.AArch64.rscratch1;
  35 import static jdk.vm.ci.aarch64.AArch64.rscratch2;
  36 import static jdk.vm.ci.aarch64.AArch64.r12;
  37 import static jdk.vm.ci.aarch64.AArch64.r27;
  38 import static jdk.vm.ci.aarch64.AArch64.r28;
  39 import static jdk.vm.ci.aarch64.AArch64.r29;
  40 import static jdk.vm.ci.aarch64.AArch64.r31;
  41 import static jdk.vm.ci.aarch64.AArch64.sp;
  42 import static jdk.vm.ci.aarch64.AArch64.v0;
  43 import static jdk.vm.ci.aarch64.AArch64.v1;
  44 import static jdk.vm.ci.aarch64.AArch64.v2;
  45 import static jdk.vm.ci.aarch64.AArch64.v3;
  46 import static jdk.vm.ci.aarch64.AArch64.v4;
  47 import static jdk.vm.ci.aarch64.AArch64.v5;
  48 import static jdk.vm.ci.aarch64.AArch64.v6;
  49 import static jdk.vm.ci.aarch64.AArch64.v7;
  50 import static jdk.vm.ci.aarch64.AArch64.zr;
  51 
  52 import java.util.ArrayList;
  53 import java.util.HashSet;
  54 import java.util.List;
  55 import java.util.Set;
  56 
  57 import jdk.vm.ci.aarch64.AArch64;
  58 import jdk.vm.ci.code.Architecture;
  59 import jdk.vm.ci.code.CallingConvention;
  60 import jdk.vm.ci.code.CallingConvention.Type;
  61 import jdk.vm.ci.code.Register;
  62 import jdk.vm.ci.code.RegisterArray;
  63 import jdk.vm.ci.code.RegisterAttributes;
  64 import jdk.vm.ci.code.RegisterConfig;
  65 import jdk.vm.ci.code.StackSlot;
  66 import jdk.vm.ci.code.TargetDescription;
  67 import jdk.vm.ci.code.ValueKindFactory;
  68 import jdk.vm.ci.common.JVMCIError;
  69 import jdk.vm.ci.hotspot.HotSpotCallingConventionType;
  70 import jdk.vm.ci.meta.AllocatableValue;
  71 import jdk.vm.ci.meta.JavaKind;
  72 import jdk.vm.ci.meta.JavaType;
  73 import jdk.vm.ci.meta.PlatformKind;
  74 import jdk.vm.ci.meta.Value;
  75 import jdk.vm.ci.meta.ValueKind;
  76 
  77 public class AArch64HotSpotRegisterConfig implements RegisterConfig {
  78 
  79     private final TargetDescription target;
  80 
  81     private final RegisterArray allocatable;
  82 
  83     /**
  84      * The caller saved registers always include all parameter registers.
  85      */
  86     private final RegisterArray callerSaved;
  87 
  88     private final boolean allAllocatableAreCallerSaved;
  89 
  90     private final RegisterAttributes[] attributesMap;
  91 
  92     @Override
  93     public RegisterArray getAllocatableRegisters() {
  94         return allocatable;
  95     }
  96 
  97     @Override
  98     public RegisterArray filterAllocatableRegisters(PlatformKind kind, RegisterArray registers) {
  99         ArrayList<Register> list = new ArrayList<>();
 100         for (Register reg : registers) {
 101             if (target.arch.canStoreValue(reg.getRegisterCategory(), kind)) {
 102                 list.add(reg);
 103             }
 104         }
 105 
 106         return new RegisterArray(list);
 107     }
 108 
 109     @Override
 110     public RegisterAttributes[] getAttributesMap() {
 111         return attributesMap.clone();
 112     }
 113 
 114     private final RegisterArray javaGeneralParameterRegisters = new RegisterArray(r1, r2, r3, r4, r5, r6, r7, r0);
 115     private final RegisterArray nativeGeneralParameterRegisters = new RegisterArray(r0, r1, r2, r3, r4, r5, r6, r7);
 116     private final RegisterArray simdParameterRegisters = new RegisterArray(v0, v1, v2, v3, v4, v5, v6, v7);
 117 
 118     public static final Register inlineCacheRegister = rscratch2;
 119 
 120     /**
 121      * Vtable stubs expect the metaspace Method in r12.
 122      */
 123     public static final Register metaspaceMethodRegister = r12;
 124 
 125     public static final Register heapBaseRegister = r27;
 126     public static final Register threadRegister = r28;
 127     public static final Register fp = r29;
 128 
 129     private static final RegisterArray reservedRegisters
 130         = new RegisterArray(rscratch1, rscratch2, threadRegister, fp, lr, r31, zr, sp);
 131 
 132     private static RegisterArray initAllocatable(Architecture arch, boolean reserveForHeapBase) {
 133         RegisterArray allRegisters = arch.getAvailableValueRegisters();
 134         Register[] registers = new Register[allRegisters.size() - reservedRegisters.size() - (reserveForHeapBase ? 1 : 0)];
 135         List<Register> reservedRegistersList = reservedRegisters.asList();
 136 
 137         int idx = 0;
 138         for (Register reg : allRegisters) {
 139             if (reservedRegistersList.contains(reg)) {
 140                 // skip reserved registers
 141                 continue;
 142             }
 143             assert !(reg.equals(threadRegister) || reg.equals(fp) || reg.equals(lr) || reg.equals(r31) || reg.equals(zr) || reg.equals(sp));
 144             if (reserveForHeapBase && reg.equals(heapBaseRegister)) {
 145                 // skip heap base register
 146                 continue;
 147             }
 148 
 149             registers[idx++] = reg;
 150         }
 151 
 152         assert idx == registers.length;
 153         return new RegisterArray(registers);
 154     }
 155 
 156     public AArch64HotSpotRegisterConfig(TargetDescription target, boolean useCompressedOops) {
 157         this(target, initAllocatable(target.arch, useCompressedOops));
 158         assert callerSaved.size() >= allocatable.size();
 159     }
 160 
 161     public AArch64HotSpotRegisterConfig(TargetDescription target, RegisterArray allocatable) {
 162         this.target = target;
 163 
 164         this.allocatable = allocatable;
 165         Set<Register> callerSaveSet = new HashSet<>();
 166         allocatable.addTo(callerSaveSet);
 167         simdParameterRegisters.addTo(callerSaveSet);
 168         javaGeneralParameterRegisters.addTo(callerSaveSet);
 169         nativeGeneralParameterRegisters.addTo(callerSaveSet);
 170         callerSaved = new RegisterArray(callerSaveSet);
 171 
 172         allAllocatableAreCallerSaved = true;
 173         attributesMap = RegisterAttributes.createMap(this, AArch64.allRegisters);
 174     }
 175 
 176     @Override
 177     public RegisterArray getCallerSaveRegisters() {
 178         return callerSaved;
 179     }
 180 
 181     public RegisterArray getCalleeSaveRegisters() {
 182         return null;
 183     }
 184 
 185     @Override
 186     public boolean areAllAllocatableRegistersCallerSaved() {
 187         return allAllocatableAreCallerSaved;
 188     }
 189 
 190     @Override
 191     public CallingConvention getCallingConvention(Type type, JavaType returnType, JavaType[] parameterTypes, ValueKindFactory<?> valueKindFactory) {
 192         HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
 193         if (type == HotSpotCallingConventionType.NativeCall) {
 194             return callingConvention(nativeGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
 195         }
 196         // On x64, parameter locations are the same whether viewed
 197         // from the caller or callee perspective
 198         return callingConvention(javaGeneralParameterRegisters, returnType, parameterTypes, hotspotType, valueKindFactory);
 199     }
 200 
 201     @Override
 202     public RegisterArray getCallingConventionRegisters(Type type, JavaKind kind) {
 203         HotSpotCallingConventionType hotspotType = (HotSpotCallingConventionType) type;
 204         switch (kind) {
 205             case Boolean:
 206             case Byte:
 207             case Short:
 208             case Char:
 209             case Int:
 210             case Long:
 211             case Object:
 212                 return hotspotType == HotSpotCallingConventionType.NativeCall ? nativeGeneralParameterRegisters : javaGeneralParameterRegisters;
 213             case Float:
 214             case Double:
 215                 return simdParameterRegisters;
 216             default:
 217                 throw JVMCIError.shouldNotReachHere();
 218         }
 219     }
 220 
 221     private CallingConvention callingConvention(RegisterArray generalParameterRegisters, JavaType returnType, JavaType[] parameterTypes, HotSpotCallingConventionType type,
 222                     ValueKindFactory<?> valueKindFactory) {
 223         AllocatableValue[] locations = new AllocatableValue[parameterTypes.length];
 224 
 225         int currentGeneral = 0;
 226         int currentSIMD = 0;
 227         int currentStackOffset = 0;
 228 
 229         for (int i = 0; i < parameterTypes.length; i++) {
 230             final JavaKind kind = parameterTypes[i].getJavaKind().getStackKind();
 231 
 232             switch (kind) {
 233                 case Byte:
 234                 case Boolean:
 235                 case Short:
 236                 case Char:
 237                 case Int:
 238                 case Long:
 239                 case Object:
 240                     if (currentGeneral < generalParameterRegisters.size()) {
 241                         Register register = generalParameterRegisters.get(currentGeneral++);
 242                         locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
 243                     }
 244                     break;
 245                 case Float:
 246                 case Double:
 247                     if (currentSIMD < simdParameterRegisters.size()) {
 248                         Register register = simdParameterRegisters.get(currentSIMD++);
 249                         locations[i] = register.asValue(valueKindFactory.getValueKind(kind));
 250                     }
 251                     break;
 252                 default:
 253                     throw JVMCIError.shouldNotReachHere();
 254             }
 255 
 256             if (locations[i] == null) {
 257                 ValueKind<?> valueKind = valueKindFactory.getValueKind(kind);
 258                 locations[i] = StackSlot.get(valueKind, currentStackOffset, !type.out);
 259                 currentStackOffset += Math.max(valueKind.getPlatformKind().getSizeInBytes(), target.wordSize);
 260             }
 261         }
 262 
 263         JavaKind returnKind = returnType == null ? JavaKind.Void : returnType.getJavaKind();
 264         AllocatableValue returnLocation = returnKind == JavaKind.Void ? Value.ILLEGAL : getReturnRegister(returnKind).asValue(valueKindFactory.getValueKind(returnKind.getStackKind()));
 265         return new CallingConvention(currentStackOffset, returnLocation, locations);
 266     }
 267 
 268     @Override
 269     public Register getReturnRegister(JavaKind kind) {
 270         switch (kind) {
 271             case Boolean:
 272             case Byte:
 273             case Char:
 274             case Short:
 275             case Int:
 276             case Long:
 277             case Object:
 278                 return r0;
 279             case Float:
 280             case Double:
 281                 return v0;
 282             case Void:
 283             case Illegal:
 284                 return null;
 285             default:
 286                 throw new UnsupportedOperationException("no return register for type " + kind);
 287         }
 288     }
 289 
 290     @Override
 291     public Register getFrameRegister() {
 292         return sp;
 293     }
 294 
 295     @Override
 296     public String toString() {
 297         return String.format("Allocatable: " + getAllocatableRegisters() + "%n" + "CallerSave:  " + getCallerSaveRegisters() + "%n");
 298     }
 299 }