src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot.sparc/src/org/graalvm/compiler/hotspot/sparc/SPARCHotSpotBackend.java
changeset 58299 6df94ce3ab2f
parent 54084 84f10bbf993f
equal deleted inserted replaced
58298:0152ad7b38b8 58299:6df94ce3ab2f
     1 /*
     1 /*
     2  * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
     2  * Copyright (c) 2013, 2019, Oracle and/or its affiliates. All rights reserved.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     4  *
     4  *
     5  * This code is free software; you can redistribute it and/or modify it
     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
     6  * under the terms of the GNU General Public License version 2 only, as
     7  * published by the Free Software Foundation.
     7  * published by the Free Software Foundation.
    46 import java.util.ArrayList;
    46 import java.util.ArrayList;
    47 import java.util.HashSet;
    47 import java.util.HashSet;
    48 import java.util.Set;
    48 import java.util.Set;
    49 import java.util.concurrent.ConcurrentHashMap;
    49 import java.util.concurrent.ConcurrentHashMap;
    50 
    50 
    51 import jdk.internal.vm.compiler.collections.EconomicMap;
       
    52 import jdk.internal.vm.compiler.collections.EconomicSet;
    51 import jdk.internal.vm.compiler.collections.EconomicSet;
    53 import jdk.internal.vm.compiler.collections.Equivalence;
    52 import jdk.internal.vm.compiler.collections.Equivalence;
    54 import org.graalvm.compiler.asm.Assembler;
    53 import org.graalvm.compiler.asm.Assembler;
    55 import org.graalvm.compiler.asm.Label;
    54 import org.graalvm.compiler.asm.Label;
    56 import org.graalvm.compiler.asm.sparc.SPARCAddress;
    55 import org.graalvm.compiler.asm.sparc.SPARCAddress;
    58 import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler;
    57 import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler;
    59 import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler.ScratchRegister;
    58 import org.graalvm.compiler.asm.sparc.SPARCMacroAssembler.ScratchRegister;
    60 import org.graalvm.compiler.code.CompilationResult;
    59 import org.graalvm.compiler.code.CompilationResult;
    61 import org.graalvm.compiler.code.DataSection;
    60 import org.graalvm.compiler.code.DataSection;
    62 import org.graalvm.compiler.code.DataSection.Data;
    61 import org.graalvm.compiler.code.DataSection.Data;
    63 import org.graalvm.compiler.core.common.CompilationIdentifier;
       
    64 import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
    62 import org.graalvm.compiler.core.common.alloc.RegisterAllocationConfig;
    65 import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
    63 import org.graalvm.compiler.core.common.cfg.AbstractBlockBase;
    66 import org.graalvm.compiler.core.gen.LIRGenerationProvider;
    64 import org.graalvm.compiler.core.gen.LIRGenerationProvider;
    67 import org.graalvm.compiler.core.sparc.SPARCNodeMatchRules;
    65 import org.graalvm.compiler.core.sparc.SPARCNodeMatchRules;
    68 import org.graalvm.compiler.debug.CounterKey;
    66 import org.graalvm.compiler.debug.CounterKey;
    75 import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
    73 import org.graalvm.compiler.hotspot.meta.HotSpotForeignCallsProvider;
    76 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
    74 import org.graalvm.compiler.hotspot.meta.HotSpotProviders;
    77 import org.graalvm.compiler.hotspot.stubs.Stub;
    75 import org.graalvm.compiler.hotspot.stubs.Stub;
    78 import org.graalvm.compiler.lir.InstructionValueConsumer;
    76 import org.graalvm.compiler.lir.InstructionValueConsumer;
    79 import org.graalvm.compiler.lir.LIR;
    77 import org.graalvm.compiler.lir.LIR;
    80 import org.graalvm.compiler.lir.LIRFrameState;
       
    81 import org.graalvm.compiler.lir.LIRInstruction;
    78 import org.graalvm.compiler.lir.LIRInstruction;
    82 import org.graalvm.compiler.lir.StandardOp.SaveRegistersOp;
       
    83 import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
    79 import org.graalvm.compiler.lir.asm.CompilationResultBuilder;
    84 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
    80 import org.graalvm.compiler.lir.asm.CompilationResultBuilderFactory;
    85 import org.graalvm.compiler.lir.asm.DataBuilder;
    81 import org.graalvm.compiler.lir.asm.DataBuilder;
    86 import org.graalvm.compiler.lir.asm.FrameContext;
    82 import org.graalvm.compiler.lir.asm.FrameContext;
    87 import org.graalvm.compiler.lir.framemap.FrameMap;
    83 import org.graalvm.compiler.lir.framemap.FrameMap;
   133             CounterKey m = counters.computeIfAbsent(name, (n) -> DebugContext.counter(n));
   129             CounterKey m = counters.computeIfAbsent(name, (n) -> DebugContext.counter(n));
   134             m.add(debug, count);
   130             m.add(debug, count);
   135         }
   131         }
   136     }
   132     }
   137 
   133 
   138     private FrameMapBuilder newFrameMapBuilder(RegisterConfig registerConfig) {
   134     @Override
       
   135     protected FrameMapBuilder newFrameMapBuilder(RegisterConfig registerConfig) {
   139         RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
   136         RegisterConfig registerConfigNonNull = registerConfig == null ? getCodeCache().getRegisterConfig() : registerConfig;
   140         FrameMap frameMap = new SPARCFrameMap(getCodeCache(), registerConfigNonNull, this);
   137         FrameMap frameMap = new SPARCFrameMap(getCodeCache(), registerConfigNonNull, this);
   141         return new SPARCFrameMapBuilder(frameMap, getCodeCache(), registerConfigNonNull);
   138         return new SPARCFrameMapBuilder(frameMap, getCodeCache(), registerConfigNonNull);
   142     }
   139     }
   143 
   140 
   144     @Override
   141     @Override
   145     public LIRGeneratorTool newLIRGenerator(LIRGenerationResult lirGenRes) {
   142     public LIRGeneratorTool newLIRGenerator(LIRGenerationResult lirGenRes) {
   146         return new SPARCHotSpotLIRGenerator(getProviders(), getRuntime().getVMConfig(), lirGenRes);
   143         return new SPARCHotSpotLIRGenerator(getProviders(), getRuntime().getVMConfig(), lirGenRes);
   147     }
       
   148 
       
   149     @Override
       
   150     public LIRGenerationResult newLIRGenerationResult(CompilationIdentifier compilationId, LIR lir, RegisterConfig registerConfig, StructuredGraph graph, Object stub) {
       
   151         return new HotSpotLIRGenerationResult(compilationId, lir, newFrameMapBuilder(registerConfig), makeCallingConvention(graph, (Stub) stub), stub,
       
   152                         config.requiresReservedStackCheck(graph.getMethods()));
       
   153     }
   144     }
   154 
   145 
   155     @Override
   146     @Override
   156     public NodeLIRBuilderTool newNodeLIRBuilder(StructuredGraph graph, LIRGeneratorTool lirGen) {
   147     public NodeLIRBuilderTool newNodeLIRBuilder(StructuredGraph graph, LIRGeneratorTool lirGen) {
   157         return new SPARCHotSpotNodeLIRBuilder(graph, lirGen, new SPARCNodeMatchRules(lirGen));
   148         return new SPARCHotSpotNodeLIRBuilder(graph, lirGen, new SPARCNodeMatchRules(lirGen));
   244         if (deoptimizationRescueSlot != null && stub == null) {
   235         if (deoptimizationRescueSlot != null && stub == null) {
   245             crb.compilationResult.setCustomStackAreaOffset(deoptimizationRescueSlot);
   236             crb.compilationResult.setCustomStackAreaOffset(deoptimizationRescueSlot);
   246         }
   237         }
   247 
   238 
   248         if (stub != null) {
   239         if (stub != null) {
   249             // Even on sparc we need to save floating point registers
   240             updateStub(stub, gen, frameMap);
   250             EconomicSet<Register> destroyedCallerRegisters = gatherDestroyedCallerRegisters(lir);
       
   251             EconomicMap<LIRFrameState, SaveRegistersOp> calleeSaveInfo = gen.getCalleeSaveInfo();
       
   252             updateStub(stub, destroyedCallerRegisters, calleeSaveInfo, frameMap);
       
   253         }
   241         }
   254         assert registerSizePredictionValidator(crb, debug);
   242         assert registerSizePredictionValidator(crb, debug);
   255         return crb;
   243         return crb;
   256     }
   244     }
   257 
   245