Formatting

Author: tkrodriguez

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/common/GraalOptions.java

@@ -193,6 +193,7 @@ public final class GraalOptions {
     // Register allocator debugging
     @Option(help = "Comma separated list of registers that register allocation is limited to.", type = OptionType.Debug)
     public static final OptionKey<String> RegisterPressure = new OptionKey<>(null);
+
     @Option(help = "Permit RegisterPressure setting to cause compilation to fail.", type = OptionType.Debug)
     public static final OptionKey<Boolean> BailoutOnRegisterPressureFailure = new OptionKey<>(false);
 

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/aarch64/shenandoah/AArch64HotSpotShenandoahBarrierSetLIRGenerator.java

@@ -117,17 +117,19 @@ public void emitCompareAndSwapOp(LIRGeneratorTool tool, boolean isLogic, Value a
 
     @Override
     public Value emitAtomicReadAndWrite(LIRGeneratorTool tool, LIRKind readKind, Value address, Value newValue, BarrierType barrierType) {
-        // We insert the necessary barriers in the node graph, at that level it
-        // is easier to handle compressed object references. No need to do anything
-        // special here.
+        /*
+         * We insert the necessary barriers in the node graph, at that level it is easier to handle
+         * compressed object references. No need to do anything special here.
+         */
         return tool.emitAtomicReadAndWrite(readKind, address, newValue, BarrierType.NONE);
     }
 
     @Override
     public Variable emitBarrieredLoad(LIRGeneratorTool tool, LIRKind kind, Value address, LIRFrameState state, MemoryOrderMode memoryOrder, BarrierType barrierType) {
-        // We insert the necessary barriers in the node graph, at that level it
-        // is easier to handle compressed object references. No need to do anything
-        // special here.
+        /*
+         * We insert the necessary barriers in the node graph, at that level it is easier to handle
+         * compressed object references. No need to do anything special here.
+         */
         return tool.getArithmetic().emitLoad(kind, address, state, memoryOrder, MemoryExtendKind.DEFAULT);
     }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/hotspot/amd64/shenandoah/AMD64HotSpotShenandoahBarrierSetLIRGenerator.java

@@ -42,9 +42,9 @@
 import jdk.graal.compiler.lir.gen.ShenandoahBarrierSetLIRGeneratorTool;
 import jdk.graal.compiler.nodes.gc.shenandoah.ShenandoahLoadRefBarrierNode;
 import jdk.vm.ci.amd64.AMD64Kind;
+import jdk.vm.ci.code.RegisterValue;
 import jdk.vm.ci.meta.AllocatableValue;
 import jdk.vm.ci.meta.PlatformKind;
-import jdk.vm.ci.code.RegisterValue;
 import jdk.vm.ci.meta.Value;
 
 public class AMD64HotSpotShenandoahBarrierSetLIRGenerator implements ShenandoahBarrierSetLIRGeneratorTool, AMD64ReadBarrierSetLIRGenerator {
@@ -117,17 +117,19 @@ public void emitCompareAndSwapOp(LIRGeneratorTool tool, boolean isLogic, LIRKind
 
     @Override
     public Value emitAtomicReadAndWrite(LIRGeneratorTool tool, LIRKind readKind, Value address, Value newValue, BarrierType barrierType) {
-        // We insert the necessary barriers in the node graph, at that level it
-        // is easier to handle compressed object references. No need to do anything
-        // special here.
+        /*
+         * We insert the necessary barriers in the node graph, at that level it is easier to handle
+         * compressed object references. No need to do anything special here.
+         */
         return tool.emitAtomicReadAndWrite(readKind, address, newValue, BarrierType.NONE);
     }
 
     @Override
     public Variable emitBarrieredLoad(LIRGeneratorTool tool, LIRKind kind, Value address, LIRFrameState state, MemoryOrderMode memoryOrder, BarrierType barrierType) {
-        // We insert the necessary barriers in the node graph, at that level it
-        // is easier to handle compressed object references. No need to do anything
-        // special here.
+        /*
+         * We insert the necessary barriers in the node graph, at that level it is easier to handle
+         * compressed object references. No need to do anything special here.
+         */
         return tool.getArithmetic().emitLoad(kind, address, state, memoryOrder, MemoryExtendKind.DEFAULT);
     }
 

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/gc/BarrierSet.java

@@ -91,8 +91,10 @@ default void verifyBarriers(StructuredGraph graph) {
     }
 
     default boolean shouldAddBarriersInStage(GraphState.StageFlag stage) {
-        // Most barrier sets should be added in mid-tier, some might also
-        // wish to add in low-tier (e.g. Shenandoah GC).
+        /*
+         * Most barrier sets should be added in mid-tier, some might also wish to add in low-tier
+         * (e.g. Shenandoah GC).
+         */
         return stage == GraphState.StageFlag.MID_TIER_BARRIER_ADDITION;
     }
 }

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/gc/G1BarrierSet.java

@@ -174,14 +174,18 @@ private void addWriteBarriers(FixedAccessNode node, ValueNode writtenValue, Valu
                     StructuredGraph graph = node.graph();
                     boolean init = node.getLocationIdentity().isInit();
                     if (!init && barrierType != BarrierType.AS_NO_KEEPALIVE_WRITE) {
-                        // The pre barrier does nothing if the value being read is null, so it can
-                        // be explicitly skipped when this is an initializing store.
-                        // No keep-alive means no need for the pre-barrier.
+                        /*
+                         * The pre barrier does nothing if the value being read is null, so it can
+                         * be explicitly skipped when this is an initializing store. No keep-alive
+                         * means no need for the pre-barrier.
+                         */
                         addG1PreWriteBarrier(node, node.getAddress(), expectedValue, doLoad, graph);
                     }
                     if (writeRequiresPostBarrier(node, writtenValue)) {
-                        // Use a precise barrier for everything that might be an array write. Being
-                        // too precise with the barriers does not cause any correctness issues.
+                        /*
+                         * Use a precise barrier for everything that might be an array write. Being
+                         * too precise with the barriers does not cause any correctness issues.
+                         */
                         ValueNode object = null;
                         if (barrierType == BarrierType.FIELD) {
                             object = node.getAddress().getBase();

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/nodes/gc/shenandoah/ShenandoahBarrierSet.java

@@ -224,9 +224,11 @@ private void addWriteBarriers(FixedAccessNode node, ValueNode writtenValue, Valu
                     StructuredGraph graph = node.graph();
                     boolean init = node.getLocationIdentity().isInit();
                     if (!init && barrierType != BarrierType.AS_NO_KEEPALIVE_WRITE && useSATBBarrier) {
-                        // The pre barrier does nothing if the value being read is null, so it can
-                        // be explicitly skipped when this is an initializing store.
-                        // No keep-alive means no need for the pre-barrier.
+                        /*
+                         * The pre barrier does nothing if the value being read is null, so it can
+                         * be explicitly skipped when this is an initializing store. No keep-alive
+                         * means no need for the pre-barrier.
+                         */
                         addShenandoahSATBBarrier(node, node.getAddress(), expectedValue, graph);
                     }
                     if (!init && useCardBarrier && !StampTool.isPointerAlwaysNull(writtenValue)) {