Mercurial > jdk8-mips64-public > hotspot / changeset

     1.1 --- a/make/bsd/makefiles/minimal1.make	Fri Jan 18 05:33:32 2013 -0800
     1.2 +++ b/make/bsd/makefiles/minimal1.make	Wed Jan 23 13:02:39 2013 -0500
     1.3 @@ -30,7 +30,7 @@
     1.4  INCLUDE_JNI_CHECK ?= false
     1.5  INCLUDE_SERVICES ?= false
     1.6  INCLUDE_MANAGEMENT ?= false
     1.7 -INCLUDE_ALTERNATE_GCS ?= false
     1.8 +INCLUDE_ALL_GCS ?= false
     1.9  INCLUDE_NMT ?= false
    1.10  INCLUDE_CDS ?= false
    1.11  

     2.1 --- a/make/excludeSrc.make	Fri Jan 18 05:33:32 2013 -0800
     2.2 +++ b/make/excludeSrc.make	Wed Jan 23 13:02:39 2013 -0500
     2.3 @@ -72,12 +72,10 @@
     2.4        Src_Files_EXCLUDE += metaspaceShared.cpp
     2.5  endif
     2.6  
     2.7 -ifeq ($(INCLUDE_ALTERNATE_GCS), false)
     2.8 -      CXXFLAGS += -DINCLUDE_ALTERNATE_GCS=0
     2.9 -      CFLAGS += -DINCLUDE_ALTERNATE_GCS=0
    2.10 +ifeq ($(INCLUDE_ALL_GCS), false)
    2.11 +      CXXFLAGS += -DINCLUDE_ALL_GCS=0
    2.12 +      CFLAGS += -DINCLUDE_ALL_GCS=0
    2.13  
    2.14 -      CXXFLAGS += -DSERIALGC
    2.15 -      CFLAGS += -DSERIALGC
    2.16        Src_Files_EXCLUDE += \
    2.17  	cmsAdaptiveSizePolicy.cpp cmsCollectorPolicy.cpp \
    2.18  	cmsGCAdaptivePolicyCounters.cpp cmsLockVerifier.cpp cmsPermGen.cpp compactibleFreeListSpace.cpp \

     3.1 --- a/make/linux/makefiles/minimal1.make	Fri Jan 18 05:33:32 2013 -0800
     3.2 +++ b/make/linux/makefiles/minimal1.make	Wed Jan 23 13:02:39 2013 -0500
     3.3 @@ -30,7 +30,7 @@
     3.4  INCLUDE_JNI_CHECK ?= false
     3.5  INCLUDE_SERVICES ?= false
     3.6  INCLUDE_MANAGEMENT ?= false
     3.7 -INCLUDE_ALTERNATE_GCS ?= false
     3.8 +INCLUDE_ALL_GCS ?= false
     3.9  INCLUDE_NMT ?= false
    3.10  INCLUDE_CDS ?= false
    3.11  

     4.1 --- a/src/cpu/sparc/vm/c1_CodeStubs_sparc.cpp	Fri Jan 18 05:33:32 2013 -0800
     4.2 +++ b/src/cpu/sparc/vm/c1_CodeStubs_sparc.cpp	Wed Jan 23 13:02:39 2013 -0500
     4.3 @@ -30,10 +30,11 @@
     4.4  #include "c1/c1_Runtime1.hpp"
     4.5  #include "nativeInst_sparc.hpp"
     4.6  #include "runtime/sharedRuntime.hpp"
     4.7 +#include "utilities/macros.hpp"
     4.8  #include "vmreg_sparc.inline.hpp"
     4.9 -#ifndef SERIALGC
    4.10 +#if INCLUDE_ALL_GCS
    4.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
    4.12 -#endif
    4.13 +#endif // INCLUDE_ALL_GCS
    4.14  
    4.15  #define __ ce->masm()->
    4.16  
    4.17 @@ -420,7 +421,7 @@
    4.18  
    4.19  
    4.20  ///////////////////////////////////////////////////////////////////////////////////
    4.21 -#ifndef SERIALGC
    4.22 +#if INCLUDE_ALL_GCS
    4.23  
    4.24  void G1PreBarrierStub::emit_code(LIR_Assembler* ce) {
    4.25    // At this point we know that marking is in progress.
    4.26 @@ -483,7 +484,7 @@
    4.27    __ delayed()->nop();
    4.28  }
    4.29  
    4.30 -#endif // SERIALGC
    4.31 +#endif // INCLUDE_ALL_GCS
    4.32  ///////////////////////////////////////////////////////////////////////////////////
    4.33  
    4.34  #undef __

     5.1 --- a/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp	Fri Jan 18 05:33:32 2013 -0800
     5.2 +++ b/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp	Wed Jan 23 13:02:39 2013 -0500
     5.3 @@ -35,6 +35,7 @@
     5.4  #include "runtime/sharedRuntime.hpp"
     5.5  #include "runtime/signature.hpp"
     5.6  #include "runtime/vframeArray.hpp"
     5.7 +#include "utilities/macros.hpp"
     5.8  #include "vmreg_sparc.inline.hpp"
     5.9  
    5.10  // Implementation of StubAssembler
    5.11 @@ -822,7 +823,7 @@
    5.12        }
    5.13        break;
    5.14  
    5.15 -#ifndef SERIALGC
    5.16 +#if INCLUDE_ALL_GCS
    5.17      case g1_pre_barrier_slow_id:
    5.18        { // G4: previous value of memory
    5.19          BarrierSet* bs = Universe::heap()->barrier_set();
    5.20 @@ -984,7 +985,7 @@
    5.21          __ delayed()->restore();
    5.22        }
    5.23        break;
    5.24 -#endif // !SERIALGC
    5.25 +#endif // INCLUDE_ALL_GCS
    5.26  
    5.27      default:
    5.28        { __ set_info("unimplemented entry", dont_gc_arguments);

     6.1 --- a/src/cpu/sparc/vm/cppInterpreter_sparc.cpp	Fri Jan 18 05:33:32 2013 -0800
     6.2 +++ b/src/cpu/sparc/vm/cppInterpreter_sparc.cpp	Wed Jan 23 13:02:39 2013 -0500
     6.3 @@ -45,6 +45,7 @@
     6.4  #include "runtime/timer.hpp"
     6.5  #include "runtime/vframeArray.hpp"
     6.6  #include "utilities/debug.hpp"
     6.7 +#include "utilities/macros.hpp"
     6.8  #ifdef SHARK
     6.9  #include "shark/shark_globals.hpp"
    6.10  #endif
    6.11 @@ -551,7 +552,7 @@
    6.12  }
    6.13  
    6.14  address InterpreterGenerator::generate_Reference_get_entry(void) {
    6.15 -#ifndef SERIALGC
    6.16 +#if INCLUDE_ALL_GCS
    6.17    if (UseG1GC) {
    6.18      // We need to generate have a routine that generates code to:
    6.19      //   * load the value in the referent field
    6.20 @@ -563,7 +564,7 @@
    6.21      // field as live.
    6.22      Unimplemented();
    6.23    }
    6.24 -#endif // SERIALGC
    6.25 +#endif // INCLUDE_ALL_GCS
    6.26  
    6.27    // If G1 is not enabled then attempt to go through the accessor entry point
    6.28    // Reference.get is an accessor

     7.1 --- a/src/cpu/sparc/vm/macroAssembler_sparc.cpp	Fri Jan 18 05:33:32 2013 -0800
     7.2 +++ b/src/cpu/sparc/vm/macroAssembler_sparc.cpp	Wed Jan 23 13:02:39 2013 -0500
     7.3 @@ -36,11 +36,12 @@
     7.4  #include "runtime/os.hpp"
     7.5  #include "runtime/sharedRuntime.hpp"
     7.6  #include "runtime/stubRoutines.hpp"
     7.7 -#ifndef SERIALGC
     7.8 +#include "utilities/macros.hpp"
     7.9 +#if INCLUDE_ALL_GCS
    7.10  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
    7.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
    7.12  #include "gc_implementation/g1/heapRegion.hpp"
    7.13 -#endif
    7.14 +#endif // INCLUDE_ALL_GCS
    7.15  
    7.16  #ifdef PRODUCT
    7.17  #define BLOCK_COMMENT(str) /* nothing */
    7.18 @@ -3867,7 +3868,7 @@
    7.19  }
    7.20  
    7.21  ///////////////////////////////////////////////////////////////////////////////////
    7.22 -#ifndef SERIALGC
    7.23 +#if INCLUDE_ALL_GCS
    7.24  
    7.25  static address satb_log_enqueue_with_frame = NULL;
    7.26  static u_char* satb_log_enqueue_with_frame_end = NULL;
    7.27 @@ -4231,7 +4232,7 @@
    7.28    bind(filtered);
    7.29  }
    7.30  
    7.31 -#endif  // SERIALGC
    7.32 +#endif // INCLUDE_ALL_GCS
    7.33  ///////////////////////////////////////////////////////////////////////////////////
    7.34  
    7.35  void MacroAssembler::card_write_barrier_post(Register store_addr, Register new_val, Register tmp) {

     8.1 --- a/src/cpu/sparc/vm/macroAssembler_sparc.hpp	Fri Jan 18 05:33:32 2013 -0800
     8.2 +++ b/src/cpu/sparc/vm/macroAssembler_sparc.hpp	Wed Jan 23 13:02:39 2013 -0500
     8.3 @@ -26,6 +26,7 @@
     8.4  #define CPU_SPARC_VM_MACROASSEMBLER_SPARC_HPP
     8.5  
     8.6  #include "asm/assembler.hpp"
     8.7 +#include "utilities/macros.hpp"
     8.8  
     8.9  // <sys/trap.h> promises that the system will not use traps 16-31
    8.10  #define ST_RESERVED_FOR_USER_0 0x10
    8.11 @@ -1181,13 +1182,13 @@
    8.12  
    8.13    void card_write_barrier_post(Register store_addr, Register new_val, Register tmp);
    8.14  
    8.15 -#ifndef SERIALGC
    8.16 +#if INCLUDE_ALL_GCS
    8.17    // General G1 pre-barrier generator.
    8.18    void g1_write_barrier_pre(Register obj, Register index, int offset, Register pre_val, Register tmp, bool preserve_o_regs);
    8.19  
    8.20    // General G1 post-barrier generator
    8.21    void g1_write_barrier_post(Register store_addr, Register new_val, Register tmp);
    8.22 -#endif // SERIALGC
    8.23 +#endif // INCLUDE_ALL_GCS
    8.24  
    8.25    // pushes double TOS element of FPU stack on CPU stack; pops from FPU stack
    8.26    void push_fTOS();

     9.1 --- a/src/cpu/sparc/vm/templateInterpreter_sparc.cpp	Fri Jan 18 05:33:32 2013 -0800
     9.2 +++ b/src/cpu/sparc/vm/templateInterpreter_sparc.cpp	Wed Jan 23 13:02:39 2013 -0500
     9.3 @@ -44,6 +44,7 @@
     9.4  #include "runtime/timer.hpp"
     9.5  #include "runtime/vframeArray.hpp"
     9.6  #include "utilities/debug.hpp"
     9.7 +#include "utilities/macros.hpp"
     9.8  
     9.9  #ifndef CC_INTERP
    9.10  #ifndef FAST_DISPATCH
    9.11 @@ -734,7 +735,7 @@
    9.12  
    9.13  // Method entry for java.lang.ref.Reference.get.
    9.14  address InterpreterGenerator::generate_Reference_get_entry(void) {
    9.15 -#ifndef SERIALGC
    9.16 +#if INCLUDE_ALL_GCS
    9.17    // Code: _aload_0, _getfield, _areturn
    9.18    // parameter size = 1
    9.19    //
    9.20 @@ -805,7 +806,7 @@
    9.21      (void) generate_normal_entry(false);
    9.22      return entry;
    9.23    }
    9.24 -#endif // SERIALGC
    9.25 +#endif // INCLUDE_ALL_GCS
    9.26  
    9.27    // If G1 is not enabled then attempt to go through the accessor entry point
    9.28    // Reference.get is an accessor

    10.1 --- a/src/cpu/sparc/vm/templateTable_sparc.cpp	Fri Jan 18 05:33:32 2013 -0800
    10.2 +++ b/src/cpu/sparc/vm/templateTable_sparc.cpp	Wed Jan 23 13:02:39 2013 -0500
    10.3 @@ -34,6 +34,7 @@
    10.4  #include "runtime/sharedRuntime.hpp"
    10.5  #include "runtime/stubRoutines.hpp"
    10.6  #include "runtime/synchronizer.hpp"
    10.7 +#include "utilities/macros.hpp"
    10.8  
    10.9  #ifndef CC_INTERP
   10.10  #define __ _masm->
   10.11 @@ -53,7 +54,7 @@
   10.12    assert(tmp != val && tmp != base && tmp != index, "register collision");
   10.13    assert(index == noreg || offset == 0, "only one offset");
   10.14    switch (barrier) {
   10.15 -#ifndef SERIALGC
   10.16 +#if INCLUDE_ALL_GCS
   10.17      case BarrierSet::G1SATBCT:
   10.18      case BarrierSet::G1SATBCTLogging:
   10.19        {
   10.20 @@ -82,7 +83,7 @@
   10.21          }
   10.22        }
   10.23        break;
   10.24 -#endif // SERIALGC
   10.25 +#endif // INCLUDE_ALL_GCS
   10.26      case BarrierSet::CardTableModRef:
   10.27      case BarrierSet::CardTableExtension:
   10.28        {

    11.1 --- a/src/cpu/x86/vm/assembler_x86.cpp	Fri Jan 18 05:33:32 2013 -0800
    11.2 +++ b/src/cpu/x86/vm/assembler_x86.cpp	Wed Jan 23 13:02:39 2013 -0500
    11.3 @@ -36,11 +36,12 @@
    11.4  #include "runtime/os.hpp"
    11.5  #include "runtime/sharedRuntime.hpp"
    11.6  #include "runtime/stubRoutines.hpp"
    11.7 -#ifndef SERIALGC
    11.8 +#include "utilities/macros.hpp"
    11.9 +#if INCLUDE_ALL_GCS
   11.10  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   11.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   11.12  #include "gc_implementation/g1/heapRegion.hpp"
   11.13 -#endif
   11.14 +#endif // INCLUDE_ALL_GCS
   11.15  
   11.16  #ifdef PRODUCT
   11.17  #define BLOCK_COMMENT(str) /* nothing */

    12.1 --- a/src/cpu/x86/vm/c1_CodeStubs_x86.cpp	Fri Jan 18 05:33:32 2013 -0800
    12.2 +++ b/src/cpu/x86/vm/c1_CodeStubs_x86.cpp	Wed Jan 23 13:02:39 2013 -0500
    12.3 @@ -30,10 +30,11 @@
    12.4  #include "c1/c1_Runtime1.hpp"
    12.5  #include "nativeInst_x86.hpp"
    12.6  #include "runtime/sharedRuntime.hpp"
    12.7 +#include "utilities/macros.hpp"
    12.8  #include "vmreg_x86.inline.hpp"
    12.9 -#ifndef SERIALGC
   12.10 +#if INCLUDE_ALL_GCS
   12.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   12.12 -#endif
   12.13 +#endif // INCLUDE_ALL_GCS
   12.14  
   12.15  
   12.16  #define __ ce->masm()->
   12.17 @@ -482,7 +483,7 @@
   12.18  }
   12.19  
   12.20  /////////////////////////////////////////////////////////////////////////////
   12.21 -#ifndef SERIALGC
   12.22 +#if INCLUDE_ALL_GCS
   12.23  
   12.24  void G1PreBarrierStub::emit_code(LIR_Assembler* ce) {
   12.25    // At this point we know that marking is in progress.
   12.26 @@ -528,7 +529,7 @@
   12.27    __ jmp(_continuation);
   12.28  }
   12.29  
   12.30 -#endif // SERIALGC
   12.31 +#endif // INCLUDE_ALL_GCS
   12.32  /////////////////////////////////////////////////////////////////////////////
   12.33  
   12.34  #undef __

    13.1 --- a/src/cpu/x86/vm/c1_Runtime1_x86.cpp	Fri Jan 18 05:33:32 2013 -0800
    13.2 +++ b/src/cpu/x86/vm/c1_Runtime1_x86.cpp	Wed Jan 23 13:02:39 2013 -0500
    13.3 @@ -36,6 +36,7 @@
    13.4  #include "runtime/sharedRuntime.hpp"
    13.5  #include "runtime/signature.hpp"
    13.6  #include "runtime/vframeArray.hpp"
    13.7 +#include "utilities/macros.hpp"
    13.8  #include "vmreg_x86.inline.hpp"
    13.9  
   13.10  
   13.11 @@ -1607,7 +1608,7 @@
   13.12        }
   13.13        break;
   13.14  
   13.15 -#ifndef SERIALGC
   13.16 +#if INCLUDE_ALL_GCS
   13.17      case g1_pre_barrier_slow_id:
   13.18        {
   13.19          StubFrame f(sasm, "g1_pre_barrier", dont_gc_arguments);
   13.20 @@ -1804,7 +1805,7 @@
   13.21  
   13.22        }
   13.23        break;
   13.24 -#endif // !SERIALGC
   13.25 +#endif // INCLUDE_ALL_GCS
   13.26  
   13.27      default:
   13.28        { StubFrame f(sasm, "unimplemented entry", dont_gc_arguments);

    14.1 --- a/src/cpu/x86/vm/cppInterpreter_x86.cpp	Fri Jan 18 05:33:32 2013 -0800
    14.2 +++ b/src/cpu/x86/vm/cppInterpreter_x86.cpp	Wed Jan 23 13:02:39 2013 -0500
    14.3 @@ -45,6 +45,7 @@
    14.4  #include "runtime/timer.hpp"
    14.5  #include "runtime/vframeArray.hpp"
    14.6  #include "utilities/debug.hpp"
    14.7 +#include "utilities/macros.hpp"
    14.8  #ifdef SHARK
    14.9  #include "shark/shark_globals.hpp"
   14.10  #endif
   14.11 @@ -938,7 +939,7 @@
   14.12  }
   14.13  
   14.14  address InterpreterGenerator::generate_Reference_get_entry(void) {
   14.15 -#ifndef SERIALGC
   14.16 +#if INCLUDE_ALL_GCS
   14.17    if (UseG1GC) {
   14.18      // We need to generate have a routine that generates code to:
   14.19      //   * load the value in the referent field
   14.20 @@ -950,7 +951,7 @@
   14.21      // field as live.
   14.22      Unimplemented();
   14.23    }
   14.24 -#endif // SERIALGC
   14.25 +#endif // INCLUDE_ALL_GCS
   14.26  
   14.27    // If G1 is not enabled then attempt to go through the accessor entry point
   14.28    // Reference.get is an accessor

    15.1 --- a/src/cpu/x86/vm/macroAssembler_x86.cpp	Fri Jan 18 05:33:32 2013 -0800
    15.2 +++ b/src/cpu/x86/vm/macroAssembler_x86.cpp	Wed Jan 23 13:02:39 2013 -0500
    15.3 @@ -37,11 +37,12 @@
    15.4  #include "runtime/os.hpp"
    15.5  #include "runtime/sharedRuntime.hpp"
    15.6  #include "runtime/stubRoutines.hpp"
    15.7 -#ifndef SERIALGC
    15.8 +#include "utilities/macros.hpp"
    15.9 +#if INCLUDE_ALL_GCS
   15.10  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   15.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   15.12  #include "gc_implementation/g1/heapRegion.hpp"
   15.13 -#endif
   15.14 +#endif // INCLUDE_ALL_GCS
   15.15  
   15.16  #ifdef PRODUCT
   15.17  #define BLOCK_COMMENT(str) /* nothing */
   15.18 @@ -3207,7 +3208,7 @@
   15.19  
   15.20  
   15.21  //////////////////////////////////////////////////////////////////////////////////
   15.22 -#ifndef SERIALGC
   15.23 +#if INCLUDE_ALL_GCS
   15.24  
   15.25  void MacroAssembler::g1_write_barrier_pre(Register obj,
   15.26                                            Register pre_val,
   15.27 @@ -3417,7 +3418,7 @@
   15.28    bind(done);
   15.29  }
   15.30  
   15.31 -#endif // SERIALGC
   15.32 +#endif // INCLUDE_ALL_GCS
   15.33  //////////////////////////////////////////////////////////////////////////////////
   15.34  
   15.35  

    16.1 --- a/src/cpu/x86/vm/macroAssembler_x86.hpp	Fri Jan 18 05:33:32 2013 -0800
    16.2 +++ b/src/cpu/x86/vm/macroAssembler_x86.hpp	Wed Jan 23 13:02:39 2013 -0500
    16.3 @@ -26,6 +26,7 @@
    16.4  #define CPU_X86_VM_MACROASSEMBLER_X86_HPP
    16.5  
    16.6  #include "asm/assembler.hpp"
    16.7 +#include "utilities/macros.hpp"
    16.8  
    16.9  
   16.10  // MacroAssembler extends Assembler by frequently used macros.
   16.11 @@ -294,7 +295,7 @@
   16.12    void store_check(Register obj);                // store check for obj - register is destroyed afterwards
   16.13    void store_check(Register obj, Address dst);   // same as above, dst is exact store location (reg. is destroyed)
   16.14  
   16.15 -#ifndef SERIALGC
   16.16 +#if INCLUDE_ALL_GCS
   16.17  
   16.18    void g1_write_barrier_pre(Register obj,
   16.19                              Register pre_val,
   16.20 @@ -309,7 +310,7 @@
   16.21                               Register tmp,
   16.22                               Register tmp2);
   16.23  
   16.24 -#endif // SERIALGC
   16.25 +#endif // INCLUDE_ALL_GCS
   16.26  
   16.27    // split store_check(Register obj) to enhance instruction interleaving
   16.28    void store_check_part_1(Register obj);

    17.1 --- a/src/cpu/x86/vm/templateInterpreter_x86_32.cpp	Fri Jan 18 05:33:32 2013 -0800
    17.2 +++ b/src/cpu/x86/vm/templateInterpreter_x86_32.cpp	Wed Jan 23 13:02:39 2013 -0500
    17.3 @@ -44,6 +44,7 @@
    17.4  #include "runtime/timer.hpp"
    17.5  #include "runtime/vframeArray.hpp"
    17.6  #include "utilities/debug.hpp"
    17.7 +#include "utilities/macros.hpp"
    17.8  
    17.9  #define __ _masm->
   17.10  
   17.11 @@ -761,7 +762,7 @@
   17.12  
   17.13  // Method entry for java.lang.ref.Reference.get.
   17.14  address InterpreterGenerator::generate_Reference_get_entry(void) {
   17.15 -#ifndef SERIALGC
   17.16 +#if INCLUDE_ALL_GCS
   17.17    // Code: _aload_0, _getfield, _areturn
   17.18    // parameter size = 1
   17.19    //
   17.20 @@ -844,7 +845,7 @@
   17.21  
   17.22      return entry;
   17.23    }
   17.24 -#endif // SERIALGC
   17.25 +#endif // INCLUDE_ALL_GCS
   17.26  
   17.27    // If G1 is not enabled then attempt to go through the accessor entry point
   17.28    // Reference.get is an accessor

    18.1 --- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp	Fri Jan 18 05:33:32 2013 -0800
    18.2 +++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp	Wed Jan 23 13:02:39 2013 -0500
    18.3 @@ -44,6 +44,7 @@
    18.4  #include "runtime/timer.hpp"
    18.5  #include "runtime/vframeArray.hpp"
    18.6  #include "utilities/debug.hpp"
    18.7 +#include "utilities/macros.hpp"
    18.8  
    18.9  #define __ _masm->
   18.10  
   18.11 @@ -742,7 +743,7 @@
   18.12  
   18.13  // Method entry for java.lang.ref.Reference.get.
   18.14  address InterpreterGenerator::generate_Reference_get_entry(void) {
   18.15 -#ifndef SERIALGC
   18.16 +#if INCLUDE_ALL_GCS
   18.17    // Code: _aload_0, _getfield, _areturn
   18.18    // parameter size = 1
   18.19    //
   18.20 @@ -821,7 +822,7 @@
   18.21  
   18.22      return entry;
   18.23    }
   18.24 -#endif // SERIALGC
   18.25 +#endif // INCLUDE_ALL_GCS
   18.26  
   18.27    // If G1 is not enabled then attempt to go through the accessor entry point
   18.28    // Reference.get is an accessor

    19.1 --- a/src/cpu/x86/vm/templateTable_x86_32.cpp	Fri Jan 18 05:33:32 2013 -0800
    19.2 +++ b/src/cpu/x86/vm/templateTable_x86_32.cpp	Wed Jan 23 13:02:39 2013 -0500
    19.3 @@ -35,6 +35,7 @@
    19.4  #include "runtime/sharedRuntime.hpp"
    19.5  #include "runtime/stubRoutines.hpp"
    19.6  #include "runtime/synchronizer.hpp"
    19.7 +#include "utilities/macros.hpp"
    19.8  
    19.9  #ifndef CC_INTERP
   19.10  #define __ _masm->
   19.11 @@ -125,7 +126,7 @@
   19.12                           bool precise) {
   19.13    assert(val == noreg || val == rax, "parameter is just for looks");
   19.14    switch (barrier) {
   19.15 -#ifndef SERIALGC
   19.16 +#if INCLUDE_ALL_GCS
   19.17      case BarrierSet::G1SATBCT:
   19.18      case BarrierSet::G1SATBCTLogging:
   19.19        {
   19.20 @@ -164,7 +165,7 @@
   19.21  
   19.22        }
   19.23        break;
   19.24 -#endif // SERIALGC
   19.25 +#endif // INCLUDE_ALL_GCS
   19.26      case BarrierSet::CardTableModRef:
   19.27      case BarrierSet::CardTableExtension:
   19.28        {

    20.1 --- a/src/cpu/x86/vm/templateTable_x86_64.cpp	Fri Jan 18 05:33:32 2013 -0800
    20.2 +++ b/src/cpu/x86/vm/templateTable_x86_64.cpp	Wed Jan 23 13:02:39 2013 -0500
    20.3 @@ -35,6 +35,7 @@
    20.4  #include "runtime/sharedRuntime.hpp"
    20.5  #include "runtime/stubRoutines.hpp"
    20.6  #include "runtime/synchronizer.hpp"
    20.7 +#include "utilities/macros.hpp"
    20.8  
    20.9  #ifndef CC_INTERP
   20.10  
   20.11 @@ -136,7 +137,7 @@
   20.12                           bool precise) {
   20.13    assert(val == noreg || val == rax, "parameter is just for looks");
   20.14    switch (barrier) {
   20.15 -#ifndef SERIALGC
   20.16 +#if INCLUDE_ALL_GCS
   20.17      case BarrierSet::G1SATBCT:
   20.18      case BarrierSet::G1SATBCTLogging:
   20.19        {
   20.20 @@ -167,7 +168,7 @@
   20.21  
   20.22        }
   20.23        break;
   20.24 -#endif // SERIALGC
   20.25 +#endif // INCLUDE_ALL_GCS
   20.26      case BarrierSet::CardTableModRef:
   20.27      case BarrierSet::CardTableExtension:
   20.28        {

    21.1 --- a/src/cpu/zero/vm/assembler_zero.cpp	Fri Jan 18 05:33:32 2013 -0800
    21.2 +++ b/src/cpu/zero/vm/assembler_zero.cpp	Wed Jan 23 13:02:39 2013 -0500
    21.3 @@ -36,11 +36,12 @@
    21.4  #include "runtime/os.hpp"
    21.5  #include "runtime/sharedRuntime.hpp"
    21.6  #include "runtime/stubRoutines.hpp"
    21.7 -#ifndef SERIALGC
    21.8 +#include "utilities/macros.hpp"
    21.9 +#if INCLUDE_ALL_GCS
   21.10  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   21.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   21.12  #include "gc_implementation/g1/heapRegion.hpp"
   21.13 -#endif
   21.14 +#endif // INCLUDE_ALL_GCS
   21.15  
   21.16  int AbstractAssembler::code_fill_byte() {
   21.17    return 0;

    22.1 --- a/src/cpu/zero/vm/cppInterpreter_zero.cpp	Fri Jan 18 05:33:32 2013 -0800
    22.2 +++ b/src/cpu/zero/vm/cppInterpreter_zero.cpp	Wed Jan 23 13:02:39 2013 -0500
    22.3 @@ -47,6 +47,7 @@
    22.4  #include "runtime/vframeArray.hpp"
    22.5  #include "stack_zero.inline.hpp"
    22.6  #include "utilities/debug.hpp"
    22.7 +#include "utilities/macros.hpp"
    22.8  #ifdef SHARK
    22.9  #include "shark/shark_globals.hpp"
   22.10  #endif
   22.11 @@ -791,7 +792,7 @@
   22.12  }
   22.13  
   22.14  address InterpreterGenerator::generate_Reference_get_entry(void) {
   22.15 -#ifndef SERIALGC
   22.16 +#if INCLUDE_ALL_GCS
   22.17    if (UseG1GC) {
   22.18      // We need to generate have a routine that generates code to:
   22.19      //   * load the value in the referent field
   22.20 @@ -803,7 +804,7 @@
   22.21      // field as live.
   22.22      Unimplemented();
   22.23    }
   22.24 -#endif // SERIALGC
   22.25 +#endif // INCLUDE_ALL_GCS
   22.26  
   22.27    // If G1 is not enabled then attempt to go through the accessor entry point
   22.28    // Reference.get is an accessor

    23.1 --- a/src/share/vm/c1/c1_CodeStubs.hpp	Fri Jan 18 05:33:32 2013 -0800
    23.2 +++ b/src/share/vm/c1/c1_CodeStubs.hpp	Wed Jan 23 13:02:39 2013 -0500
    23.3 @@ -31,6 +31,7 @@
    23.4  #include "c1/c1_LIR.hpp"
    23.5  #include "c1/c1_Runtime1.hpp"
    23.6  #include "utilities/array.hpp"
    23.7 +#include "utilities/macros.hpp"
    23.8  
    23.9  class CodeEmitInfo;
   23.10  class LIR_Assembler;
   23.11 @@ -515,7 +516,7 @@
   23.12  };
   23.13  
   23.14  //////////////////////////////////////////////////////////////////////////////////////////
   23.15 -#ifndef SERIALGC
   23.16 +#if INCLUDE_ALL_GCS
   23.17  
   23.18  // Code stubs for Garbage-First barriers.
   23.19  class G1PreBarrierStub: public CodeStub {
   23.20 @@ -608,7 +609,7 @@
   23.21  #endif // PRODUCT
   23.22  };
   23.23  
   23.24 -#endif // SERIALGC
   23.25 +#endif // INCLUDE_ALL_GCS
   23.26  //////////////////////////////////////////////////////////////////////////////////////////
   23.27  
   23.28  #endif // SHARE_VM_C1_C1_CODESTUBS_HPP

    24.1 --- a/src/share/vm/c1/c1_LIRGenerator.cpp	Fri Jan 18 05:33:32 2013 -0800
    24.2 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp	Wed Jan 23 13:02:39 2013 -0500
    24.3 @@ -35,9 +35,10 @@
    24.4  #include "runtime/sharedRuntime.hpp"
    24.5  #include "runtime/stubRoutines.hpp"
    24.6  #include "utilities/bitMap.inline.hpp"
    24.7 -#ifndef SERIALGC
    24.8 +#include "utilities/macros.hpp"
    24.9 +#if INCLUDE_ALL_GCS
   24.10  #include "gc_implementation/g1/heapRegion.hpp"
   24.11 -#endif
   24.12 +#endif // INCLUDE_ALL_GCS
   24.13  
   24.14  #ifdef ASSERT
   24.15  #define __ gen()->lir(__FILE__, __LINE__)->
   24.16 @@ -1417,12 +1418,12 @@
   24.17                                 bool do_load, bool patch, CodeEmitInfo* info) {
   24.18    // Do the pre-write barrier, if any.
   24.19    switch (_bs->kind()) {
   24.20 -#ifndef SERIALGC
   24.21 +#if INCLUDE_ALL_GCS
   24.22      case BarrierSet::G1SATBCT:
   24.23      case BarrierSet::G1SATBCTLogging:
   24.24        G1SATBCardTableModRef_pre_barrier(addr_opr, pre_val, do_load, patch, info);
   24.25        break;
   24.26 -#endif // SERIALGC
   24.27 +#endif // INCLUDE_ALL_GCS
   24.28      case BarrierSet::CardTableModRef:
   24.29      case BarrierSet::CardTableExtension:
   24.30        // No pre barriers
   24.31 @@ -1439,12 +1440,12 @@
   24.32  
   24.33  void LIRGenerator::post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val) {
   24.34    switch (_bs->kind()) {
   24.35 -#ifndef SERIALGC
   24.36 +#if INCLUDE_ALL_GCS
   24.37      case BarrierSet::G1SATBCT:
   24.38      case BarrierSet::G1SATBCTLogging:
   24.39        G1SATBCardTableModRef_post_barrier(addr,  new_val);
   24.40        break;
   24.41 -#endif // SERIALGC
   24.42 +#endif // INCLUDE_ALL_GCS
   24.43      case BarrierSet::CardTableModRef:
   24.44      case BarrierSet::CardTableExtension:
   24.45        CardTableModRef_post_barrier(addr,  new_val);
   24.46 @@ -1459,7 +1460,7 @@
   24.47  }
   24.48  
   24.49  ////////////////////////////////////////////////////////////////////////
   24.50 -#ifndef SERIALGC
   24.51 +#if INCLUDE_ALL_GCS
   24.52  
   24.53  void LIRGenerator::G1SATBCardTableModRef_pre_barrier(LIR_Opr addr_opr, LIR_Opr pre_val,
   24.54                                                       bool do_load, bool patch, CodeEmitInfo* info) {
   24.55 @@ -1575,7 +1576,7 @@
   24.56    __ branch_destination(slow->continuation());
   24.57  }
   24.58  
   24.59 -#endif // SERIALGC
   24.60 +#endif // INCLUDE_ALL_GCS
   24.61  ////////////////////////////////////////////////////////////////////////
   24.62  
   24.63  void LIRGenerator::CardTableModRef_post_barrier(LIR_OprDesc* addr, LIR_OprDesc* new_val) {
   24.64 @@ -2181,7 +2182,7 @@
   24.65  
   24.66    get_Object_unsafe(value, src.result(), off.result(), type, x->is_volatile());
   24.67  
   24.68 -#ifndef SERIALGC
   24.69 +#if INCLUDE_ALL_GCS
   24.70    // We might be reading the value of the referent field of a
   24.71    // Reference object in order to attach it back to the live
   24.72    // object graph. If G1 is enabled then we need to record
   24.73 @@ -2311,7 +2312,7 @@
   24.74        __ branch_destination(Lcont->label());
   24.75      }
   24.76    }
   24.77 -#endif // SERIALGC
   24.78 +#endif // INCLUDE_ALL_GCS
   24.79  
   24.80    if (x->is_volatile() && os::is_MP()) __ membar_acquire();
   24.81  }

    25.1 --- a/src/share/vm/ci/ciEnv.cpp	Fri Jan 18 05:33:32 2013 -0800
    25.2 +++ b/src/share/vm/ci/ciEnv.cpp	Wed Jan 23 13:02:39 2013 -0500
    25.3 @@ -52,6 +52,7 @@
    25.4  #include "runtime/reflection.hpp"
    25.5  #include "runtime/sharedRuntime.hpp"
    25.6  #include "utilities/dtrace.hpp"
    25.7 +#include "utilities/macros.hpp"
    25.8  #ifdef COMPILER1
    25.9  #include "c1/c1_Runtime1.hpp"
   25.10  #endif

    26.1 --- a/src/share/vm/ci/ciReplay.cpp	Fri Jan 18 05:33:32 2013 -0800
    26.2 +++ b/src/share/vm/ci/ciReplay.cpp	Wed Jan 23 13:02:39 2013 -0500
    26.3 @@ -30,6 +30,7 @@
    26.4  #include "memory/oopFactory.hpp"
    26.5  #include "memory/resourceArea.hpp"
    26.6  #include "utilities/copy.hpp"
    26.7 +#include "utilities/macros.hpp"
    26.8  
    26.9  #ifndef PRODUCT
   26.10  

    27.1 --- a/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp	Fri Jan 18 05:33:32 2013 -0800
    27.2 +++ b/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp	Wed Jan 23 13:02:39 2013 -0500
    27.3 @@ -28,8 +28,9 @@
    27.4  #include "memory/cardTableModRefBS.hpp"
    27.5  #include "memory/memRegion.hpp"
    27.6  #include "oops/oop.inline.hpp"
    27.7 +#include "utilities/macros.hpp"
    27.8  
    27.9 -#ifndef SERIALGC
   27.10 +#if INCLUDE_ALL_GCS
   27.11  
   27.12  class DirtyCardQueueSet;
   27.13  
   27.14 @@ -120,6 +121,6 @@
   27.15  };
   27.16  
   27.17  
   27.18 -#endif // SERIALGC
   27.19 +#endif // INCLUDE_ALL_GCS
   27.20  
   27.21  #endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1SATBCARDTABLEMODREFBS_HPP

    28.1 --- a/src/share/vm/gc_implementation/g1/heapRegion.hpp	Fri Jan 18 05:33:32 2013 -0800
    28.2 +++ b/src/share/vm/gc_implementation/g1/heapRegion.hpp	Wed Jan 23 13:02:39 2013 -0500
    28.3 @@ -32,8 +32,9 @@
    28.4  #include "gc_implementation/shared/spaceDecorator.hpp"
    28.5  #include "memory/space.inline.hpp"
    28.6  #include "memory/watermark.hpp"
    28.7 +#include "utilities/macros.hpp"
    28.8  
    28.9 -#ifndef SERIALGC
   28.10 +#if INCLUDE_ALL_GCS
   28.11  
   28.12  // A HeapRegion is the smallest piece of a G1CollectedHeap that
   28.13  // can be collected independently.
   28.14 @@ -837,6 +838,6 @@
   28.15    bool complete() { return _complete; }
   28.16  };
   28.17  
   28.18 -#endif // SERIALGC
   28.19 +#endif // INCLUDE_ALL_GCS
   28.20  
   28.21  #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP

    29.1 --- a/src/share/vm/gc_implementation/shared/allocationStats.cpp	Fri Jan 18 05:33:32 2013 -0800
    29.2 +++ b/src/share/vm/gc_implementation/shared/allocationStats.cpp	Wed Jan 23 13:02:39 2013 -0500
    29.3 @@ -23,10 +23,11 @@
    29.4   */
    29.5  
    29.6  #include "precompiled.hpp"
    29.7 -#ifndef SERIALGC
    29.8 +#include "utilities/macros.hpp"
    29.9 +#if INCLUDE_ALL_GCS
   29.10  #include "gc_implementation/shared/allocationStats.hpp"
   29.11  #include "utilities/ostream.hpp"
   29.12 -#endif
   29.13 +#endif // INCLUDE_ALL_GCS
   29.14  
   29.15  // Technically this should be derived from machine speed, and
   29.16  // ideally it would be dynamically adjusted.

    30.1 --- a/src/share/vm/gc_implementation/shared/allocationStats.hpp	Fri Jan 18 05:33:32 2013 -0800
    30.2 +++ b/src/share/vm/gc_implementation/shared/allocationStats.hpp	Wed Jan 23 13:02:39 2013 -0500
    30.3 @@ -25,11 +25,12 @@
    30.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_ALLOCATIONSTATS_HPP
    30.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_ALLOCATIONSTATS_HPP
    30.6  
    30.7 -#ifndef SERIALGC
    30.8 +#include "utilities/macros.hpp"
    30.9 +#if INCLUDE_ALL_GCS
   30.10  #include "gc_implementation/shared/gcUtil.hpp"
   30.11  #include "memory/allocation.hpp"
   30.12  #include "utilities/globalDefinitions.hpp"
   30.13 -#endif
   30.14 +#endif // INCLUDE_ALL_GCS
   30.15  
   30.16  class AllocationStats VALUE_OBJ_CLASS_SPEC {
   30.17    // A duration threshold (in ms) used to filter

    31.1 --- a/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp	Fri Jan 18 05:33:32 2013 -0800
    31.2 +++ b/src/share/vm/gc_implementation/shared/concurrentGCThread.hpp	Wed Jan 23 13:02:39 2013 -0500
    31.3 @@ -25,9 +25,10 @@
    31.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_CONCURRENTGCTHREAD_HPP
    31.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_CONCURRENTGCTHREAD_HPP
    31.6  
    31.7 -#ifndef SERIALGC
    31.8 +#include "utilities/macros.hpp"
    31.9 +#if INCLUDE_ALL_GCS
   31.10  #include "runtime/thread.hpp"
   31.11 -#endif
   31.12 +#endif // INCLUDE_ALL_GCS
   31.13  
   31.14  class VoidClosure;
   31.15  

    32.1 --- a/src/share/vm/gc_implementation/shared/gSpaceCounters.cpp	Fri Jan 18 05:33:32 2013 -0800
    32.2 +++ b/src/share/vm/gc_implementation/shared/gSpaceCounters.cpp	Wed Jan 23 13:02:39 2013 -0500
    32.3 @@ -23,11 +23,12 @@
    32.4   */
    32.5  
    32.6  #include "precompiled.hpp"
    32.7 -#ifndef SERIALGC
    32.8 +#include "utilities/macros.hpp"
    32.9 +#if INCLUDE_ALL_GCS
   32.10  #include "gc_implementation/shared/gSpaceCounters.hpp"
   32.11  #include "memory/generation.hpp"
   32.12  #include "memory/resourceArea.hpp"
   32.13 -#endif
   32.14 +#endif // INCLUDE_ALL_GCS
   32.15  
   32.16  GSpaceCounters::GSpaceCounters(const char* name, int ordinal, size_t max_size,
   32.17                                 Generation* g, GenerationCounters* gc,

    33.1 --- a/src/share/vm/gc_implementation/shared/gSpaceCounters.hpp	Fri Jan 18 05:33:32 2013 -0800
    33.2 +++ b/src/share/vm/gc_implementation/shared/gSpaceCounters.hpp	Wed Jan 23 13:02:39 2013 -0500
    33.3 @@ -25,11 +25,12 @@
    33.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_GSPACECOUNTERS_HPP
    33.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_GSPACECOUNTERS_HPP
    33.6  
    33.7 -#ifndef SERIALGC
    33.8 +#include "utilities/macros.hpp"
    33.9 +#if INCLUDE_ALL_GCS
   33.10  #include "gc_implementation/shared/generationCounters.hpp"
   33.11  #include "memory/generation.hpp"
   33.12  #include "runtime/perfData.hpp"
   33.13 -#endif
   33.14 +#endif // INCLUDE_ALL_GCS
   33.15  
   33.16  // A GSpaceCounter is a holder class for performance counters
   33.17  // that track a space;

    34.1 --- a/src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp	Fri Jan 18 05:33:32 2013 -0800
    34.2 +++ b/src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp	Wed Jan 23 13:02:39 2013 -0500
    34.3 @@ -25,10 +25,11 @@
    34.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_GCADAPTIVEPOLICYCOUNTERS_HPP
    34.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_GCADAPTIVEPOLICYCOUNTERS_HPP
    34.6  
    34.7 -#ifndef SERIALGC
    34.8 +#include "utilities/macros.hpp"
    34.9 +#if INCLUDE_ALL_GCS
   34.10  #include "gc_implementation/shared/adaptiveSizePolicy.hpp"
   34.11  #include "gc_implementation/shared/gcPolicyCounters.hpp"
   34.12 -#endif
   34.13 +#endif // INCLUDE_ALL_GCS
   34.14  
   34.15  // This class keeps statistical information and computes the
   34.16  // size of the heap.

    35.1 --- a/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp	Fri Jan 18 05:33:32 2013 -0800
    35.2 +++ b/src/share/vm/gc_implementation/shared/hSpaceCounters.hpp	Wed Jan 23 13:02:39 2013 -0500
    35.3 @@ -25,11 +25,12 @@
    35.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_HSPACECOUNTERS_HPP
    35.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_HSPACECOUNTERS_HPP
    35.6  
    35.7 -#ifndef SERIALGC
    35.8 +#include "utilities/macros.hpp"
    35.9 +#if INCLUDE_ALL_GCS
   35.10  #include "gc_implementation/shared/generationCounters.hpp"
   35.11  #include "memory/generation.hpp"
   35.12  #include "runtime/perfData.hpp"
   35.13 -#endif
   35.14 +#endif // INCLUDE_ALL_GCS
   35.15  
   35.16  // A HSpaceCounter is a holder class for performance counters
   35.17  // that track a collections (logical spaces) in a heap;

    36.1 --- a/src/share/vm/gc_implementation/shared/immutableSpace.cpp	Fri Jan 18 05:33:32 2013 -0800
    36.2 +++ b/src/share/vm/gc_implementation/shared/immutableSpace.cpp	Wed Jan 23 13:02:39 2013 -0500
    36.3 @@ -23,11 +23,12 @@
    36.4   */
    36.5  
    36.6  #include "precompiled.hpp"
    36.7 -#ifndef SERIALGC
    36.8 +#include "utilities/macros.hpp"
    36.9 +#if INCLUDE_ALL_GCS
   36.10  #include "gc_implementation/shared/immutableSpace.hpp"
   36.11  #include "memory/universe.hpp"
   36.12  #include "oops/oop.inline.hpp"
   36.13 -#endif
   36.14 +#endif // INCLUDE_ALL_GCS
   36.15  
   36.16  void ImmutableSpace::initialize(MemRegion mr) {
   36.17    HeapWord* bottom = mr.start();

    37.1 --- a/src/share/vm/gc_implementation/shared/isGCActiveMark.hpp	Fri Jan 18 05:33:32 2013 -0800
    37.2 +++ b/src/share/vm/gc_implementation/shared/isGCActiveMark.hpp	Wed Jan 23 13:02:39 2013 -0500
    37.3 @@ -25,9 +25,10 @@
    37.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_ISGCACTIVEMARK_HPP
    37.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_ISGCACTIVEMARK_HPP
    37.6  
    37.7 -#ifndef SERIALGC
    37.8 +#include "utilities/macros.hpp"
    37.9 +#if INCLUDE_ALL_GCS
   37.10  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
   37.11 -#endif
   37.12 +#endif // INCLUDE_ALL_GCS
   37.13  
   37.14  // This class provides a method for block structured setting of the
   37.15  // _is_gc_active state without requiring accessors in CollectedHeap

    38.1 --- a/src/share/vm/gc_implementation/shared/markSweep.inline.hpp	Fri Jan 18 05:33:32 2013 -0800
    38.2 +++ b/src/share/vm/gc_implementation/shared/markSweep.inline.hpp	Wed Jan 23 13:02:39 2013 -0500
    38.3 @@ -28,9 +28,10 @@
    38.4  #include "gc_implementation/shared/markSweep.hpp"
    38.5  #include "gc_interface/collectedHeap.hpp"
    38.6  #include "utilities/stack.inline.hpp"
    38.7 -#ifndef SERIALGC
    38.8 +#include "utilities/macros.hpp"
    38.9 +#if INCLUDE_ALL_GCS
   38.10  #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
   38.11 -#endif
   38.12 +#endif // INCLUDE_ALL_GCS
   38.13  
   38.14  inline void MarkSweep::mark_object(oop obj) {
   38.15    // some marks may contain information we need to preserve so we store them away

    39.1 --- a/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp	Fri Jan 18 05:33:32 2013 -0800
    39.2 +++ b/src/share/vm/gc_implementation/shared/mutableNUMASpace.hpp	Wed Jan 23 13:02:39 2013 -0500
    39.3 @@ -25,10 +25,11 @@
    39.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_MUTABLENUMASPACE_HPP
    39.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_MUTABLENUMASPACE_HPP
    39.6  
    39.7 -#ifndef SERIALGC
    39.8 +#include "utilities/macros.hpp"
    39.9 +#if INCLUDE_ALL_GCS
   39.10  #include "gc_implementation/shared/gcUtil.hpp"
   39.11  #include "gc_implementation/shared/mutableSpace.hpp"
   39.12 -#endif
   39.13 +#endif // INCLUDE_ALL_GCS
   39.14  
   39.15  /*
   39.16   *    The NUMA-aware allocator (MutableNUMASpace) is basically a modification

    40.1 --- a/src/share/vm/gc_implementation/shared/mutableSpace.cpp	Fri Jan 18 05:33:32 2013 -0800
    40.2 +++ b/src/share/vm/gc_implementation/shared/mutableSpace.cpp	Wed Jan 23 13:02:39 2013 -0500
    40.3 @@ -23,13 +23,14 @@
    40.4   */
    40.5  
    40.6  #include "precompiled.hpp"
    40.7 -#ifndef SERIALGC
    40.8 +#include "utilities/macros.hpp"
    40.9 +#if INCLUDE_ALL_GCS
   40.10  #include "gc_implementation/shared/mutableSpace.hpp"
   40.11  #include "gc_implementation/shared/spaceDecorator.hpp"
   40.12  #include "oops/oop.inline.hpp"
   40.13  #include "runtime/safepoint.hpp"
   40.14  #include "runtime/thread.hpp"
   40.15 -#endif
   40.16 +#endif // INCLUDE_ALL_GCS
   40.17  
   40.18  MutableSpace::MutableSpace(size_t alignment): ImmutableSpace(), _top(NULL), _alignment(alignment) {
   40.19    assert(MutableSpace::alignment() >= 0 &&

    41.1 --- a/src/share/vm/gc_implementation/shared/spaceCounters.cpp	Fri Jan 18 05:33:32 2013 -0800
    41.2 +++ b/src/share/vm/gc_implementation/shared/spaceCounters.cpp	Wed Jan 23 13:02:39 2013 -0500
    41.3 @@ -23,10 +23,11 @@
    41.4   */
    41.5  
    41.6  #include "precompiled.hpp"
    41.7 -#ifndef SERIALGC
    41.8 +#include "utilities/macros.hpp"
    41.9 +#if INCLUDE_ALL_GCS
   41.10  #include "gc_implementation/shared/spaceCounters.hpp"
   41.11  #include "memory/resourceArea.hpp"
   41.12 -#endif
   41.13 +#endif // INCLUDE_ALL_GCS
   41.14  
   41.15  SpaceCounters::SpaceCounters(const char* name, int ordinal, size_t max_size,
   41.16                               MutableSpace* m, GenerationCounters* gc) :

    42.1 --- a/src/share/vm/gc_implementation/shared/spaceCounters.hpp	Fri Jan 18 05:33:32 2013 -0800
    42.2 +++ b/src/share/vm/gc_implementation/shared/spaceCounters.hpp	Wed Jan 23 13:02:39 2013 -0500
    42.3 @@ -25,12 +25,13 @@
    42.4  #ifndef SHARE_VM_GC_IMPLEMENTATION_SHARED_SPACECOUNTERS_HPP
    42.5  #define SHARE_VM_GC_IMPLEMENTATION_SHARED_SPACECOUNTERS_HPP
    42.6  
    42.7 -#ifndef SERIALGC
    42.8 +#include "utilities/macros.hpp"
    42.9 +#if INCLUDE_ALL_GCS
   42.10  #include "gc_implementation/shared/generationCounters.hpp"
   42.11  #include "gc_implementation/shared/immutableSpace.hpp"
   42.12  #include "gc_implementation/shared/mutableSpace.hpp"
   42.13  #include "runtime/perfData.hpp"
   42.14 -#endif
   42.15 +#endif // INCLUDE_ALL_GCS
   42.16  
   42.17  // A SpaceCounter is a holder class for performance counters
   42.18  // that track a space;

    43.1 --- a/src/share/vm/gc_implementation/shared/vmGCOperations.cpp	Fri Jan 18 05:33:32 2013 -0800
    43.2 +++ b/src/share/vm/gc_implementation/shared/vmGCOperations.cpp	Wed Jan 23 13:02:39 2013 -0500
    43.3 @@ -36,9 +36,10 @@
    43.4  #include "runtime/interfaceSupport.hpp"
    43.5  #include "utilities/dtrace.hpp"
    43.6  #include "utilities/preserveException.hpp"
    43.7 -#ifndef SERIALGC
    43.8 +#include "utilities/macros.hpp"
    43.9 +#if INCLUDE_ALL_GCS
   43.10  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   43.11 -#endif
   43.12 +#endif // INCLUDE_ALL_GCS
   43.13  
   43.14  #ifndef USDT2
   43.15  HS_DTRACE_PROBE_DECL1(hotspot, gc__begin, bool);

    44.1 --- a/src/share/vm/memory/binaryTreeDictionary.cpp	Fri Jan 18 05:33:32 2013 -0800
    44.2 +++ b/src/share/vm/memory/binaryTreeDictionary.cpp	Wed Jan 23 13:02:39 2013 -0500
    44.3 @@ -23,6 +23,7 @@
    44.4   */
    44.5  
    44.6  #include "precompiled.hpp"
    44.7 +#include "utilities/macros.hpp"
    44.8  #include "gc_implementation/shared/allocationStats.hpp"
    44.9  #include "memory/binaryTreeDictionary.hpp"
   44.10  #include "memory/freeList.hpp"
   44.11 @@ -31,12 +32,13 @@
   44.12  #include "memory/metachunk.hpp"
   44.13  #include "runtime/globals.hpp"
   44.14  #include "utilities/ostream.hpp"
   44.15 -#ifndef SERIALGC
   44.16 +#include "utilities/macros.hpp"
   44.17 +#if INCLUDE_ALL_GCS
   44.18  #include "gc_implementation/concurrentMarkSweep/adaptiveFreeList.hpp"
   44.19  #include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
   44.20  #include "gc_implementation/shared/spaceDecorator.hpp"
   44.21  #include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
   44.22 -#endif // SERIALGC
   44.23 +#endif // INCLUDE_ALL_GCS
   44.24  
   44.25  ////////////////////////////////////////////////////////////////////////////////
   44.26  // A binary tree based search structure for free blocks.
   44.27 @@ -118,7 +120,7 @@
   44.28  }
   44.29  
   44.30  
   44.31 -#ifndef SERIALGC
   44.32 +#if INCLUDE_ALL_GCS
   44.33  // Specialize for AdaptiveFreeList which tries to avoid
   44.34  // splitting a chunk of a size that is under populated in favor of
   44.35  // an over populated size.  The general get_better_list() just returns
   44.36 @@ -160,7 +162,7 @@
   44.37    }
   44.38    return curTL;
   44.39  }
   44.40 -#endif // SERIALGC
   44.41 +#endif // INCLUDE_ALL_GCS
   44.42  
   44.43  template <class Chunk_t, template <class> class FreeList_t>
   44.44  TreeList<Chunk_t, FreeList_t>*
   44.45 @@ -871,7 +873,7 @@
   44.46  template <class Chunk_t, template <class> class FreeList_t>
   44.47  void BinaryTreeDictionary<Chunk_t, FreeList_t>::dict_census_update(size_t size, bool split, bool birth){}
   44.48  
   44.49 -#ifndef SERIALGC
   44.50 +#if INCLUDE_ALL_GCS
   44.51  template <>
   44.52  void BinaryTreeDictionary<FreeChunk, AdaptiveFreeList>::dict_census_update(size_t size, bool split, bool birth){
   44.53    TreeList<FreeChunk, AdaptiveFreeList>* nd = find_list(size);
   44.54 @@ -900,7 +902,7 @@
   44.55    //   This is a birth associated with a LinAB.  The chunk
   44.56    //     for the LinAB is not in the dictionary.
   44.57  }
   44.58 -#endif // SERIALGC
   44.59 +#endif // INCLUDE_ALL_GCS
   44.60  
   44.61  template <class Chunk_t, template <class> class FreeList_t>
   44.62  bool BinaryTreeDictionary<Chunk_t, FreeList_t>::coal_dict_over_populated(size_t size) {
   44.63 @@ -909,7 +911,7 @@
   44.64    return true;
   44.65  }
   44.66  
   44.67 -#ifndef SERIALGC
   44.68 +#if INCLUDE_ALL_GCS
   44.69  template <>
   44.70  bool BinaryTreeDictionary<FreeChunk, AdaptiveFreeList>::coal_dict_over_populated(size_t size) {
   44.71    if (FLSAlwaysCoalesceLarge) return true;
   44.72 @@ -919,7 +921,7 @@
   44.73    return list_of_size == NULL || list_of_size->coal_desired() <= 0 ||
   44.74           list_of_size->count() > list_of_size->coal_desired();
   44.75  }
   44.76 -#endif  // SERIALGC
   44.77 +#endif // INCLUDE_ALL_GCS
   44.78  
   44.79  // Closures for walking the binary tree.
   44.80  //   do_list() walks the free list in a node applying the closure
   44.81 @@ -979,7 +981,7 @@
   44.82  
   44.83    void do_list(FreeList<Chunk_t>* fl) {}
   44.84  
   44.85 -#ifndef SERIALGC
   44.86 +#if INCLUDE_ALL_GCS
   44.87    void do_list(AdaptiveFreeList<Chunk_t>* fl) {
   44.88      double coalSurplusPercent = _percentage;
   44.89      fl->compute_desired(_inter_sweep_current, _inter_sweep_estimate, _intra_sweep_estimate);
   44.90 @@ -987,7 +989,7 @@
   44.91      fl->set_before_sweep(fl->count());
   44.92      fl->set_bfr_surp(fl->surplus());
   44.93    }
   44.94 -#endif // SERIALGC
   44.95 +#endif // INCLUDE_ALL_GCS
   44.96  };
   44.97  
   44.98  // Used to search the tree until a condition is met.
   44.99 @@ -1134,13 +1136,13 @@
  44.100    setTreeSurplusClosure(double v) { percentage = v; }
  44.101    void do_list(FreeList<Chunk_t>* fl) {}
  44.102  
  44.103 -#ifndef SERIALGC
  44.104 +#if INCLUDE_ALL_GCS
  44.105    void do_list(AdaptiveFreeList<Chunk_t>* fl) {
  44.106      double splitSurplusPercent = percentage;
  44.107      fl->set_surplus(fl->count() -
  44.108                     (ssize_t)((double)fl->desired() * splitSurplusPercent));
  44.109    }
  44.110 -#endif // SERIALGC
  44.111 +#endif // INCLUDE_ALL_GCS
  44.112  };
  44.113  
  44.114  template <class Chunk_t, template <class> class FreeList_t>
  44.115 @@ -1157,7 +1159,7 @@
  44.116    setTreeHintsClosure(size_t v) { hint = v; }
  44.117    void do_list(FreeList<Chunk_t>* fl) {}
  44.118  
  44.119 -#ifndef SERIALGC
  44.120 +#if INCLUDE_ALL_GCS
  44.121    void do_list(AdaptiveFreeList<Chunk_t>* fl) {
  44.122      fl->set_hint(hint);
  44.123      assert(fl->hint() == 0 || fl->hint() > fl->size(),
  44.124 @@ -1166,7 +1168,7 @@
  44.125        hint = fl->size();
  44.126      }
  44.127    }
  44.128 -#endif // SERIALGC
  44.129 +#endif // INCLUDE_ALL_GCS
  44.130  };
  44.131  
  44.132  template <class Chunk_t, template <class> class FreeList_t>
  44.133 @@ -1180,7 +1182,7 @@
  44.134  class clearTreeCensusClosure : public AscendTreeCensusClosure<Chunk_t, FreeList_t> {
  44.135    void do_list(FreeList<Chunk_t>* fl) {}
  44.136  
  44.137 -#ifndef SERIALGC
  44.138 +#if INCLUDE_ALL_GCS
  44.139    void do_list(AdaptiveFreeList<Chunk_t>* fl) {
  44.140      fl->set_prev_sweep(fl->count());
  44.141      fl->set_coal_births(0);
  44.142 @@ -1188,7 +1190,7 @@
  44.143      fl->set_split_births(0);
  44.144      fl->set_split_deaths(0);
  44.145    }
  44.146 -#endif  // SERIALGC
  44.147 +#endif // INCLUDE_ALL_GCS
  44.148  };
  44.149  
  44.150  template <class Chunk_t, template <class> class FreeList_t>
  44.151 @@ -1252,7 +1254,7 @@
  44.152      total()->set_count(      total()->count()       + fl->count()      );
  44.153    }
  44.154  
  44.155 -#ifndef SERIALGC
  44.156 +#if INCLUDE_ALL_GCS
  44.157    void do_list(AdaptiveFreeList<Chunk_t>* fl) {
  44.158      if (++_print_line >= 40) {
  44.159        FreeList_t<Chunk_t>::print_labels_on(gclog_or_tty, "size");
  44.160 @@ -1271,7 +1273,7 @@
  44.161      total()->set_split_births(total()->split_births() + fl->split_births());
  44.162      total()->set_split_deaths(total()->split_deaths() + fl->split_deaths());
  44.163    }
  44.164 -#endif  // SERIALGC
  44.165 +#endif // INCLUDE_ALL_GCS
  44.166  };
  44.167  
  44.168  template <class Chunk_t, template <class> class FreeList_t>
  44.169 @@ -1286,7 +1288,7 @@
  44.170    FreeList_t<Chunk_t>::print_labels_on(gclog_or_tty, " ");
  44.171  }
  44.172  
  44.173 -#ifndef SERIALGC
  44.174 +#if INCLUDE_ALL_GCS
  44.175  template <>
  44.176  void BinaryTreeDictionary<FreeChunk, AdaptiveFreeList>::print_dict_census(void) const {
  44.177  
  44.178 @@ -1308,7 +1310,7 @@
  44.179               (double)(total->desired() - total->count())
  44.180               /(total->desired() != 0 ? (double)total->desired() : 1.0));
  44.181  }
  44.182 -#endif  // SERIALGC
  44.183 +#endif // INCLUDE_ALL_GCS
  44.184  
  44.185  template <class Chunk_t, template <class> class FreeList_t>
  44.186  class PrintFreeListsClosure : public AscendTreeCensusClosure<Chunk_t, FreeList_t> {
  44.187 @@ -1414,10 +1416,10 @@
  44.188  template class TreeChunk<Metachunk, FreeList>;
  44.189  
  44.190  
  44.191 -#ifndef SERIALGC
  44.192 +#if INCLUDE_ALL_GCS
  44.193  // Explicitly instantiate these types for FreeChunk.
  44.194  template class TreeList<FreeChunk, AdaptiveFreeList>;
  44.195  template class BinaryTreeDictionary<FreeChunk, AdaptiveFreeList>;
  44.196  template class TreeChunk<FreeChunk, AdaptiveFreeList>;
  44.197  
  44.198 -#endif // SERIALGC
  44.199 +#endif // INCLUDE_ALL_GCS

    45.1 --- a/src/share/vm/memory/cardTableModRefBS.cpp	Fri Jan 18 05:33:32 2013 -0800
    45.2 +++ b/src/share/vm/memory/cardTableModRefBS.cpp	Wed Jan 23 13:02:39 2013 -0500
    45.3 @@ -34,6 +34,7 @@
    45.4  #include "runtime/mutexLocker.hpp"
    45.5  #include "runtime/virtualspace.hpp"
    45.6  #include "services/memTracker.hpp"
    45.7 +#include "utilities/macros.hpp"
    45.8  #ifdef COMPILER1
    45.9  #include "c1/c1_LIR.hpp"
   45.10  #include "c1/c1_LIRGenerator.hpp"
   45.11 @@ -499,13 +500,13 @@
   45.12      int n_threads =  SharedHeap::heap()->n_par_threads();
   45.13      bool is_par = n_threads > 0;
   45.14      if (is_par) {
   45.15 -#ifndef SERIALGC
   45.16 +#if INCLUDE_ALL_GCS
   45.17        assert(SharedHeap::heap()->n_par_threads() ==
   45.18               SharedHeap::heap()->workers()->active_workers(), "Mismatch");
   45.19        non_clean_card_iterate_parallel_work(sp, mr, cl, ct, n_threads);
   45.20 -#else  // SERIALGC
   45.21 +#else  // INCLUDE_ALL_GCS
   45.22        fatal("Parallel gc not supported here.");
   45.23 -#endif // SERIALGC
   45.24 +#endif // INCLUDE_ALL_GCS
   45.25      } else {
   45.26        // We do not call the non_clean_card_iterate_serial() version below because
   45.27        // we want to clear the cards (which non_clean_card_iterate_serial() does not

    46.1 --- a/src/share/vm/memory/cardTableRS.cpp	Fri Jan 18 05:33:32 2013 -0800
    46.2 +++ b/src/share/vm/memory/cardTableRS.cpp	Wed Jan 23 13:02:39 2013 -0500
    46.3 @@ -31,10 +31,11 @@
    46.4  #include "oops/oop.inline.hpp"
    46.5  #include "runtime/java.hpp"
    46.6  #include "runtime/os.hpp"
    46.7 -#ifndef SERIALGC
    46.8 +#include "utilities/macros.hpp"
    46.9 +#if INCLUDE_ALL_GCS
   46.10  #include "gc_implementation/g1/concurrentMark.hpp"
   46.11  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   46.12 -#endif
   46.13 +#endif // INCLUDE_ALL_GCS
   46.14  
   46.15  CardTableRS::CardTableRS(MemRegion whole_heap,
   46.16                           int max_covered_regions) :
   46.17 @@ -42,7 +43,7 @@
   46.18    _cur_youngergen_card_val(youngergenP1_card),
   46.19    _regions_to_iterate(max_covered_regions - 1)
   46.20  {
   46.21 -#ifndef SERIALGC
   46.22 +#if INCLUDE_ALL_GCS
   46.23    if (UseG1GC) {
   46.24        _ct_bs = new G1SATBCardTableLoggingModRefBS(whole_heap,
   46.25                                                    max_covered_regions);

    47.1 --- a/src/share/vm/memory/collectorPolicy.cpp	Fri Jan 18 05:33:32 2013 -0800
    47.2 +++ b/src/share/vm/memory/collectorPolicy.cpp	Wed Jan 23 13:02:39 2013 -0500
    47.3 @@ -39,10 +39,11 @@
    47.4  #include "runtime/java.hpp"
    47.5  #include "runtime/thread.inline.hpp"
    47.6  #include "runtime/vmThread.hpp"
    47.7 -#ifndef SERIALGC
    47.8 +#include "utilities/macros.hpp"
    47.9 +#if INCLUDE_ALL_GCS
   47.10  #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
   47.11  #include "gc_implementation/concurrentMarkSweep/cmsGCAdaptivePolicyCounters.hpp"
   47.12 -#endif
   47.13 +#endif // INCLUDE_ALL_GCS
   47.14  
   47.15  // CollectorPolicy methods.
   47.16  

    48.1 --- a/src/share/vm/memory/collectorPolicy.hpp	Fri Jan 18 05:33:32 2013 -0800
    48.2 +++ b/src/share/vm/memory/collectorPolicy.hpp	Wed Jan 23 13:02:39 2013 -0500
    48.3 @@ -29,6 +29,7 @@
    48.4  #include "memory/barrierSet.hpp"
    48.5  #include "memory/generationSpec.hpp"
    48.6  #include "memory/genRemSet.hpp"
    48.7 +#include "utilities/macros.hpp"
    48.8  
    48.9  // This class (or more correctly, subtypes of this class)
   48.10  // are used to define global garbage collector attributes.
   48.11 @@ -48,10 +49,10 @@
   48.12  class GenCollectorPolicy;
   48.13  class TwoGenerationCollectorPolicy;
   48.14  class AdaptiveSizePolicy;
   48.15 -#ifndef SERIALGC
   48.16 +#if INCLUDE_ALL_GCS
   48.17  class ConcurrentMarkSweepPolicy;
   48.18  class G1CollectorPolicy;
   48.19 -#endif // SERIALGC
   48.20 +#endif // INCLUDE_ALL_GCS
   48.21  
   48.22  class GCPolicyCounters;
   48.23  class MarkSweepPolicy;
   48.24 @@ -134,21 +135,21 @@
   48.25    virtual GenCollectorPolicy*           as_generation_policy()            { return NULL; }
   48.26    virtual TwoGenerationCollectorPolicy* as_two_generation_policy()        { return NULL; }
   48.27    virtual MarkSweepPolicy*              as_mark_sweep_policy()            { return NULL; }
   48.28 -#ifndef SERIALGC
   48.29 +#if INCLUDE_ALL_GCS
   48.30    virtual ConcurrentMarkSweepPolicy*    as_concurrent_mark_sweep_policy() { return NULL; }
   48.31    virtual G1CollectorPolicy*            as_g1_policy()                    { return NULL; }
   48.32 -#endif // SERIALGC
   48.33 +#endif // INCLUDE_ALL_GCS
   48.34    // Note that these are not virtual.
   48.35    bool is_generation_policy()            { return as_generation_policy() != NULL; }
   48.36    bool is_two_generation_policy()        { return as_two_generation_policy() != NULL; }
   48.37    bool is_mark_sweep_policy()            { return as_mark_sweep_policy() != NULL; }
   48.38 -#ifndef SERIALGC
   48.39 +#if INCLUDE_ALL_GCS
   48.40    bool is_concurrent_mark_sweep_policy() { return as_concurrent_mark_sweep_policy() != NULL; }
   48.41    bool is_g1_policy()                    { return as_g1_policy() != NULL; }
   48.42 -#else  // SERIALGC
   48.43 +#else  // INCLUDE_ALL_GCS
   48.44    bool is_concurrent_mark_sweep_policy() { return false; }
   48.45    bool is_g1_policy()                    { return false; }
   48.46 -#endif // SERIALGC
   48.47 +#endif // INCLUDE_ALL_GCS
   48.48  
   48.49  
   48.50    virtual BarrierSet::Name barrier_set_name() = 0;

    49.1 --- a/src/share/vm/memory/freeBlockDictionary.cpp	Fri Jan 18 05:33:32 2013 -0800
    49.2 +++ b/src/share/vm/memory/freeBlockDictionary.cpp	Wed Jan 23 13:02:39 2013 -0500
    49.3 @@ -23,13 +23,15 @@
    49.4   */
    49.5  
    49.6  #include "precompiled.hpp"
    49.7 -#ifndef SERIALGC
    49.8 +#include "utilities/macros.hpp"
    49.9 +#if INCLUDE_ALL_GCS
   49.10  #include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
   49.11 -#endif // SERIALGC
   49.12 +#endif // INCLUDE_ALL_GCS
   49.13  #include "memory/freeBlockDictionary.hpp"
   49.14  #include "memory/metablock.hpp"
   49.15  #include "memory/metachunk.hpp"
   49.16  #include "runtime/thread.inline.hpp"
   49.17 +#include "utilities/macros.hpp"
   49.18  
   49.19  #ifndef PRODUCT
   49.20  template <class Chunk> Mutex* FreeBlockDictionary<Chunk>::par_lock() const {
   49.21 @@ -56,7 +58,7 @@
   49.22  template class FreeBlockDictionary<Metablock>;
   49.23  template class FreeBlockDictionary<Metachunk>;
   49.24  
   49.25 -#ifndef SERIALGC
   49.26 +#if INCLUDE_ALL_GCS
   49.27  // Explicitly instantiate for FreeChunk
   49.28  template class FreeBlockDictionary<FreeChunk>;
   49.29 -#endif // SERIALGC
   49.30 +#endif // INCLUDE_ALL_GCS

    50.1 --- a/src/share/vm/memory/freeList.cpp	Fri Jan 18 05:33:32 2013 -0800
    50.2 +++ b/src/share/vm/memory/freeList.cpp	Wed Jan 23 13:02:39 2013 -0500
    50.3 @@ -31,10 +31,11 @@
    50.4  #include "runtime/globals.hpp"
    50.5  #include "runtime/mutex.hpp"
    50.6  #include "runtime/vmThread.hpp"
    50.7 +#include "utilities/macros.hpp"
    50.8  
    50.9 -#ifndef SERIALGC
   50.10 +#if INCLUDE_ALL_GCS
   50.11  #include "gc_implementation/concurrentMarkSweep/freeChunk.hpp"
   50.12 -#endif // SERIALGC
   50.13 +#endif // INCLUDE_ALL_GCS
   50.14  
   50.15  // Free list.  A FreeList is used to access a linked list of chunks
   50.16  // of space in the heap.  The head and tail are maintained so that
   50.17 @@ -341,6 +342,6 @@
   50.18  
   50.19  template class FreeList<Metablock>;
   50.20  template class FreeList<Metachunk>;
   50.21 -#ifndef SERIALGC
   50.22 +#if INCLUDE_ALL_GCS
   50.23  template class FreeList<FreeChunk>;
   50.24 -#endif // SERIALGC
   50.25 +#endif // INCLUDE_ALL_GCS

    51.1 --- a/src/share/vm/memory/genCollectedHeap.cpp	Fri Jan 18 05:33:32 2013 -0800
    51.2 +++ b/src/share/vm/memory/genCollectedHeap.cpp	Wed Jan 23 13:02:39 2013 -0500
    51.3 @@ -51,10 +51,11 @@
    51.4  #include "services/memoryService.hpp"
    51.5  #include "utilities/vmError.hpp"
    51.6  #include "utilities/workgroup.hpp"
    51.7 -#ifndef SERIALGC
    51.8 +#include "utilities/macros.hpp"
    51.9 +#if INCLUDE_ALL_GCS
   51.10  #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
   51.11  #include "gc_implementation/concurrentMarkSweep/vmCMSOperations.hpp"
   51.12 -#endif
   51.13 +#endif // INCLUDE_ALL_GCS
   51.14  
   51.15  GenCollectedHeap* GenCollectedHeap::_gch;
   51.16  NOT_PRODUCT(size_t GenCollectedHeap::_skip_header_HeapWords = 0;)
   51.17 @@ -141,14 +142,14 @@
   51.18    }
   51.19    clear_incremental_collection_failed();
   51.20  
   51.21 -#ifndef SERIALGC
   51.22 +#if INCLUDE_ALL_GCS
   51.23    // If we are running CMS, create the collector responsible
   51.24    // for collecting the CMS generations.
   51.25    if (collector_policy()->is_concurrent_mark_sweep_policy()) {
   51.26      bool success = create_cms_collector();
   51.27      if (!success) return JNI_ENOMEM;
   51.28    }
   51.29 -#endif // SERIALGC
   51.30 +#endif // INCLUDE_ALL_GCS
   51.31  
   51.32    return JNI_OK;
   51.33  }
   51.34 @@ -686,12 +687,12 @@
   51.35  
   51.36  void GenCollectedHeap::collect(GCCause::Cause cause) {
   51.37    if (should_do_concurrent_full_gc(cause)) {
   51.38 -#ifndef SERIALGC
   51.39 +#if INCLUDE_ALL_GCS
   51.40      // mostly concurrent full collection
   51.41      collect_mostly_concurrent(cause);
   51.42 -#else  // SERIALGC
   51.43 +#else  // INCLUDE_ALL_GCS
   51.44      ShouldNotReachHere();
   51.45 -#endif // SERIALGC
   51.46 +#endif // INCLUDE_ALL_GCS
   51.47    } else {
   51.48  #ifdef ASSERT
   51.49      if (cause == GCCause::_scavenge_alot) {
   51.50 @@ -736,7 +737,7 @@
   51.51    }
   51.52  }
   51.53  
   51.54 -#ifndef SERIALGC
   51.55 +#if INCLUDE_ALL_GCS
   51.56  bool GenCollectedHeap::create_cms_collector() {
   51.57  
   51.58    assert(((_gens[1]->kind() == Generation::ConcurrentMarkSweep) ||
   51.59 @@ -772,7 +773,7 @@
   51.60      VMThread::execute(&op);
   51.61    }
   51.62  }
   51.63 -#endif // SERIALGC
   51.64 +#endif // INCLUDE_ALL_GCS
   51.65  
   51.66  void GenCollectedHeap::do_full_collection(bool clear_all_soft_refs) {
   51.67     do_full_collection(clear_all_soft_refs, _n_gens - 1);
   51.68 @@ -1116,22 +1117,22 @@
   51.69    if (workers() != NULL) {
   51.70      workers()->threads_do(tc);
   51.71    }
   51.72 -#ifndef SERIALGC
   51.73 +#if INCLUDE_ALL_GCS
   51.74    if (UseConcMarkSweepGC) {
   51.75      ConcurrentMarkSweepThread::threads_do(tc);
   51.76    }
   51.77 -#endif // SERIALGC
   51.78 +#endif // INCLUDE_ALL_GCS
   51.79  }
   51.80  
   51.81  void GenCollectedHeap::print_gc_threads_on(outputStream* st) const {
   51.82 -#ifndef SERIALGC
   51.83 +#if INCLUDE_ALL_GCS
   51.84    if (UseParNewGC) {
   51.85      workers()->print_worker_threads_on(st);
   51.86    }
   51.87    if (UseConcMarkSweepGC) {
   51.88      ConcurrentMarkSweepThread::print_all_on(st);
   51.89    }
   51.90 -#endif // SERIALGC
   51.91 +#endif // INCLUDE_ALL_GCS
   51.92  }
   51.93  
   51.94  void GenCollectedHeap::print_tracing_info() const {

    52.1 --- a/src/share/vm/memory/generationSpec.cpp	Fri Jan 18 05:33:32 2013 -0800
    52.2 +++ b/src/share/vm/memory/generationSpec.cpp	Wed Jan 23 13:02:39 2013 -0500
    52.3 @@ -30,11 +30,12 @@
    52.4  #include "memory/generationSpec.hpp"
    52.5  #include "memory/tenuredGeneration.hpp"
    52.6  #include "runtime/java.hpp"
    52.7 -#ifndef SERIALGC
    52.8 +#include "utilities/macros.hpp"
    52.9 +#if INCLUDE_ALL_GCS
   52.10  #include "gc_implementation/parNew/asParNewGeneration.hpp"
   52.11  #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
   52.12  #include "gc_implementation/parNew/parNewGeneration.hpp"
   52.13 -#endif
   52.14 +#endif // INCLUDE_ALL_GCS
   52.15  
   52.16  Generation* GenerationSpec::init(ReservedSpace rs, int level,
   52.17                                   GenRemSet* remset) {
   52.18 @@ -45,7 +46,7 @@
   52.19      case Generation::MarkSweepCompact:
   52.20        return new TenuredGeneration(rs, init_size(), level, remset);
   52.21  
   52.22 -#ifndef SERIALGC
   52.23 +#if INCLUDE_ALL_GCS
   52.24      case Generation::ParNew:
   52.25        return new ParNewGeneration(rs, init_size(), level);
   52.26  
   52.27 @@ -94,7 +95,7 @@
   52.28  
   52.29        return g;
   52.30      }
   52.31 -#endif // SERIALGC
   52.32 +#endif // INCLUDE_ALL_GCS
   52.33  
   52.34      default:
   52.35        guarantee(false, "unrecognized GenerationName");

    53.1 --- a/src/share/vm/memory/heapInspection.cpp	Fri Jan 18 05:33:32 2013 -0800
    53.2 +++ b/src/share/vm/memory/heapInspection.cpp	Wed Jan 23 13:02:39 2013 -0500
    53.3 @@ -29,9 +29,10 @@
    53.4  #include "memory/resourceArea.hpp"
    53.5  #include "runtime/os.hpp"
    53.6  #include "utilities/globalDefinitions.hpp"
    53.7 -#ifndef SERIALGC
    53.8 +#include "utilities/macros.hpp"
    53.9 +#if INCLUDE_ALL_GCS
   53.10  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
   53.11 -#endif
   53.12 +#endif // INCLUDE_ALL_GCS
   53.13  
   53.14  // HeapInspection
   53.15  

    54.1 --- a/src/share/vm/memory/heapInspection.hpp	Fri Jan 18 05:33:32 2013 -0800
    54.2 +++ b/src/share/vm/memory/heapInspection.hpp	Wed Jan 23 13:02:39 2013 -0500
    54.3 @@ -27,6 +27,7 @@
    54.4  
    54.5  #include "memory/allocation.inline.hpp"
    54.6  #include "oops/oop.inline.hpp"
    54.7 +#include "utilities/macros.hpp"
    54.8  
    54.9  #if INCLUDE_SERVICES
   54.10  

    55.1 --- a/src/share/vm/memory/space.cpp	Fri Jan 18 05:33:32 2013 -0800
    55.2 +++ b/src/share/vm/memory/space.cpp	Wed Jan 23 13:02:39 2013 -0500
    55.3 @@ -40,6 +40,7 @@
    55.4  #include "runtime/safepoint.hpp"
    55.5  #include "utilities/copy.hpp"
    55.6  #include "utilities/globalDefinitions.hpp"
    55.7 +#include "utilities/macros.hpp"
    55.8  
    55.9  void SpaceMemRegionOopsIterClosure::do_oop(oop* p)       { SpaceMemRegionOopsIterClosure::do_oop_work(p); }
   55.10  void SpaceMemRegionOopsIterClosure::do_oop(narrowOop* p) { SpaceMemRegionOopsIterClosure::do_oop_work(p); }
   55.11 @@ -658,7 +659,7 @@
   55.12    }
   55.13  }
   55.14  
   55.15 -#ifndef SERIALGC
   55.16 +#if INCLUDE_ALL_GCS
   55.17  #define ContigSpace_PAR_OOP_ITERATE_DEFN(OopClosureType, nv_suffix)         \
   55.18                                                                              \
   55.19    void ContiguousSpace::par_oop_iterate(MemRegion mr, OopClosureType* blk) {\
   55.20 @@ -673,7 +674,7 @@
   55.21    ALL_PAR_OOP_ITERATE_CLOSURES(ContigSpace_PAR_OOP_ITERATE_DEFN)
   55.22  
   55.23  #undef ContigSpace_PAR_OOP_ITERATE_DEFN
   55.24 -#endif // SERIALGC
   55.25 +#endif // INCLUDE_ALL_GCS
   55.26  
   55.27  void ContiguousSpace::oop_iterate(ExtendedOopClosure* blk) {
   55.28    if (is_empty()) return;

    56.1 --- a/src/share/vm/memory/space.hpp	Fri Jan 18 05:33:32 2013 -0800
    56.2 +++ b/src/share/vm/memory/space.hpp	Wed Jan 23 13:02:39 2013 -0500
    56.3 @@ -34,6 +34,7 @@
    56.4  #include "oops/markOop.hpp"
    56.5  #include "runtime/mutexLocker.hpp"
    56.6  #include "runtime/prefetch.hpp"
    56.7 +#include "utilities/macros.hpp"
    56.8  #include "utilities/workgroup.hpp"
    56.9  #ifdef TARGET_OS_FAMILY_linux
   56.10  # include "os_linux.inline.hpp"
   56.11 @@ -884,14 +885,14 @@
   56.12    }
   56.13  
   56.14  
   56.15 -#ifndef SERIALGC
   56.16 +#if INCLUDE_ALL_GCS
   56.17    // In support of parallel oop_iterate.
   56.18    #define ContigSpace_PAR_OOP_ITERATE_DECL(OopClosureType, nv_suffix)  \
   56.19      void par_oop_iterate(MemRegion mr, OopClosureType* blk);
   56.20  
   56.21      ALL_PAR_OOP_ITERATE_CLOSURES(ContigSpace_PAR_OOP_ITERATE_DECL)
   56.22    #undef ContigSpace_PAR_OOP_ITERATE_DECL
   56.23 -#endif // SERIALGC
   56.24 +#endif // INCLUDE_ALL_GCS
   56.25  
   56.26    // Compaction support
   56.27    virtual void reset_after_compaction() {

    57.1 --- a/src/share/vm/memory/specialized_oop_closures.hpp	Fri Jan 18 05:33:32 2013 -0800
    57.2 +++ b/src/share/vm/memory/specialized_oop_closures.hpp	Wed Jan 23 13:02:39 2013 -0500
    57.3 @@ -26,9 +26,10 @@
    57.4  #define SHARE_VM_MEMORY_SPECIALIZED_OOP_CLOSURES_HPP
    57.5  
    57.6  #include "runtime/atomic.hpp"
    57.7 -#ifndef SERIALGC
    57.8 +#include "utilities/macros.hpp"
    57.9 +#if INCLUDE_ALL_GCS
   57.10  #include "gc_implementation/g1/g1_specialized_oop_closures.hpp"
   57.11 -#endif
   57.12 +#endif // INCLUDE_ALL_GCS
   57.13  
   57.14  // The following OopClosure types get specialized versions of
   57.15  // "oop_oop_iterate" that invoke the closures' do_oop methods
   57.16 @@ -80,20 +81,20 @@
   57.17    f(FastScanClosure,_nv)                                \
   57.18    f(FilteringClosure,_nv)
   57.19  
   57.20 -#ifndef SERIALGC
   57.21 +#if INCLUDE_ALL_GCS
   57.22  #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f)       \
   57.23    f(ParScanWithBarrierClosure,_nv)                      \
   57.24    f(ParScanWithoutBarrierClosure,_nv)
   57.25 -#else  // SERIALGC
   57.26 +#else  // INCLUDE_ALL_GCS
   57.27  #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f)
   57.28 -#endif // SERIALGC
   57.29 +#endif // INCLUDE_ALL_GCS
   57.30  
   57.31  #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(f)       \
   57.32    f(NoHeaderExtendedOopClosure,_nv)                     \
   57.33    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_S(f)             \
   57.34    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f)
   57.35  
   57.36 -#ifndef SERIALGC
   57.37 +#if INCLUDE_ALL_GCS
   57.38  #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f)       \
   57.39    f(MarkRefsIntoAndScanClosure,_nv)                     \
   57.40    f(Par_MarkRefsIntoAndScanClosure,_nv)                 \
   57.41 @@ -104,9 +105,9 @@
   57.42    f(CMSKeepAliveClosure,_nv)                            \
   57.43    f(CMSInnerParMarkAndPushClosure,_nv)                  \
   57.44    FURTHER_SPECIALIZED_OOP_OOP_ITERATE_CLOSURES(f)
   57.45 -#else  // SERIALGC
   57.46 +#else  // INCLUDE_ALL_GCS
   57.47  #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f)
   57.48 -#endif // SERIALGC
   57.49 +#endif // INCLUDE_ALL_GCS
   57.50  
   57.51  
   57.52  // We separate these out, because sometime the general one has
   57.53 @@ -120,7 +121,7 @@
   57.54  #define ALL_OOP_OOP_ITERATE_CLOSURES_2(f)               \
   57.55    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f)
   57.56  
   57.57 -#ifndef SERIALGC
   57.58 +#if INCLUDE_ALL_GCS
   57.59  // This macro applies an argument macro to all OopClosures for which we
   57.60  // want specialized bodies of a family of methods related to
   57.61  // "par_oop_iterate".  The arguments to f are the same as above.
   57.62 @@ -136,7 +137,7 @@
   57.63  #define ALL_PAR_OOP_ITERATE_CLOSURES(f)                \
   57.64    f(ExtendedOopClosure,_v)                             \
   57.65    SPECIALIZED_PAR_OOP_ITERATE_CLOSURES(f)
   57.66 -#endif // SERIALGC
   57.67 +#endif // INCLUDE_ALL_GCS
   57.68  
   57.69  // This macro applies an argument macro to all OopClosures for which we
   57.70  // want specialized bodies of a family of methods related to
   57.71 @@ -155,14 +156,14 @@
   57.72    f(ScanClosure,_nv)                                     \
   57.73    f(FastScanClosure,_nv)
   57.74  
   57.75 -#ifndef SERIALGC
   57.76 +#if INCLUDE_ALL_GCS
   57.77  #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_P(f) \
   57.78    f(ParScanWithBarrierClosure,_nv)                       \
   57.79    f(ParScanWithoutBarrierClosure,_nv)                    \
   57.80    FURTHER_SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES(f)
   57.81 -#else  // SERIALGC
   57.82 +#else  // INCLUDE_ALL_GCS
   57.83  #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_P(f)
   57.84 -#endif // SERIALGC
   57.85 +#endif // INCLUDE_ALL_GCS
   57.86  
   57.87  #define SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG(f)  \
   57.88    SPECIALIZED_SINCE_SAVE_MARKS_CLOSURES_YOUNG_S(f)      \

    58.1 --- a/src/share/vm/memory/tenuredGeneration.cpp	Fri Jan 18 05:33:32 2013 -0800
    58.2 +++ b/src/share/vm/memory/tenuredGeneration.cpp	Wed Jan 23 13:02:39 2013 -0500
    58.3 @@ -33,6 +33,7 @@
    58.4  #include "memory/tenuredGeneration.hpp"
    58.5  #include "oops/oop.inline.hpp"
    58.6  #include "runtime/java.hpp"
    58.7 +#include "utilities/macros.hpp"
    58.8  
    58.9  TenuredGeneration::TenuredGeneration(ReservedSpace rs,
   58.10                                       size_t initial_byte_size, int level,
   58.11 @@ -61,7 +62,7 @@
   58.12    _space_counters = new CSpaceCounters(gen_name, 0,
   58.13                                         _virtual_space.reserved_size(),
   58.14                                         _the_space, _gen_counters);
   58.15 -#ifndef SERIALGC
   58.16 +#if INCLUDE_ALL_GCS
   58.17    if (UseParNewGC) {
   58.18      typedef ParGCAllocBufferWithBOT* ParGCAllocBufferWithBOTPtr;
   58.19      _alloc_buffers = NEW_C_HEAP_ARRAY(ParGCAllocBufferWithBOTPtr,
   58.20 @@ -77,7 +78,7 @@
   58.21    } else {
   58.22      _alloc_buffers = NULL;
   58.23    }
   58.24 -#endif // SERIALGC
   58.25 +#endif // INCLUDE_ALL_GCS
   58.26  }
   58.27  
   58.28  
   58.29 @@ -339,7 +340,7 @@
   58.30  }
   58.31  
   58.32  
   58.33 -#ifndef SERIALGC
   58.34 +#if INCLUDE_ALL_GCS
   58.35  oop TenuredGeneration::par_promote(int thread_num,
   58.36                                     oop old, markOop m, size_t word_sz) {
   58.37  
   58.38 @@ -423,10 +424,10 @@
   58.39    }
   58.40  }
   58.41  
   58.42 -#else  // SERIALGC
   58.43 +#else  // INCLUDE_ALL_GCS
   58.44  void TenuredGeneration::retire_alloc_buffers_before_full_gc() {}
   58.45  void TenuredGeneration::verify_alloc_buffers_clean() {}
   58.46 -#endif // SERIALGC
   58.47 +#endif // INCLUDE_ALL_GCS
   58.48  
   58.49  bool TenuredGeneration::promotion_attempt_is_safe(size_t max_promotion_in_bytes) const {
   58.50    size_t available = max_contiguous_available();

    59.1 --- a/src/share/vm/memory/tenuredGeneration.hpp	Fri Jan 18 05:33:32 2013 -0800
    59.2 +++ b/src/share/vm/memory/tenuredGeneration.hpp	Wed Jan 23 13:02:39 2013 -0500
    59.3 @@ -29,6 +29,7 @@
    59.4  #include "gc_implementation/shared/gcStats.hpp"
    59.5  #include "gc_implementation/shared/generationCounters.hpp"
    59.6  #include "memory/generation.hpp"
    59.7 +#include "utilities/macros.hpp"
    59.8  
    59.9  // TenuredGeneration models the heap containing old (promoted/tenured) objects.
   59.10  
   59.11 @@ -45,11 +46,11 @@
   59.12    size_t _capacity_at_prologue;
   59.13    size_t _used_at_prologue;
   59.14  
   59.15 -#ifndef SERIALGC
   59.16 +#if INCLUDE_ALL_GCS
   59.17    // To support parallel promotion: an array of parallel allocation
   59.18    // buffers, one per thread, initially NULL.
   59.19    ParGCAllocBufferWithBOT** _alloc_buffers;
   59.20 -#endif // SERIALGC
   59.21 +#endif // INCLUDE_ALL_GCS
   59.22  
   59.23    // Retire all alloc buffers before a full GC, so that they will be
   59.24    // re-allocated at the start of the next young GC.
   59.25 @@ -93,14 +94,14 @@
   59.26                         size_t size,
   59.27                         bool is_tlab);
   59.28  
   59.29 -#ifndef SERIALGC
   59.30 +#if INCLUDE_ALL_GCS
   59.31    // Overrides.
   59.32    virtual oop par_promote(int thread_num,
   59.33                            oop obj, markOop m, size_t word_sz);
   59.34    virtual void par_promote_alloc_undo(int thread_num,
   59.35                                        HeapWord* obj, size_t word_sz);
   59.36    virtual void par_promote_alloc_done(int thread_num);
   59.37 -#endif // SERIALGC
   59.38 +#endif // INCLUDE_ALL_GCS
   59.39  
   59.40    // Performance Counter support
   59.41    void update_counters();

    60.1 --- a/src/share/vm/memory/universe.cpp	Fri Jan 18 05:33:32 2013 -0800
    60.2 +++ b/src/share/vm/memory/universe.cpp	Wed Jan 23 13:02:39 2013 -0500
    60.3 @@ -70,13 +70,14 @@
    60.4  #include "utilities/events.hpp"
    60.5  #include "utilities/hashtable.inline.hpp"
    60.6  #include "utilities/preserveException.hpp"
    60.7 -#ifndef SERIALGC
    60.8 +#include "utilities/macros.hpp"
    60.9 +#if INCLUDE_ALL_GCS
   60.10  #include "gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp"
   60.11  #include "gc_implementation/concurrentMarkSweep/cmsCollectorPolicy.hpp"
   60.12  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   60.13  #include "gc_implementation/g1/g1CollectorPolicy.hpp"
   60.14  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
   60.15 -#endif
   60.16 +#endif // INCLUDE_ALL_GCS
   60.17  
   60.18  // Known objects
   60.19  Klass* Universe::_boolArrayKlassObj                 = NULL;
   60.20 @@ -740,20 +741,20 @@
   60.21  jint Universe::initialize_heap() {
   60.22  
   60.23    if (UseParallelGC) {
   60.24 -#ifndef SERIALGC
   60.25 +#if INCLUDE_ALL_GCS
   60.26      Universe::_collectedHeap = new ParallelScavengeHeap();
   60.27 -#else  // SERIALGC
   60.28 +#else  // INCLUDE_ALL_GCS
   60.29      fatal("UseParallelGC not supported in this VM.");
   60.30 -#endif // SERIALGC
   60.31 +#endif // INCLUDE_ALL_GCS
   60.32  
   60.33    } else if (UseG1GC) {
   60.34 -#ifndef SERIALGC
   60.35 +#if INCLUDE_ALL_GCS
   60.36      G1CollectorPolicy* g1p = new G1CollectorPolicy();
   60.37      G1CollectedHeap* g1h = new G1CollectedHeap(g1p);
   60.38      Universe::_collectedHeap = g1h;
   60.39 -#else  // SERIALGC
   60.40 +#else  // INCLUDE_ALL_GCS
   60.41      fatal("UseG1GC not supported in java kernel vm.");
   60.42 -#endif // SERIALGC
   60.43 +#endif // INCLUDE_ALL_GCS
   60.44  
   60.45    } else {
   60.46      GenCollectorPolicy *gc_policy;
   60.47 @@ -761,15 +762,15 @@
   60.48      if (UseSerialGC) {
   60.49        gc_policy = new MarkSweepPolicy();
   60.50      } else if (UseConcMarkSweepGC) {
   60.51 -#ifndef SERIALGC
   60.52 +#if INCLUDE_ALL_GCS
   60.53        if (UseAdaptiveSizePolicy) {
   60.54          gc_policy = new ASConcurrentMarkSweepPolicy();
   60.55        } else {
   60.56          gc_policy = new ConcurrentMarkSweepPolicy();
   60.57        }
   60.58 -#else   // SERIALGC
   60.59 +#else  // INCLUDE_ALL_GCS
   60.60      fatal("UseConcMarkSweepGC not supported in this VM.");
   60.61 -#endif // SERIALGC
   60.62 +#endif // INCLUDE_ALL_GCS
   60.63      } else { // default old generation
   60.64        gc_policy = new MarkSweepPolicy();
   60.65      }

    61.1 --- a/src/share/vm/oops/cpCache.cpp	Fri Jan 18 05:33:32 2013 -0800
    61.2 +++ b/src/share/vm/oops/cpCache.cpp	Wed Jan 23 13:02:39 2013 -0500
    61.3 @@ -33,9 +33,10 @@
    61.4  #include "prims/jvmtiRedefineClassesTrace.hpp"
    61.5  #include "prims/methodHandles.hpp"
    61.6  #include "runtime/handles.inline.hpp"
    61.7 -#ifndef SERIALGC
    61.8 +#include "utilities/macros.hpp"
    61.9 +#if INCLUDE_ALL_GCS
   61.10  # include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
   61.11 -#endif
   61.12 +#endif // INCLUDE_ALL_GCS
   61.13  
   61.14  
   61.15  // Implememtation of ConstantPoolCacheEntry

    62.1 --- a/src/share/vm/oops/instanceClassLoaderKlass.cpp	Fri Jan 18 05:33:32 2013 -0800
    62.2 +++ b/src/share/vm/oops/instanceClassLoaderKlass.cpp	Wed Jan 23 13:02:39 2013 -0500
    62.3 @@ -36,12 +36,13 @@
    62.4  #include "oops/oop.inline.hpp"
    62.5  #include "oops/symbol.hpp"
    62.6  #include "runtime/handles.inline.hpp"
    62.7 -#ifndef SERIALGC
    62.8 +#include "utilities/macros.hpp"
    62.9 +#if INCLUDE_ALL_GCS
   62.10  #include "gc_implementation/parNew/parOopClosures.inline.hpp"
   62.11  #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
   62.12  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   62.13  #include "oops/oop.pcgc.inline.hpp"
   62.14 -#endif
   62.15 +#endif // INCLUDE_ALL_GCS
   62.16  
   62.17  #define if_do_metadata_checked(closure, nv_suffix)                    \
   62.18    /* Make sure the non-virtual and the virtual versions match. */     \
   62.19 @@ -73,7 +74,7 @@
   62.20    return size;                                                                  \
   62.21  }
   62.22  
   62.23 -#ifndef SERIALGC
   62.24 +#if INCLUDE_ALL_GCS
   62.25  #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   62.26                                                                                  \
   62.27  int InstanceClassLoaderKlass::                                                  \
   62.28 @@ -83,7 +84,7 @@
   62.29    int size = InstanceKlass::oop_oop_iterate_backwards##nv_suffix(obj, closure); \
   62.30    return size;                                                                  \
   62.31  }
   62.32 -#endif // !SERIALGC
   62.33 +#endif // INCLUDE_ALL_GCS
   62.34  
   62.35  
   62.36  #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)      \
   62.37 @@ -111,10 +112,10 @@
   62.38  
   62.39  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN)
   62.40  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN)
   62.41 -#ifndef SERIALGC
   62.42 +#if INCLUDE_ALL_GCS
   62.43  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   62.44  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   62.45 -#endif // SERIALGC
   62.46 +#endif // INCLUDE_ALL_GCS
   62.47  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m)
   62.48  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DEFN_m)
   62.49  
   62.50 @@ -129,7 +130,7 @@
   62.51    }
   62.52  }
   62.53  
   62.54 -#ifndef SERIALGC
   62.55 +#if INCLUDE_ALL_GCS
   62.56  void InstanceClassLoaderKlass::oop_follow_contents(ParCompactionManager* cm,
   62.57          oop obj) {
   62.58    InstanceKlass::oop_follow_contents(cm, obj);
   62.59 @@ -155,5 +156,5 @@
   62.60    }
   62.61    return size_helper();
   62.62  }
   62.63 -#endif // SERIALGC
   62.64 +#endif // INCLUDE_ALL_GCS
   62.65  

    63.1 --- a/src/share/vm/oops/instanceClassLoaderKlass.hpp	Fri Jan 18 05:33:32 2013 -0800
    63.2 +++ b/src/share/vm/oops/instanceClassLoaderKlass.hpp	Wed Jan 23 13:02:39 2013 -0500
    63.3 @@ -26,6 +26,7 @@
    63.4  #define SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_HPP
    63.5  
    63.6  #include "oops/instanceKlass.hpp"
    63.7 +#include "utilities/macros.hpp"
    63.8  
    63.9  // An InstanceClassLoaderKlass is a specialization of the InstanceKlass. It does
   63.10  // not add any field.  It is added to walk the dependencies for the class loader
   63.11 @@ -61,13 +62,13 @@
   63.12    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DECL)
   63.13    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_DECL)
   63.14  
   63.15 -#ifndef SERIALGC
   63.16 +#if INCLUDE_ALL_GCS
   63.17  #define InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)      \
   63.18    int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);
   63.19  
   63.20    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   63.21    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceClassLoaderKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   63.22 -#endif // !SERIALGC
   63.23 +#endif // INCLUDE_ALL_GCS
   63.24  
   63.25      // Garbage collection
   63.26    void oop_follow_contents(oop obj);

    64.1 --- a/src/share/vm/oops/instanceKlass.cpp	Fri Jan 18 05:33:32 2013 -0800
    64.2 +++ b/src/share/vm/oops/instanceKlass.cpp	Wed Jan 23 13:02:39 2013 -0500
    64.3 @@ -55,7 +55,8 @@
    64.4  #include "runtime/thread.inline.hpp"
    64.5  #include "services/threadService.hpp"
    64.6  #include "utilities/dtrace.hpp"
    64.7 -#ifndef SERIALGC
    64.8 +#include "utilities/macros.hpp"
    64.9 +#if INCLUDE_ALL_GCS
   64.10  #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
   64.11  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   64.12  #include "gc_implementation/g1/g1OopClosures.inline.hpp"
   64.13 @@ -66,7 +67,7 @@
   64.14  #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
   64.15  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   64.16  #include "oops/oop.pcgc.inline.hpp"
   64.17 -#endif
   64.18 +#endif // INCLUDE_ALL_GCS
   64.19  #ifdef COMPILER1
   64.20  #include "c1/c1_Compiler.hpp"
   64.21  #endif
   64.22 @@ -2042,7 +2043,7 @@
   64.23      assert_is_in_closed_subset)
   64.24  }
   64.25  
   64.26 -#ifndef SERIALGC
   64.27 +#if INCLUDE_ALL_GCS
   64.28  void InstanceKlass::oop_follow_contents(ParCompactionManager* cm,
   64.29                                          oop obj) {
   64.30    assert(obj != NULL, "can't follow the content of NULL object");
   64.31 @@ -2054,7 +2055,7 @@
   64.32      PSParallelCompact::mark_and_push(cm, p), \
   64.33      assert_is_in)
   64.34  }
   64.35 -#endif // SERIALGC
   64.36 +#endif // INCLUDE_ALL_GCS
   64.37  
   64.38  // closure's do_metadata() method dictates whether the given closure should be
   64.39  // applied to the klass ptr in the object header.
   64.40 @@ -2082,7 +2083,7 @@
   64.41    return size_helper();                                                 \
   64.42  }
   64.43  
   64.44 -#ifndef SERIALGC
   64.45 +#if INCLUDE_ALL_GCS
   64.46  #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   64.47                                                                                  \
   64.48  int InstanceKlass::oop_oop_iterate_backwards##nv_suffix(oop obj,                \
   64.49 @@ -2100,7 +2101,7 @@
   64.50      assert_is_in_closed_subset)                                                 \
   64.51     return size_helper();                                                        \
   64.52  }
   64.53 -#endif // !SERIALGC
   64.54 +#endif // INCLUDE_ALL_GCS
   64.55  
   64.56  #define InstanceKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix) \
   64.57                                                                          \
   64.58 @@ -2124,10 +2125,10 @@
   64.59  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN)
   64.60  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
   64.61  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DEFN_m)
   64.62 -#ifndef SERIALGC
   64.63 +#if INCLUDE_ALL_GCS
   64.64  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   64.65  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   64.66 -#endif // !SERIALGC
   64.67 +#endif // INCLUDE_ALL_GCS
   64.68  
   64.69  int InstanceKlass::oop_adjust_pointers(oop obj) {
   64.70    int size = size_helper();
   64.71 @@ -2139,7 +2140,7 @@
   64.72    return size;
   64.73  }
   64.74  
   64.75 -#ifndef SERIALGC
   64.76 +#if INCLUDE_ALL_GCS
   64.77  void InstanceKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   64.78    InstanceKlass_OOP_MAP_REVERSE_ITERATE( \
   64.79      obj, \
   64.80 @@ -2159,7 +2160,7 @@
   64.81    return size;
   64.82  }
   64.83  
   64.84 -#endif // SERIALGC
   64.85 +#endif // INCLUDE_ALL_GCS
   64.86  
   64.87  void InstanceKlass::clean_implementors_list(BoolObjectClosure* is_alive) {
   64.88    assert(is_loader_alive(is_alive), "this klass should be live");

    65.1 --- a/src/share/vm/oops/instanceKlass.hpp	Fri Jan 18 05:33:32 2013 -0800
    65.2 +++ b/src/share/vm/oops/instanceKlass.hpp	Wed Jan 23 13:02:39 2013 -0500
    65.3 @@ -36,6 +36,7 @@
    65.4  #include "runtime/os.hpp"
    65.5  #include "utilities/accessFlags.hpp"
    65.6  #include "utilities/bitMap.inline.hpp"
    65.7 +#include "utilities/macros.hpp"
    65.8  
    65.9  // An InstanceKlass is the VM level representation of a Java class.
   65.10  // It contains all information needed for at class at execution runtime.
   65.11 @@ -932,13 +933,13 @@
   65.12    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_DECL)
   65.13    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_DECL)
   65.14  
   65.15 -#ifndef SERIALGC
   65.16 +#if INCLUDE_ALL_GCS
   65.17  #define InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
   65.18    int  oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);
   65.19  
   65.20    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   65.21    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   65.22 -#endif // !SERIALGC
   65.23 +#endif // INCLUDE_ALL_GCS
   65.24  
   65.25    u2 idnum_allocated_count() const      { return _idnum_allocated_count; }
   65.26  private:

    66.1 --- a/src/share/vm/oops/instanceMirrorKlass.cpp	Fri Jan 18 05:33:32 2013 -0800
    66.2 +++ b/src/share/vm/oops/instanceMirrorKlass.cpp	Wed Jan 23 13:02:39 2013 -0500
    66.3 @@ -35,7 +35,8 @@
    66.4  #include "oops/oop.inline.hpp"
    66.5  #include "oops/symbol.hpp"
    66.6  #include "runtime/handles.inline.hpp"
    66.7 -#ifndef SERIALGC
    66.8 +#include "utilities/macros.hpp"
    66.9 +#if INCLUDE_ALL_GCS
   66.10  #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
   66.11  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   66.12  #include "gc_implementation/g1/g1OopClosures.inline.hpp"
   66.13 @@ -45,7 +46,7 @@
   66.14  #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
   66.15  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   66.16  #include "oops/oop.pcgc.inline.hpp"
   66.17 -#endif
   66.18 +#endif // INCLUDE_ALL_GCS
   66.19  
   66.20  int InstanceMirrorKlass::_offset_of_static_fields = 0;
   66.21  
   66.22 @@ -168,7 +169,7 @@
   66.23      assert_is_in_closed_subset)
   66.24  }
   66.25  
   66.26 -#ifndef SERIALGC
   66.27 +#if INCLUDE_ALL_GCS
   66.28  void InstanceMirrorKlass::oop_follow_contents(ParCompactionManager* cm,
   66.29                                                oop obj) {
   66.30    InstanceKlass::oop_follow_contents(cm, obj);
   66.31 @@ -189,7 +190,7 @@
   66.32      PSParallelCompact::mark_and_push(cm, p),                                          \
   66.33      assert_is_in)
   66.34  }
   66.35 -#endif // SERIALGC
   66.36 +#endif // INCLUDE_ALL_GCS
   66.37  
   66.38  int InstanceMirrorKlass::oop_adjust_pointers(oop obj) {
   66.39    int size = oop_size(obj);
   66.40 @@ -262,7 +263,7 @@
   66.41    }                                                                                   \
   66.42  }
   66.43  
   66.44 -#ifndef SERIALGC
   66.45 +#if INCLUDE_ALL_GCS
   66.46  #define InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   66.47                                                                                        \
   66.48  int InstanceMirrorKlass::                                                             \
   66.49 @@ -278,7 +279,7 @@
   66.50      InstanceMirrorKlass_SPECIALIZED_OOP_ITERATE_DEFN(oop, nv_suffix);                 \
   66.51    }                                                                                   \
   66.52  }
   66.53 -#endif // !SERIALGC
   66.54 +#endif // INCLUDE_ALL_GCS
   66.55  
   66.56  
   66.57  #define InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)         \
   66.58 @@ -310,14 +311,14 @@
   66.59  
   66.60  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN)
   66.61  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN)
   66.62 -#ifndef SERIALGC
   66.63 +#if INCLUDE_ALL_GCS
   66.64  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   66.65  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   66.66 -#endif // SERIALGC
   66.67 +#endif // INCLUDE_ALL_GCS
   66.68  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m)
   66.69  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DEFN_m)
   66.70  
   66.71 -#ifndef SERIALGC
   66.72 +#if INCLUDE_ALL_GCS
   66.73  void InstanceMirrorKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   66.74    // Note that we don't have to follow the mirror -> klass pointer, since all
   66.75    // klasses that are dirty will be scavenged when we iterate over the
   66.76 @@ -353,7 +354,7 @@
   66.77      assert_nothing)
   66.78    return size;
   66.79  }
   66.80 -#endif // SERIALGC
   66.81 +#endif // INCLUDE_ALL_GCS
   66.82  
   66.83  int InstanceMirrorKlass::instance_size(KlassHandle k) {
   66.84    if (k() != NULL && k->oop_is_instance()) {

    67.1 --- a/src/share/vm/oops/instanceMirrorKlass.hpp	Fri Jan 18 05:33:32 2013 -0800
    67.2 +++ b/src/share/vm/oops/instanceMirrorKlass.hpp	Wed Jan 23 13:02:39 2013 -0500
    67.3 @@ -28,6 +28,7 @@
    67.4  #include "classfile/systemDictionary.hpp"
    67.5  #include "oops/instanceKlass.hpp"
    67.6  #include "runtime/handles.hpp"
    67.7 +#include "utilities/macros.hpp"
    67.8  
    67.9  // An InstanceMirrorKlass is a specialized InstanceKlass for
   67.10  // java.lang.Class instances.  These instances are special because
   67.11 @@ -107,13 +108,13 @@
   67.12    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_DECL)
   67.13    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_DECL)
   67.14  
   67.15 -#ifndef SERIALGC
   67.16 +#if INCLUDE_ALL_GCS
   67.17  #define InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
   67.18    int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);
   67.19  
   67.20    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   67.21    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceMirrorKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   67.22 -#endif // !SERIALGC
   67.23 +#endif // INCLUDE_ALL_GCS
   67.24  };
   67.25  
   67.26  #endif // SHARE_VM_OOPS_INSTANCEMIRRORKLASS_HPP

    68.1 --- a/src/share/vm/oops/instanceRefKlass.cpp	Fri Jan 18 05:33:32 2013 -0800
    68.2 +++ b/src/share/vm/oops/instanceRefKlass.cpp	Wed Jan 23 13:02:39 2013 -0500
    68.3 @@ -33,7 +33,8 @@
    68.4  #include "oops/instanceRefKlass.hpp"
    68.5  #include "oops/oop.inline.hpp"
    68.6  #include "utilities/preserveException.hpp"
    68.7 -#ifndef SERIALGC
    68.8 +#include "utilities/macros.hpp"
    68.9 +#if INCLUDE_ALL_GCS
   68.10  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   68.11  #include "gc_implementation/g1/g1OopClosures.inline.hpp"
   68.12  #include "gc_implementation/g1/g1RemSet.inline.hpp"
   68.13 @@ -42,7 +43,7 @@
   68.14  #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
   68.15  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   68.16  #include "oops/oop.pcgc.inline.hpp"
   68.17 -#endif
   68.18 +#endif // INCLUDE_ALL_GCS
   68.19  
   68.20  template <class T>
   68.21  void specialized_oop_follow_contents(InstanceRefKlass* ref, oop obj) {
   68.22 @@ -120,7 +121,7 @@
   68.23    }
   68.24  }
   68.25  
   68.26 -#ifndef SERIALGC
   68.27 +#if INCLUDE_ALL_GCS
   68.28  template <class T>
   68.29  void specialized_oop_follow_contents(InstanceRefKlass* ref,
   68.30                                       ParCompactionManager* cm,
   68.31 @@ -194,7 +195,7 @@
   68.32      specialized_oop_follow_contents<oop>(this, cm, obj);
   68.33    }
   68.34  }
   68.35 -#endif // SERIALGC
   68.36 +#endif // INCLUDE_ALL_GCS
   68.37  
   68.38  #ifdef ASSERT
   68.39  template <class T> void trace_reference_gc(const char *s, oop obj,
   68.40 @@ -317,7 +318,7 @@
   68.41    }                                                                             \
   68.42  }
   68.43  
   68.44 -#ifndef SERIALGC
   68.45 +#if INCLUDE_ALL_GCS
   68.46  #define InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
   68.47                                                                                  \
   68.48  int InstanceRefKlass::                                                          \
   68.49 @@ -333,7 +334,7 @@
   68.50      InstanceRefKlass_SPECIALIZED_OOP_ITERATE(oop, nv_suffix, contains);         \
   68.51    }                                                                             \
   68.52  }
   68.53 -#endif // !SERIALGC
   68.54 +#endif // INCLUDE_ALL_GCS
   68.55  
   68.56  
   68.57  #define InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m(OopClosureType, nv_suffix)      \
   68.58 @@ -354,14 +355,14 @@
   68.59  
   68.60  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
   68.61  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN)
   68.62 -#ifndef SERIALGC
   68.63 +#if INCLUDE_ALL_GCS
   68.64  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   68.65  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DEFN)
   68.66 -#endif // SERIALGC
   68.67 +#endif // INCLUDE_ALL_GCS
   68.68  ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
   68.69  ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DEFN_m)
   68.70  
   68.71 -#ifndef SERIALGC
   68.72 +#if INCLUDE_ALL_GCS
   68.73  template <class T>
   68.74  void specialized_oop_push_contents(InstanceRefKlass *ref,
   68.75                                     PSPromotionManager* pm, oop obj) {
   68.76 @@ -444,7 +445,7 @@
   68.77    }
   68.78    return size_helper();
   68.79  }
   68.80 -#endif // SERIALGC
   68.81 +#endif // INCLUDE_ALL_GCS
   68.82  
   68.83  void InstanceRefKlass::update_nonstatic_oop_maps(Klass* k) {
   68.84    // Clear the nonstatic oop-map entries corresponding to referent

    69.1 --- a/src/share/vm/oops/instanceRefKlass.hpp	Fri Jan 18 05:33:32 2013 -0800
    69.2 +++ b/src/share/vm/oops/instanceRefKlass.hpp	Wed Jan 23 13:02:39 2013 -0500
    69.3 @@ -26,6 +26,7 @@
    69.4  #define SHARE_VM_OOPS_INSTANCEREFKLASS_HPP
    69.5  
    69.6  #include "oops/instanceKlass.hpp"
    69.7 +#include "utilities/macros.hpp"
    69.8  
    69.9  // An InstanceRefKlass is a specialized InstanceKlass for Java
   69.10  // classes that are subclasses of java/lang/ref/Reference.
   69.11 @@ -83,13 +84,13 @@
   69.12    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_DECL)
   69.13    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_DECL)
   69.14  
   69.15 -#ifndef SERIALGC
   69.16 +#if INCLUDE_ALL_GCS
   69.17  #define InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)      \
   69.18    int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* blk);
   69.19  
   69.20    ALL_OOP_OOP_ITERATE_CLOSURES_1(InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   69.21    ALL_OOP_OOP_ITERATE_CLOSURES_2(InstanceRefKlass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   69.22 -#endif // !SERIALGC
   69.23 +#endif // INCLUDE_ALL_GCS
   69.24  
   69.25    static void release_and_notify_pending_list_lock(BasicLock *pending_list_basic_lock);
   69.26    static void acquire_pending_list_lock(BasicLock *pending_list_basic_lock);

    70.1 --- a/src/share/vm/oops/klass.cpp	Fri Jan 18 05:33:32 2013 -0800
    70.2 +++ b/src/share/vm/oops/klass.cpp	Wed Jan 23 13:02:39 2013 -0500
    70.3 @@ -37,11 +37,12 @@
    70.4  #include "oops/oop.inline2.hpp"
    70.5  #include "runtime/atomic.hpp"
    70.6  #include "utilities/stack.hpp"
    70.7 -#ifndef SERIALGC
    70.8 +#include "utilities/macros.hpp"
    70.9 +#if INCLUDE_ALL_GCS
   70.10  #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
   70.11  #include "gc_implementation/parallelScavenge/psPromotionManager.hpp"
   70.12  #include "gc_implementation/parallelScavenge/psScavenge.hpp"
   70.13 -#endif
   70.14 +#endif // INCLUDE_ALL_GCS
   70.15  
   70.16  void Klass::set_name(Symbol* n) {
   70.17    _name = n;

    71.1 --- a/src/share/vm/oops/klass.hpp	Fri Jan 18 05:33:32 2013 -0800
    71.2 +++ b/src/share/vm/oops/klass.hpp	Wed Jan 23 13:02:39 2013 -0500
    71.3 @@ -35,11 +35,12 @@
    71.4  #include "runtime/orderAccess.hpp"
    71.5  #include "trace/traceMacros.hpp"
    71.6  #include "utilities/accessFlags.hpp"
    71.7 -#ifndef SERIALGC
    71.8 +#include "utilities/macros.hpp"
    71.9 +#if INCLUDE_ALL_GCS
   71.10  #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp"
   71.11  #include "gc_implementation/g1/g1OopClosures.hpp"
   71.12  #include "gc_implementation/parNew/parOopClosures.hpp"
   71.13 -#endif
   71.14 +#endif // INCLUDE_ALL_GCS
   71.15  
   71.16  //
   71.17  // A Klass provides:
   71.18 @@ -625,13 +626,13 @@
   71.19      return oop_oop_iterate(obj, blk);
   71.20    }
   71.21  
   71.22 -#ifndef SERIALGC
   71.23 +#if INCLUDE_ALL_GCS
   71.24    // In case we don't have a specialized backward scanner use forward
   71.25    // iteration.
   71.26    virtual int oop_oop_iterate_backwards_v(oop obj, ExtendedOopClosure* blk) {
   71.27      return oop_oop_iterate_v(obj, blk);
   71.28    }
   71.29 -#endif // !SERIALGC
   71.30 +#endif // INCLUDE_ALL_GCS
   71.31  
   71.32    // Iterates "blk" over all the oops in "obj" (of type "this") within "mr".
   71.33    // (I don't see why the _m should be required, but without it the Solaris
   71.34 @@ -663,7 +664,7 @@
   71.35    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL)
   71.36    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL)
   71.37  
   71.38 -#ifndef SERIALGC
   71.39 +#if INCLUDE_ALL_GCS
   71.40  #define Klass_OOP_OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)      \
   71.41    virtual int oop_oop_iterate_backwards##nv_suffix(oop obj,                  \
   71.42                                                     OopClosureType* blk) {    \
   71.43 @@ -673,7 +674,7 @@
   71.44  
   71.45    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   71.46    SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_BACKWARDS_DECL)
   71.47 -#endif // !SERIALGC
   71.48 +#endif // INCLUDE_ALL_GCS
   71.49  
   71.50    virtual void array_klasses_do(void f(Klass* k)) {}
   71.51    virtual void with_array_klasses_do(void f(Klass* k));

    72.1 --- a/src/share/vm/oops/klassPS.hpp	Fri Jan 18 05:33:32 2013 -0800
    72.2 +++ b/src/share/vm/oops/klassPS.hpp	Wed Jan 23 13:02:39 2013 -0500
    72.3 @@ -27,7 +27,9 @@
    72.4  
    72.5    // Expands to Parallel Scavenge and Parallel Old declarations
    72.6  
    72.7 -#ifndef SERIALGC
    72.8 +#include "utilities/macros.hpp"
    72.9 +
   72.10 +#if INCLUDE_ALL_GCS
   72.11  #define PARALLEL_GC_DECLS \
   72.12    virtual void oop_push_contents(PSPromotionManager* pm, oop obj);          \
   72.13    /* Parallel Old GC support                                                \
   72.14 @@ -44,9 +46,9 @@
   72.15    virtual void oop_push_contents(PSPromotionManager* pm, oop obj) = 0;      \
   72.16    virtual void oop_follow_contents(ParCompactionManager* cm, oop obj) = 0;  \
   72.17    virtual int  oop_update_pointers(ParCompactionManager* cm, oop obj) = 0;
   72.18 -#else  // SERIALGC
   72.19 +#else  // INCLUDE_ALL_GCS
   72.20  #define PARALLEL_GC_DECLS
   72.21  #define PARALLEL_GC_DECLS_PV
   72.22 -#endif // SERIALGC
   72.23 +#endif // INCLUDE_ALL_GCS
   72.24  
   72.25  #endif // SHARE_VM_OOPS_KLASSPS_HPP

    73.1 --- a/src/share/vm/oops/objArrayKlass.cpp	Fri Jan 18 05:33:32 2013 -0800
    73.2 +++ b/src/share/vm/oops/objArrayKlass.cpp	Wed Jan 23 13:02:39 2013 -0500
    73.3 @@ -43,7 +43,8 @@
    73.4  #include "runtime/handles.inline.hpp"
    73.5  #include "runtime/mutexLocker.hpp"
    73.6  #include "utilities/copy.hpp"
    73.7 -#ifndef SERIALGC
    73.8 +#include "utilities/macros.hpp"
    73.9 +#if INCLUDE_ALL_GCS
   73.10  #include "gc_implementation/concurrentMarkSweep/cmsOopClosures.inline.hpp"
   73.11  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   73.12  #include "gc_implementation/g1/g1OopClosures.inline.hpp"
   73.13 @@ -54,7 +55,7 @@
   73.14  #include "gc_implementation/parallelScavenge/psPromotionManager.inline.hpp"
   73.15  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   73.16  #include "oops/oop.pcgc.inline.hpp"
   73.17 -#endif
   73.18 +#endif // INCLUDE_ALL_GCS
   73.19  
   73.20  ObjArrayKlass* ObjArrayKlass::allocate(ClassLoaderData* loader_data, int n, KlassHandle klass_handle, Symbol* name, TRAPS) {
   73.21    assert(ObjArrayKlass::header_size() <= InstanceKlass::header_size(),
   73.22 @@ -461,7 +462,7 @@
   73.23    }
   73.24  }
   73.25  
   73.26 -#ifndef SERIALGC
   73.27 +#if INCLUDE_ALL_GCS
   73.28  void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm,
   73.29                                          oop obj) {
   73.30    assert(obj->is_array(), "obj must be array");
   73.31 @@ -472,7 +473,7 @@
   73.32      objarray_follow_contents<oop>(cm, obj, 0);
   73.33    }
   73.34  }
   73.35 -#endif // SERIALGC
   73.36 +#endif // INCLUDE_ALL_GCS
   73.37  
   73.38  #define if_do_metadata_checked(closure, nv_suffix)                    \
   73.39    /* Make sure the non-virtual and the virtual versions match. */     \
   73.40 @@ -573,7 +574,7 @@
   73.41    return size;
   73.42  }
   73.43  
   73.44 -#ifndef SERIALGC
   73.45 +#if INCLUDE_ALL_GCS
   73.46  void ObjArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   73.47    assert(obj->is_objArray(), "obj must be obj array");
   73.48    ObjArrayKlass_OOP_ITERATE( \
   73.49 @@ -591,7 +592,7 @@
   73.50    ObjArrayKlass_OOP_ITERATE(a, p, PSParallelCompact::adjust_pointer(p))
   73.51    return size;
   73.52  }
   73.53 -#endif // SERIALGC
   73.54 +#endif // INCLUDE_ALL_GCS
   73.55  
   73.56  // JVM support
   73.57  

    74.1 --- a/src/share/vm/oops/objArrayKlass.hpp	Fri Jan 18 05:33:32 2013 -0800
    74.2 +++ b/src/share/vm/oops/objArrayKlass.hpp	Wed Jan 23 13:02:39 2013 -0500
    74.3 @@ -28,6 +28,7 @@
    74.4  #include "classfile/classLoaderData.hpp"
    74.5  #include "memory/specialized_oop_closures.hpp"
    74.6  #include "oops/arrayKlass.hpp"
    74.7 +#include "utilities/macros.hpp"
    74.8  
    74.9  // ObjArrayKlass is the klass for objArrays
   74.10  
   74.11 @@ -111,11 +112,11 @@
   74.12  
   74.13    // Parallel Scavenge and Parallel Old
   74.14    PARALLEL_GC_DECLS
   74.15 -#ifndef SERIALGC
   74.16 +#if INCLUDE_ALL_GCS
   74.17    inline void oop_follow_contents(ParCompactionManager* cm, oop obj, int index);
   74.18    template <class T> inline void
   74.19      objarray_follow_contents(ParCompactionManager* cm, oop obj, int index);
   74.20 -#endif // !SERIALGC
   74.21 +#endif // INCLUDE_ALL_GCS
   74.22  
   74.23    // Iterators
   74.24    int oop_oop_iterate(oop obj, ExtendedOopClosure* blk) {

    75.1 --- a/src/share/vm/oops/objArrayKlass.inline.hpp	Fri Jan 18 05:33:32 2013 -0800
    75.2 +++ b/src/share/vm/oops/objArrayKlass.inline.hpp	Wed Jan 23 13:02:39 2013 -0500
    75.3 @@ -27,10 +27,11 @@
    75.4  
    75.5  #include "gc_implementation/shared/markSweep.inline.hpp"
    75.6  #include "oops/objArrayKlass.hpp"
    75.7 -#ifndef SERIALGC
    75.8 +#include "utilities/macros.hpp"
    75.9 +#if INCLUDE_ALL_GCS
   75.10  #include "gc_implementation/parallelScavenge/psCompactionManager.inline.hpp"
   75.11  #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
   75.12 -#endif
   75.13 +#endif // INCLUDE_ALL_GCS
   75.14  
   75.15  void ObjArrayKlass::oop_follow_contents(oop obj, int index) {
   75.16    if (UseCompressedOops) {
   75.17 @@ -63,7 +64,7 @@
   75.18    }
   75.19  }
   75.20  
   75.21 -#ifndef SERIALGC
   75.22 +#if INCLUDE_ALL_GCS
   75.23  void ObjArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj,
   75.24                                          int index) {
   75.25    if (UseCompressedOops) {
   75.26 @@ -96,6 +97,6 @@
   75.27      cm->push_objarray(a, end_index); // Push the continuation.
   75.28    }
   75.29  }
   75.30 -#endif // #ifndef SERIALGC
   75.31 +#endif // INCLUDE_ALL_GCS
   75.32  
   75.33  #endif // SHARE_VM_OOPS_OBJARRAYKLASS_INLINE_HPP

    76.1 --- a/src/share/vm/oops/oop.hpp	Fri Jan 18 05:33:32 2013 -0800
    76.2 +++ b/src/share/vm/oops/oop.hpp	Wed Jan 23 13:02:39 2013 -0500
    76.3 @@ -29,6 +29,7 @@
    76.4  #include "memory/memRegion.hpp"
    76.5  #include "memory/specialized_oop_closures.hpp"
    76.6  #include "oops/metadata.hpp"
    76.7 +#include "utilities/macros.hpp"
    76.8  #include "utilities/top.hpp"
    76.9  
   76.10  // oopDesc is the top baseclass for objects classes.  The {name}Desc classes describe
   76.11 @@ -298,7 +299,7 @@
   76.12    // reference field in "this".
   76.13    void follow_contents(void);
   76.14  
   76.15 -#ifndef SERIALGC
   76.16 +#if INCLUDE_ALL_GCS
   76.17    // Parallel Scavenge
   76.18    void push_contents(PSPromotionManager* pm);
   76.19  
   76.20 @@ -306,7 +307,7 @@
   76.21    void update_contents(ParCompactionManager* cm);
   76.22  
   76.23    void follow_contents(ParCompactionManager* cm);
   76.24 -#endif // SERIALGC
   76.25 +#endif // INCLUDE_ALL_GCS
   76.26  
   76.27    bool is_scavengable() const;
   76.28  
   76.29 @@ -316,13 +317,13 @@
   76.30    void forward_to(oop p);
   76.31    bool cas_forward_to(oop p, markOop compare);
   76.32  
   76.33 -#ifndef SERIALGC
   76.34 +#if INCLUDE_ALL_GCS
   76.35    // Like "forward_to", but inserts the forwarding pointer atomically.
   76.36    // Exactly one thread succeeds in inserting the forwarding pointer, and
   76.37    // this call returns "NULL" for that thread; any other thread has the
   76.38    // value of the forwarding pointer returned and does not modify "this".
   76.39    oop forward_to_atomic(oop p);
   76.40 -#endif // SERIALGC
   76.41 +#endif // INCLUDE_ALL_GCS
   76.42  
   76.43    oop forwardee() const;
   76.44  
   76.45 @@ -334,10 +335,10 @@
   76.46    // return the size of this oop.  This is used by the MarkSweep collector.
   76.47    int adjust_pointers();
   76.48  
   76.49 -#ifndef SERIALGC
   76.50 +#if INCLUDE_ALL_GCS
   76.51    // Parallel old
   76.52    void update_header(ParCompactionManager* cm);
   76.53 -#endif // SERIALGC
   76.54 +#endif // INCLUDE_ALL_GCS
   76.55  
   76.56    // mark-sweep support
   76.57    void follow_body(int begin, int end);
   76.58 @@ -354,7 +355,7 @@
   76.59    ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL)
   76.60    ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL)
   76.61  
   76.62 -#ifndef SERIALGC
   76.63 +#if INCLUDE_ALL_GCS
   76.64  
   76.65  #define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix)            \
   76.66    int oop_iterate_backwards(OopClosureType* blk);

    77.1 --- a/src/share/vm/oops/oop.inline.hpp	Fri Jan 18 05:33:32 2013 -0800
    77.2 +++ b/src/share/vm/oops/oop.inline.hpp	Wed Jan 23 13:02:39 2013 -0500
    77.3 @@ -40,6 +40,7 @@
    77.4  #include "oops/oop.hpp"
    77.5  #include "runtime/atomic.hpp"
    77.6  #include "runtime/os.hpp"
    77.7 +#include "utilities/macros.hpp"
    77.8  #ifdef TARGET_ARCH_x86
    77.9  # include "bytes_x86.hpp"
   77.10  #endif
   77.11 @@ -760,7 +761,7 @@
   77.12  ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DEFN)
   77.13  ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DEFN)
   77.14  
   77.15 -#ifndef SERIALGC
   77.16 +#if INCLUDE_ALL_GCS
   77.17  #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix)              \
   77.18                                                                             \
   77.19  inline int oopDesc::oop_iterate_backwards(OopClosureType* blk) {           \
   77.20 @@ -770,6 +771,6 @@
   77.21  
   77.22  ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DEFN)
   77.23  ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DEFN)
   77.24 -#endif // !SERIALGC
   77.25 +#endif // INCLUDE_ALL_GCS
   77.26  
   77.27  #endif // SHARE_VM_OOPS_OOP_INLINE_HPP

    78.1 --- a/src/share/vm/oops/oop.pcgc.inline.hpp	Fri Jan 18 05:33:32 2013 -0800
    78.2 +++ b/src/share/vm/oops/oop.pcgc.inline.hpp	Wed Jan 23 13:02:39 2013 -0500
    78.3 @@ -25,14 +25,15 @@
    78.4  #ifndef SHARE_VM_OOPS_OOP_PCGC_INLINE_HPP
    78.5  #define SHARE_VM_OOPS_OOP_PCGC_INLINE_HPP
    78.6  
    78.7 -#ifndef SERIALGC
    78.8 +#include "utilities/macros.hpp"
    78.9 +#if INCLUDE_ALL_GCS
   78.10  #include "gc_implementation/parNew/parNewGeneration.hpp"
   78.11  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
   78.12  #include "gc_implementation/parallelScavenge/psCompactionManager.hpp"
   78.13  #include "gc_implementation/parallelScavenge/psParallelCompact.hpp"
   78.14  #include "gc_implementation/parallelScavenge/psScavenge.hpp"
   78.15  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   78.16 -#endif
   78.17 +#endif // INCLUDE_ALL_GCS
   78.18  
   78.19  inline void oopDesc::update_contents(ParCompactionManager* cm) {
   78.20    // The klass field must be updated before anything else

    79.1 --- a/src/share/vm/oops/oop.psgc.inline.hpp	Fri Jan 18 05:33:32 2013 -0800
    79.2 +++ b/src/share/vm/oops/oop.psgc.inline.hpp	Wed Jan 23 13:02:39 2013 -0500
    79.3 @@ -25,11 +25,12 @@
    79.4  #ifndef SHARE_VM_OOPS_OOP_PSGC_INLINE_HPP
    79.5  #define SHARE_VM_OOPS_OOP_PSGC_INLINE_HPP
    79.6  
    79.7 -#ifndef SERIALGC
    79.8 +#include "utilities/macros.hpp"
    79.9 +#if INCLUDE_ALL_GCS
   79.10  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
   79.11  #include "gc_implementation/parallelScavenge/psScavenge.hpp"
   79.12  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   79.13 -#endif
   79.14 +#endif // INCLUDE_ALL_GCS
   79.15  
   79.16  // ParallelScavengeHeap methods
   79.17  

    80.1 --- a/src/share/vm/oops/typeArrayKlass.cpp	Fri Jan 18 05:33:32 2013 -0800
    80.2 +++ b/src/share/vm/oops/typeArrayKlass.cpp	Wed Jan 23 13:02:39 2013 -0500
    80.3 @@ -39,6 +39,7 @@
    80.4  #include "oops/typeArrayKlass.hpp"
    80.5  #include "oops/typeArrayOop.hpp"
    80.6  #include "runtime/handles.inline.hpp"
    80.7 +#include "utilities/macros.hpp"
    80.8  
    80.9  bool TypeArrayKlass::compute_is_subtype_of(Klass* k) {
   80.10    if (!k->oop_is_typeArray()) {
   80.11 @@ -208,13 +209,13 @@
   80.12    // know that Universe::TypeArrayKlass never moves.
   80.13  }
   80.14  
   80.15 -#ifndef SERIALGC
   80.16 +#if INCLUDE_ALL_GCS
   80.17  void TypeArrayKlass::oop_follow_contents(ParCompactionManager* cm, oop obj) {
   80.18    assert(obj->is_typeArray(),"must be a type array");
   80.19    // Performance tweak: We skip iterating over the klass pointer since we
   80.20    // know that Universe::TypeArrayKlass never moves.
   80.21  }
   80.22 -#endif // SERIALGC
   80.23 +#endif // INCLUDE_ALL_GCS
   80.24  
   80.25  int TypeArrayKlass::oop_adjust_pointers(oop obj) {
   80.26    assert(obj->is_typeArray(),"must be a type array");
   80.27 @@ -240,7 +241,7 @@
   80.28    return t->object_size();
   80.29  }
   80.30  
   80.31 -#ifndef SERIALGC
   80.32 +#if INCLUDE_ALL_GCS
   80.33  void TypeArrayKlass::oop_push_contents(PSPromotionManager* pm, oop obj) {
   80.34    ShouldNotReachHere();
   80.35    assert(obj->is_typeArray(),"must be a type array");
   80.36 @@ -251,7 +252,7 @@
   80.37    assert(obj->is_typeArray(),"must be a type array");
   80.38    return typeArrayOop(obj)->object_size();
   80.39  }
   80.40 -#endif // SERIALGC
   80.41 +#endif // INCLUDE_ALL_GCS
   80.42  
   80.43  void TypeArrayKlass::initialize(TRAPS) {
   80.44    // Nothing to do. Having this function is handy since objArrayKlasses can be

    81.1 --- a/src/share/vm/precompiled/precompiled.hpp	Fri Jan 18 05:33:32 2013 -0800
    81.2 +++ b/src/share/vm/precompiled/precompiled.hpp	Wed Jan 23 13:02:39 2013 -0500
    81.3 @@ -24,6 +24,7 @@
    81.4  
    81.5  // Precompiled headers are turned off for Sun Studion,
    81.6  // or if the user passes USE_PRECOMPILED_HEADER=0 to the makefiles.
    81.7 +
    81.8  #ifndef DONT_USE_PRECOMPILED_HEADER
    81.9  
   81.10  # include "asm/assembler.hpp"
   81.11 @@ -285,7 +286,7 @@
   81.12  # include "c1/c1_ValueType.hpp"
   81.13  # include "c1/c1_globals.hpp"
   81.14  #endif // COMPILER1
   81.15 -#ifndef SERIALGC
   81.16 +#if INCLUDE_ALL_GCS
   81.17  # include "gc_implementation/concurrentMarkSweep/cmsOopClosures.hpp"
   81.18  # include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
   81.19  # include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp"
   81.20 @@ -314,6 +315,6 @@
   81.21  # include "gc_implementation/shared/gcAdaptivePolicyCounters.hpp"
   81.22  # include "gc_implementation/shared/gcPolicyCounters.hpp"
   81.23  # include "gc_implementation/shared/parGCAllocBuffer.hpp"
   81.24 -#endif // SERIALGC
   81.25 +#endif // INCLUDE_ALL_GCS
   81.26  
   81.27  #endif // !DONT_USE_PRECOMPILED_HEADER

    82.1 --- a/src/share/vm/prims/jni.cpp	Fri Jan 18 05:33:32 2013 -0800
    82.2 +++ b/src/share/vm/prims/jni.cpp	Wed Jan 23 13:02:39 2013 -0500
    82.3 @@ -32,9 +32,10 @@
    82.4  #include "classfile/systemDictionary.hpp"
    82.5  #include "classfile/vmSymbols.hpp"
    82.6  #include "interpreter/linkResolver.hpp"
    82.7 -#ifndef SERIALGC
    82.8 +#include "utilities/macros.hpp"
    82.9 +#if INCLUDE_ALL_GCS
   82.10  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   82.11 -#endif // SERIALGC
   82.12 +#endif // INCLUDE_ALL_GCS
   82.13  #include "memory/allocation.hpp"
   82.14  #include "memory/allocation.inline.hpp"
   82.15  #include "memory/gcLocker.inline.hpp"
   82.16 @@ -2641,7 +2642,7 @@
   82.17      o = JvmtiExport::jni_GetField_probe(thread, obj, o, k, fieldID, false);
   82.18    }
   82.19    jobject ret = JNIHandles::make_local(env, o->obj_field(offset));
   82.20 -#ifndef SERIALGC
   82.21 +#if INCLUDE_ALL_GCS
   82.22    // If G1 is enabled and we are accessing the value of the referent
   82.23    // field in a reference object then we need to register a non-null
   82.24    // referent with the SATB barrier.
   82.25 @@ -2660,7 +2661,7 @@
   82.26        G1SATBCardTableModRefBS::enqueue(referent);
   82.27      }
   82.28    }
   82.29 -#endif // SERIALGC
   82.30 +#endif // INCLUDE_ALL_GCS
   82.31  #ifndef USDT2
   82.32    DTRACE_PROBE1(hotspot_jni, GetObjectField__return, ret);
   82.33  #else /* USDT2 */

    83.1 --- a/src/share/vm/prims/jvmtiEnvBase.hpp	Fri Jan 18 05:33:32 2013 -0800
    83.2 +++ b/src/share/vm/prims/jvmtiEnvBase.hpp	Wed Jan 23 13:02:39 2013 -0500
    83.3 @@ -35,6 +35,7 @@
    83.4  #include "runtime/thread.hpp"
    83.5  #include "runtime/vm_operations.hpp"
    83.6  #include "utilities/growableArray.hpp"
    83.7 +#include "utilities/macros.hpp"
    83.8  
    83.9  //
   83.10  // Forward Declarations

    84.1 --- a/src/share/vm/prims/jvmtiExport.cpp	Fri Jan 18 05:33:32 2013 -0800
    84.2 +++ b/src/share/vm/prims/jvmtiExport.cpp	Wed Jan 23 13:02:39 2013 -0500
    84.3 @@ -50,9 +50,10 @@
    84.4  #include "runtime/vframe.hpp"
    84.5  #include "services/attachListener.hpp"
    84.6  #include "services/serviceUtil.hpp"
    84.7 -#ifndef SERIALGC
    84.8 +#include "utilities/macros.hpp"
    84.9 +#if INCLUDE_ALL_GCS
   84.10  #include "gc_implementation/parallelScavenge/psMarkSweep.hpp"
   84.11 -#endif
   84.12 +#endif // INCLUDE_ALL_GCS
   84.13  
   84.14  #ifdef JVMTI_TRACE
   84.15  #define EVT_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_SENT) != 0) { SafeResourceMark rm; tty->print_cr out; }

    85.1 --- a/src/share/vm/prims/jvmtiExport.hpp	Fri Jan 18 05:33:32 2013 -0800
    85.2 +++ b/src/share/vm/prims/jvmtiExport.hpp	Wed Jan 23 13:02:39 2013 -0500
    85.3 @@ -34,6 +34,7 @@
    85.4  #include "runtime/handles.hpp"
    85.5  #include "utilities/globalDefinitions.hpp"
    85.6  #include "utilities/growableArray.hpp"
    85.7 +#include "utilities/macros.hpp"
    85.8  
    85.9  // Must be included after jvmti.h.
   85.10  #include "code/jvmticmlr.h"

    86.1 --- a/src/share/vm/prims/jvmtiTagMap.cpp	Fri Jan 18 05:33:32 2013 -0800
    86.2 +++ b/src/share/vm/prims/jvmtiTagMap.cpp	Wed Jan 23 13:02:39 2013 -0500
    86.3 @@ -45,9 +45,10 @@
    86.4  #include "runtime/vmThread.hpp"
    86.5  #include "runtime/vm_operations.hpp"
    86.6  #include "services/serviceUtil.hpp"
    86.7 -#ifndef SERIALGC
    86.8 +#include "utilities/macros.hpp"
    86.9 +#if INCLUDE_ALL_GCS
   86.10  #include "gc_implementation/parallelScavenge/parallelScavengeHeap.hpp"
   86.11 -#endif
   86.12 +#endif // INCLUDE_ALL_GCS
   86.13  
   86.14  // JvmtiTagHashmapEntry
   86.15  //

    87.1 --- a/src/share/vm/prims/nativeLookup.cpp	Fri Jan 18 05:33:32 2013 -0800
    87.2 +++ b/src/share/vm/prims/nativeLookup.cpp	Wed Jan 23 13:02:39 2013 -0500
    87.3 @@ -40,6 +40,7 @@
    87.4  #include "runtime/javaCalls.hpp"
    87.5  #include "runtime/sharedRuntime.hpp"
    87.6  #include "runtime/signature.hpp"
    87.7 +#include "utilities/macros.hpp"
    87.8  #ifdef TARGET_OS_FAMILY_linux
    87.9  # include "os_linux.inline.hpp"
   87.10  #endif

    88.1 --- a/src/share/vm/prims/unsafe.cpp	Fri Jan 18 05:33:32 2013 -0800
    88.2 +++ b/src/share/vm/prims/unsafe.cpp	Wed Jan 23 13:02:39 2013 -0500
    88.3 @@ -24,9 +24,10 @@
    88.4  
    88.5  #include "precompiled.hpp"
    88.6  #include "classfile/vmSymbols.hpp"
    88.7 -#ifndef SERIALGC
    88.8 +#include "utilities/macros.hpp"
    88.9 +#if INCLUDE_ALL_GCS
   88.10  #include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
   88.11 -#endif // SERIALGC
   88.12 +#endif // INCLUDE_ALL_GCS
   88.13  #include "memory/allocation.inline.hpp"
   88.14  #include "prims/jni.h"
   88.15  #include "prims/jvm.h"
   88.16 @@ -189,7 +190,7 @@
   88.17    if (obj == NULL)  THROW_0(vmSymbols::java_lang_NullPointerException());
   88.18    GET_OOP_FIELD(obj, offset, v)
   88.19    jobject ret = JNIHandles::make_local(env, v);
   88.20 -#ifndef SERIALGC
   88.21 +#if INCLUDE_ALL_GCS
   88.22    // We could be accessing the referent field in a reference
   88.23    // object. If G1 is enabled then we need to register a non-null
   88.24    // referent with the SATB barrier.
   88.25 @@ -212,7 +213,7 @@
   88.26        G1SATBCardTableModRefBS::enqueue(referent);
   88.27      }
   88.28    }
   88.29 -#endif // SERIALGC
   88.30 +#endif // INCLUDE_ALL_GCS
   88.31    return ret;
   88.32  UNSAFE_END
   88.33  
   88.34 @@ -247,7 +248,7 @@
   88.35    UnsafeWrapper("Unsafe_GetObject");
   88.36    GET_OOP_FIELD(obj, offset, v)
   88.37    jobject ret = JNIHandles::make_local(env, v);
   88.38 -#ifndef SERIALGC
   88.39 +#if INCLUDE_ALL_GCS
   88.40    // We could be accessing the referent field in a reference
   88.41    // object. If G1 is enabled then we need to register non-null
   88.42    // referent with the SATB barrier.
   88.43 @@ -270,7 +271,7 @@
   88.44        G1SATBCardTableModRefBS::enqueue(referent);
   88.45      }
   88.46    }
   88.47 -#endif // SERIALGC
   88.48 +#endif // INCLUDE_ALL_GCS
   88.49    return ret;
   88.50  UNSAFE_END
   88.51  

    89.1 --- a/src/share/vm/prims/whitebox.cpp	Fri Jan 18 05:33:32 2013 -0800
    89.2 +++ b/src/share/vm/prims/whitebox.cpp	Wed Jan 23 13:02:39 2013 -0500
    89.3 @@ -36,12 +36,13 @@
    89.4  #include "runtime/interfaceSupport.hpp"
    89.5  #include "runtime/os.hpp"
    89.6  #include "utilities/debug.hpp"
    89.7 +#include "utilities/macros.hpp"
    89.8  
    89.9 -#ifndef SERIALGC
   89.10 +#if INCLUDE_ALL_GCS
   89.11  #include "gc_implementation/g1/concurrentMark.hpp"
   89.12  #include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
   89.13  #include "gc_implementation/g1/heapRegionRemSet.hpp"
   89.14 -#endif // !SERIALGC
   89.15 +#endif // INCLUDE_ALL_GCS
   89.16  
   89.17  bool WhiteBox::_used = false;
   89.18  
   89.19 @@ -85,7 +86,7 @@
   89.20    return closure.found();
   89.21  WB_END
   89.22  
   89.23 -#ifndef SERIALGC
   89.24 +#if INCLUDE_ALL_GCS
   89.25  WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj))
   89.26    G1CollectedHeap* g1 = G1CollectedHeap::heap();
   89.27    oop result = JNIHandles::resolve(obj);
   89.28 @@ -108,7 +109,7 @@
   89.29  WB_ENTRY(jint, WB_G1RegionSize(JNIEnv* env, jobject o))
   89.30    return (jint)HeapRegion::GrainBytes;
   89.31  WB_END
   89.32 -#endif // !SERIALGC
   89.33 +#endif // INCLUDE_ALL_GCS
   89.34  
   89.35  //Some convenience methods to deal with objects from java
   89.36  int WhiteBox::offset_for_field(const char* field_name, oop object,
   89.37 @@ -171,12 +172,12 @@
   89.38        CC "(Ljava/lang/String;[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;",
   89.39        (void*) &WB_ParseCommandLine
   89.40    },
   89.41 -#ifndef SERIALGC
   89.42 +#if INCLUDE_ALL_GCS
   89.43    {CC"g1InConcurrentMark", CC"()Z",                   (void*)&WB_G1InConcurrentMark},
   89.44    {CC"g1IsHumongous",      CC"(Ljava/lang/Object;)Z", (void*)&WB_G1IsHumongous     },
   89.45    {CC"g1NumFreeRegions",   CC"()J",                   (void*)&WB_G1NumFreeRegions  },
   89.46    {CC"g1RegionSize",       CC"()I",                   (void*)&WB_G1RegionSize      },
   89.47 -#endif // !SERIALGC
   89.48 +#endif // INCLUDE_ALL_GCS
   89.49  };
   89.50  
   89.51  #undef CC

    90.1 --- a/src/share/vm/runtime/arguments.cpp	Fri Jan 18 05:33:32 2013 -0800
    90.2 +++ b/src/share/vm/runtime/arguments.cpp	Wed Jan 23 13:02:39 2013 -0500
    90.3 @@ -38,6 +38,7 @@
    90.4  #include "services/management.hpp"
    90.5  #include "services/memTracker.hpp"
    90.6  #include "utilities/defaultStream.hpp"
    90.7 +#include "utilities/macros.hpp"
    90.8  #include "utilities/taskqueue.hpp"
    90.9  #ifdef TARGET_OS_FAMILY_linux
   90.10  # include "os_linux.inline.hpp"
   90.11 @@ -51,9 +52,9 @@
   90.12  #ifdef TARGET_OS_FAMILY_bsd
   90.13  # include "os_bsd.inline.hpp"
   90.14  #endif
   90.15 -#ifndef SERIALGC
   90.16 +#if INCLUDE_ALL_GCS
   90.17  #include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"
   90.18 -#endif
   90.19 +#endif // INCLUDE_ALL_GCS
   90.20  
   90.21  // Note: This is a special bug reporting site for the JVM
   90.22  #define DEFAULT_VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/crash.jsp"
   90.23 @@ -1072,7 +1073,7 @@
   90.24    }
   90.25  }
   90.26  
   90.27 -#if INCLUDE_ALTERNATE_GCS
   90.28 +#if INCLUDE_ALL_GCS
   90.29  static void disable_adaptive_size_policy(const char* collector_name) {
   90.30    if (UseAdaptiveSizePolicy) {
   90.31      if (FLAG_IS_CMDLINE(UseAdaptiveSizePolicy)) {
   90.32 @@ -1284,7 +1285,7 @@
   90.33      tty->print_cr("ConcGCThreads: %u", ConcGCThreads);
   90.34    }
   90.35  }
   90.36 -#endif // INCLUDE_ALTERNATE_GCS
   90.37 +#endif // INCLUDE_ALL_GCS
   90.38  
   90.39  void set_object_alignment() {
   90.40    // Object alignment.
   90.41 @@ -1301,10 +1302,10 @@
   90.42    // Oop encoding heap max
   90.43    OopEncodingHeapMax = (uint64_t(max_juint) + 1) << LogMinObjAlignmentInBytes;
   90.44  
   90.45 -#if INCLUDE_ALTERNATE_GCS
   90.46 +#if INCLUDE_ALL_GCS
   90.47    // Set CMS global values
   90.48    CompactibleFreeListSpace::set_cms_values();
   90.49 -#endif // INCLUDE_ALTERNATE_GCS
   90.50 +#endif // INCLUDE_ALL_GCS
   90.51  }
   90.52  
   90.53  bool verify_object_alignment() {
   90.54 @@ -1976,7 +1977,7 @@
   90.55  
   90.56    status = status && verify_min_value(ParGCArrayScanChunk, 1, "ParGCArrayScanChunk");
   90.57  
   90.58 -#ifndef SERIALGC
   90.59 +#if INCLUDE_ALL_GCS
   90.60    if (UseG1GC) {
   90.61      status = status && verify_percentage(InitiatingHeapOccupancyPercent,
   90.62                                           "InitiatingHeapOccupancyPercent");
   90.63 @@ -1985,7 +1986,7 @@
   90.64      status = status && verify_min_value((intx)G1ConcMarkStepDurationMillis, 1,
   90.65                                          "G1ConcMarkStepDurationMillis");
   90.66    }
   90.67 -#endif
   90.68 +#endif // INCLUDE_ALL_GCS
   90.69  
   90.70    status = status && verify_interval(RefDiscoveryPolicy,
   90.71                                       ReferenceProcessor::DiscoveryPolicyMin,
   90.72 @@ -3157,7 +3158,7 @@
   90.73    UNSUPPORTED_OPTION(UseLargePages, "-XX:+UseLargePages");
   90.74  #endif
   90.75  
   90.76 -#if !INCLUDE_ALTERNATE_GCS
   90.77 +#if !INCLUDE_ALL_GCS
   90.78    if (UseParallelGC) {
   90.79      warning("Parallel GC is not supported in this VM.  Using Serial GC.");
   90.80    }
   90.81 @@ -3170,7 +3171,7 @@
   90.82    if (UseParNewGC) {
   90.83      warning("Par New GC is not supported in this VM.  Using Serial GC.");
   90.84    }
   90.85 -#endif // INCLUDE_ALTERNATE_GCS
   90.86 +#endif // INCLUDE_ALL_GCS
   90.87  
   90.88  #ifndef PRODUCT
   90.89    if (TraceBytecodesAt != 0) {
   90.90 @@ -3217,9 +3218,9 @@
   90.91    // Set object alignment values.
   90.92    set_object_alignment();
   90.93  
   90.94 -#ifdef SERIALGC
   90.95 +#if !INCLUDE_ALL_GCS
   90.96    force_serial_gc();
   90.97 -#endif // SERIALGC
   90.98 +#endif // INCLUDE_ALL_GCS
   90.99  #if !INCLUDE_CDS
  90.100    no_shared_spaces();
  90.101  #endif // INCLUDE_CDS
  90.102 @@ -3247,7 +3248,7 @@
  90.103    // Set heap size based on available physical memory
  90.104    set_heap_size();
  90.105  
  90.106 -#if INCLUDE_ALTERNATE_GCS
  90.107 +#if INCLUDE_ALL_GCS
  90.108    // Set per-collector flags
  90.109    if (UseParallelGC || UseParallelOldGC) {
  90.110      set_parallel_gc_flags();
  90.111 @@ -3259,11 +3260,9 @@
  90.112      set_g1_gc_flags();
  90.113    }
  90.114    check_deprecated_gcs();
  90.115 -#endif // INCLUDE_ALTERNATE_GCS
  90.116 -
  90.117 -#ifdef SERIALGC
  90.118 +#else // INCLUDE_ALL_GCS
  90.119    assert(verify_serial_gc_flags(), "SerialGC unset");
  90.120 -#endif // SERIALGC
  90.121 +#endif // INCLUDE_ALL_GCS
  90.122  
  90.123    // Set bytecode rewriting flags
  90.124    set_bytecode_flags();
  90.125 @@ -3357,7 +3356,7 @@
  90.126  }
  90.127  
  90.128  jint Arguments::adjust_after_os() {
  90.129 -#if INCLUDE_ALTERNATE_GCS
  90.130 +#if INCLUDE_ALL_GCS
  90.131    if (UseParallelGC || UseParallelOldGC) {
  90.132      if (UseNUMA) {
  90.133        if (FLAG_IS_DEFAULT(MinHeapDeltaBytes)) {
  90.134 @@ -3368,7 +3367,7 @@
  90.135        UseNUMAInterleaving = true;
  90.136      }
  90.137    }
  90.138 -#endif
  90.139 +#endif // INCLUDE_ALL_GCS
  90.140    return JNI_OK;
  90.141  }
  90.142  

    91.1 --- a/src/share/vm/runtime/fprofiler.hpp	Fri Jan 18 05:33:32 2013 -0800
    91.2 +++ b/src/share/vm/runtime/fprofiler.hpp	Wed Jan 23 13:02:39 2013 -0500
    91.3 @@ -25,6 +25,7 @@
    91.4  #ifndef SHARE_VM_RUNTIME_FPROFILER_HPP
    91.5  #define SHARE_VM_RUNTIME_FPROFILER_HPP
    91.6  
    91.7 +#include "utilities/macros.hpp"
    91.8  #include "runtime/timer.hpp"
    91.9  
   91.10  // a simple flat profiler for Java

    92.1 --- a/src/share/vm/runtime/globals.cpp	Fri Jan 18 05:33:32 2013 -0800
    92.2 +++ b/src/share/vm/runtime/globals.cpp	Wed Jan 23 13:02:39 2013 -0500
    92.3 @@ -29,10 +29,11 @@
    92.4  #include "runtime/globals.hpp"
    92.5  #include "runtime/globals_extension.hpp"
    92.6  #include "utilities/ostream.hpp"
    92.7 +#include "utilities/macros.hpp"
    92.8  #include "utilities/top.hpp"
    92.9 -#ifndef SERIALGC
   92.10 +#if INCLUDE_ALL_GCS
   92.11  #include "gc_implementation/g1/g1_globals.hpp"
   92.12 -#endif
   92.13 +#endif // INCLUDE_ALL_GCS
   92.14  #ifdef COMPILER1
   92.15  #include "c1/c1_globals.hpp"
   92.16  #endif
   92.17 @@ -256,9 +257,9 @@
   92.18  static Flag flagTable[] = {
   92.19   RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_EXPERIMENTAL_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT, RUNTIME_MANAGEABLE_FLAG_STRUCT, RUNTIME_PRODUCT_RW_FLAG_STRUCT, RUNTIME_LP64_PRODUCT_FLAG_STRUCT)
   92.20   RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT)
   92.21 -#ifndef SERIALGC
   92.22 +#if INCLUDE_ALL_GCS
   92.23   G1_FLAGS(RUNTIME_DEVELOP_FLAG_STRUCT, RUNTIME_PD_DEVELOP_FLAG_STRUCT, RUNTIME_PRODUCT_FLAG_STRUCT, RUNTIME_PD_PRODUCT_FLAG_STRUCT, RUNTIME_DIAGNOSTIC_FLAG_STRUCT, RUNTIME_EXPERIMENTAL_FLAG_STRUCT, RUNTIME_NOTPRODUCT_FLAG_STRUCT, RUNTIME_MANAGEABLE_FLAG_STRUCT, RUNTIME_PRODUCT_RW_FLAG_STRUCT)
   92.24 -#endif // SERIALGC
   92.25 +#endif // INCLUDE_ALL_GCS
   92.26  #ifdef COMPILER1
   92.27   C1_FLAGS(C1_DEVELOP_FLAG_STRUCT, C1_PD_DEVELOP_FLAG_STRUCT, C1_PRODUCT_FLAG_STRUCT, C1_PD_PRODUCT_FLAG_STRUCT, C1_NOTPRODUCT_FLAG_STRUCT)
   92.28  #endif

    93.1 --- a/src/share/vm/runtime/globals_extension.hpp	Fri Jan 18 05:33:32 2013 -0800
    93.2 +++ b/src/share/vm/runtime/globals_extension.hpp	Wed Jan 23 13:02:39 2013 -0500
    93.3 @@ -26,6 +26,7 @@
    93.4  #define SHARE_VM_RUNTIME_GLOBALS_EXTENSION_HPP
    93.5  
    93.6  #include "runtime/globals.hpp"
    93.7 +#include "utilities/macros.hpp"
    93.8  #include "utilities/top.hpp"
    93.9  
   93.10  // Construct enum of Flag_<cmdline-arg> constants.
   93.11 @@ -94,9 +95,9 @@
   93.12  typedef enum {
   93.13   RUNTIME_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, RUNTIME_PD_DEVELOP_FLAG_MEMBER, RUNTIME_PRODUCT_FLAG_MEMBER, RUNTIME_PD_PRODUCT_FLAG_MEMBER, RUNTIME_DIAGNOSTIC_FLAG_MEMBER, RUNTIME_EXPERIMENTAL_FLAG_MEMBER, RUNTIME_NOTPRODUCT_FLAG_MEMBER, RUNTIME_MANAGEABLE_FLAG_MEMBER, RUNTIME_PRODUCT_RW_FLAG_MEMBER, RUNTIME_LP64_PRODUCT_FLAG_MEMBER)
   93.14   RUNTIME_OS_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, RUNTIME_PD_DEVELOP_FLAG_MEMBER, RUNTIME_PRODUCT_FLAG_MEMBER, RUNTIME_PD_PRODUCT_FLAG_MEMBER, RUNTIME_DIAGNOSTIC_FLAG_MEMBER, RUNTIME_NOTPRODUCT_FLAG_MEMBER)
   93.15 -#if INCLUDE_ALTERNATE_GCS
   93.16 +#if INCLUDE_ALL_GCS
   93.17   G1_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER, RUNTIME_PD_DEVELOP_FLAG_MEMBER, RUNTIME_PRODUCT_FLAG_MEMBER, RUNTIME_PD_PRODUCT_FLAG_MEMBER, RUNTIME_DIAGNOSTIC_FLAG_MEMBER, RUNTIME_EXPERIMENTAL_FLAG_MEMBER, RUNTIME_NOTPRODUCT_FLAG_MEMBER, RUNTIME_MANAGEABLE_FLAG_MEMBER, RUNTIME_PRODUCT_RW_FLAG_MEMBER)
   93.18 -#endif // INCLUDE_ALTERNATE_GCS
   93.19 +#endif // INCLUDE_ALL_GCS
   93.20  #ifdef COMPILER1
   93.21   C1_FLAGS(C1_DEVELOP_FLAG_MEMBER, C1_PD_DEVELOP_FLAG_MEMBER, C1_PRODUCT_FLAG_MEMBER, C1_PD_PRODUCT_FLAG_MEMBER, C1_NOTPRODUCT_FLAG_MEMBER)
   93.22  #endif
   93.23 @@ -187,7 +188,7 @@
   93.24                    RUNTIME_PD_PRODUCT_FLAG_MEMBER_WITH_TYPE,
   93.25                    RUNTIME_DIAGNOSTIC_FLAG_MEMBER_WITH_TYPE,
   93.26                    RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE)
   93.27 -#if INCLUDE_ALTERNATE_GCS
   93.28 +#if INCLUDE_ALL_GCS
   93.29   G1_FLAGS(RUNTIME_DEVELOP_FLAG_MEMBER_WITH_TYPE,
   93.30            RUNTIME_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,
   93.31            RUNTIME_PRODUCT_FLAG_MEMBER_WITH_TYPE,
   93.32 @@ -197,7 +198,7 @@
   93.33            RUNTIME_NOTPRODUCT_FLAG_MEMBER_WITH_TYPE,
   93.34            RUNTIME_MANAGEABLE_FLAG_MEMBER_WITH_TYPE,
   93.35            RUNTIME_PRODUCT_RW_FLAG_MEMBER_WITH_TYPE)
   93.36 -#endif // INCLUDE_ALTERNATE_GCS
   93.37 +#endif // INCLUDE_ALL_GCS
   93.38  #ifdef COMPILER1
   93.39   C1_FLAGS(C1_DEVELOP_FLAG_MEMBER_WITH_TYPE,
   93.40            C1_PD_DEVELOP_FLAG_MEMBER_WITH_TYPE,

    94.1 --- a/src/share/vm/runtime/init.cpp	Fri Jan 18 05:33:32 2013 -0800
    94.2 +++ b/src/share/vm/runtime/init.cpp	Wed Jan 23 13:02:39 2013 -0500
    94.3 @@ -34,6 +34,7 @@
    94.4  #include "runtime/init.hpp"
    94.5  #include "runtime/safepoint.hpp"
    94.6  #include "runtime/sharedRuntime.hpp"
    94.7 +#include "utilities/macros.hpp"
    94.8  
    94.9  // Initialization done by VM thread in vm_init_globals()
   94.10  void check_ThreadShadow();

    95.1 --- a/src/share/vm/runtime/java.cpp	Fri Jan 18 05:33:32 2013 -0800
    95.2 +++ b/src/share/vm/runtime/java.cpp	Wed Jan 23 13:02:39 2013 -0500
    95.3 @@ -64,6 +64,7 @@
    95.4  #include "utilities/dtrace.hpp"
    95.5  #include "utilities/globalDefinitions.hpp"
    95.6  #include "utilities/histogram.hpp"
    95.7 +#include "utilities/macros.hpp"
    95.8  #include "utilities/vmError.hpp"
    95.9  #ifdef TARGET_ARCH_x86
   95.10  # include "vm_version_x86.hpp"
   95.11 @@ -80,11 +81,11 @@
   95.12  #ifdef TARGET_ARCH_ppc
   95.13  # include "vm_version_ppc.hpp"
   95.14  #endif
   95.15 -#ifndef SERIALGC
   95.16 +#if INCLUDE_ALL_GCS
   95.17  #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
   95.18  #include "gc_implementation/parallelScavenge/psScavenge.hpp"
   95.19  #include "gc_implementation/parallelScavenge/psScavenge.inline.hpp"
   95.20 -#endif
   95.21 +#endif // INCLUDE_ALL_GCS
   95.22  #ifdef COMPILER1
   95.23  #include "c1/c1_Compiler.hpp"
   95.24  #include "c1/c1_Runtime1.hpp"

    96.1 --- a/src/share/vm/runtime/safepoint.cpp	Fri Jan 18 05:33:32 2013 -0800
    96.2 +++ b/src/share/vm/runtime/safepoint.cpp	Wed Jan 23 13:02:39 2013 -0500
    96.3 @@ -52,6 +52,7 @@
    96.4  #include "services/memTracker.hpp"
    96.5  #include "services/runtimeService.hpp"
    96.6  #include "utilities/events.hpp"
    96.7 +#include "utilities/macros.hpp"
    96.8  #ifdef TARGET_ARCH_x86
    96.9  # include "nativeInst_x86.hpp"
   96.10  # include "vmreg_x86.inline.hpp"
   96.11 @@ -72,10 +73,10 @@
   96.12  # include "nativeInst_ppc.hpp"
   96.13  # include "vmreg_ppc.inline.hpp"
   96.14  #endif
   96.15 -#ifndef SERIALGC
   96.16 +#if INCLUDE_ALL_GCS
   96.17  #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
   96.18  #include "gc_implementation/shared/concurrentGCThread.hpp"
   96.19 -#endif
   96.20 +#endif // INCLUDE_ALL_GCS
   96.21  #ifdef COMPILER1
   96.22  #include "c1/c1_globals.hpp"
   96.23  #endif
   96.24 @@ -103,7 +104,7 @@
   96.25      _ts_of_current_safepoint = tty->time_stamp().seconds();
   96.26    }
   96.27  
   96.28 -#ifndef SERIALGC
   96.29 +#if INCLUDE_ALL_GCS
   96.30    if (UseConcMarkSweepGC) {
   96.31      // In the future we should investigate whether CMS can use the
   96.32      // more-general mechanism below.  DLD (01/05).
   96.33 @@ -111,7 +112,7 @@
   96.34    } else if (UseG1GC) {
   96.35      ConcurrentGCThread::safepoint_synchronize();
   96.36    }
   96.37 -#endif // SERIALGC
   96.38 +#endif // INCLUDE_ALL_GCS
   96.39  
   96.40    // By getting the Threads_lock, we assure that no threads are about to start or
   96.41    // exit. It is released again in SafepointSynchronize::end().
   96.42 @@ -480,14 +481,14 @@
   96.43      Threads_lock->unlock();
   96.44  
   96.45    }
   96.46 -#ifndef SERIALGC
   96.47 +#if INCLUDE_ALL_GCS
   96.48    // If there are any concurrent GC threads resume them.
   96.49    if (UseConcMarkSweepGC) {
   96.50      ConcurrentMarkSweepThread::desynchronize(false);
   96.51    } else if (UseG1GC) {
   96.52      ConcurrentGCThread::safepoint_desynchronize();
   96.53    }
   96.54 -#endif // SERIALGC
   96.55 +#endif // INCLUDE_ALL_GCS
   96.56    // record this time so VMThread can keep track how much time has elasped
   96.57    // since last safepoint.
   96.58    _end_of_last_safepoint = os::javaTimeMillis();

    97.1 --- a/src/share/vm/runtime/sharedRuntime.cpp	Fri Jan 18 05:33:32 2013 -0800
    97.2 +++ b/src/share/vm/runtime/sharedRuntime.cpp	Wed Jan 23 13:02:39 2013 -0500
    97.3 @@ -56,6 +56,7 @@
    97.4  #include "utilities/dtrace.hpp"
    97.5  #include "utilities/events.hpp"
    97.6  #include "utilities/hashtable.inline.hpp"
    97.7 +#include "utilities/macros.hpp"
    97.8  #include "utilities/xmlstream.hpp"
    97.9  #ifdef TARGET_ARCH_x86
   97.10  # include "nativeInst_x86.hpp"
   97.11 @@ -212,7 +213,7 @@
   97.12  }
   97.13  #endif // PRODUCT
   97.14  
   97.15 -#ifndef SERIALGC
   97.16 +#if INCLUDE_ALL_GCS
   97.17  
   97.18  // G1 write-barrier pre: executed before a pointer store.
   97.19  JRT_LEAF(void, SharedRuntime::g1_wb_pre(oopDesc* orig, JavaThread *thread))
   97.20 @@ -230,7 +231,7 @@
   97.21    thread->dirty_card_queue().enqueue(card_addr);
   97.22  JRT_END
   97.23  
   97.24 -#endif // !SERIALGC
   97.25 +#endif // INCLUDE_ALL_GCS
   97.26  
   97.27  
   97.28  JRT_LEAF(jlong, SharedRuntime::lmul(jlong y, jlong x))

    98.1 --- a/src/share/vm/runtime/sharedRuntime.hpp	Fri Jan 18 05:33:32 2013 -0800
    98.2 +++ b/src/share/vm/runtime/sharedRuntime.hpp	Wed Jan 23 13:02:39 2013 -0500
    98.3 @@ -32,6 +32,7 @@
    98.4  #include "memory/resourceArea.hpp"
    98.5  #include "runtime/threadLocalStorage.hpp"
    98.6  #include "utilities/hashtable.hpp"
    98.7 +#include "utilities/macros.hpp"
    98.8  
    98.9  class AdapterHandlerEntry;
   98.10  class AdapterHandlerTable;
   98.11 @@ -168,11 +169,11 @@
   98.12    static address raw_exception_handler_for_return_address(JavaThread* thread, address return_address);
   98.13    static address exception_handler_for_return_address(JavaThread* thread, address return_address);
   98.14  
   98.15 -#ifndef SERIALGC
   98.16 +#if INCLUDE_ALL_GCS
   98.17    // G1 write barriers
   98.18    static void g1_wb_pre(oopDesc* orig, JavaThread *thread);
   98.19    static void g1_wb_post(void* card_addr, JavaThread* thread);
   98.20 -#endif // !SERIALGC
   98.21 +#endif // INCLUDE_ALL_GCS
   98.22  
   98.23    // exception handling and implicit exceptions
   98.24    static address compute_compiled_exc_handler(nmethod* nm, address ret_pc, Handle& exception,

    99.1 --- a/src/share/vm/runtime/thread.cpp	Fri Jan 18 05:33:32 2013 -0800
    99.2 +++ b/src/share/vm/runtime/thread.cpp	Wed Jan 23 13:02:39 2013 -0500
    99.3 @@ -82,6 +82,7 @@
    99.4  #include "utilities/dtrace.hpp"
    99.5  #include "utilities/events.hpp"
    99.6  #include "utilities/preserveException.hpp"
    99.7 +#include "utilities/macros.hpp"
    99.8  #ifdef TARGET_OS_FAMILY_linux
    99.9  # include "os_linux.inline.hpp"
   99.10  #endif
   99.11 @@ -94,11 +95,11 @@
   99.12  #ifdef TARGET_OS_FAMILY_bsd
   99.13  # include "os_bsd.inline.hpp"
   99.14  #endif
   99.15 -#ifndef SERIALGC
   99.16 +#if INCLUDE_ALL_GCS
   99.17  #include "gc_implementation/concurrentMarkSweep/concurrentMarkSweepThread.hpp"
   99.18  #include "gc_implementation/g1/concurrentMarkThread.inline.hpp"
   99.19  #include "gc_implementation/parallelScavenge/pcTasks.hpp"
   99.20 -#endif
   99.21 +#endif // INCLUDE_ALL_GCS
   99.22  #ifdef COMPILER1
   99.23  #include "c1/c1_Compiler.hpp"
   99.24  #endif
   99.25 @@ -1482,17 +1483,17 @@
   99.26    pd_initialize();
   99.27  }
   99.28  
   99.29 -#ifndef SERIALGC
   99.30 +#if INCLUDE_ALL_GCS
   99.31  SATBMarkQueueSet JavaThread::_satb_mark_queue_set;
   99.32  DirtyCardQueueSet JavaThread::_dirty_card_queue_set;
   99.33 -#endif // !SERIALGC
   99.34 +#endif // INCLUDE_ALL_GCS
   99.35  
   99.36  JavaThread::JavaThread(bool is_attaching_via_jni) :
   99.37    Thread()
   99.38 -#ifndef SERIALGC
   99.39 +#if INCLUDE_ALL_GCS
   99.40    , _satb_mark_queue(&_satb_mark_queue_set),
   99.41    _dirty_card_queue(&_dirty_card_queue_set)
   99.42 -#endif // !SERIALGC
   99.43 +#endif // INCLUDE_ALL_GCS
   99.44  {
   99.45    initialize();
   99.46    if (is_attaching_via_jni) {
   99.47 @@ -1547,10 +1548,10 @@
   99.48  
   99.49  JavaThread::JavaThread(ThreadFunction entry_point, size_t stack_sz) :
   99.50    Thread()
   99.51 -#ifndef SERIALGC
   99.52 +#if INCLUDE_ALL_GCS
   99.53    , _satb_mark_queue(&_satb_mark_queue_set),
   99.54    _dirty_card_queue(&_dirty_card_queue_set)
   99.55 -#endif // !SERIALGC
   99.56 +#endif // INCLUDE_ALL_GCS
   99.57  {
   99.58    if (TraceThreadEvents) {
   99.59      tty->print_cr("creating thread %p", this);
   99.60 @@ -1896,19 +1897,19 @@
   99.61      JvmtiExport::cleanup_thread(this);
   99.62    }
   99.63  
   99.64 -#ifndef SERIALGC
   99.65 +#if INCLUDE_ALL_GCS
   99.66    // We must flush G1-related buffers before removing a thread from
   99.67    // the list of active threads.
   99.68    if (UseG1GC) {
   99.69      flush_barrier_queues();
   99.70    }
   99.71 -#endif
   99.72 +#endif // INCLUDE_ALL_GCS
   99.73  
   99.74    // Remove from list of active threads list, and notify VM thread if we are the last non-daemon thread
   99.75    Threads::remove(this);
   99.76  }
   99.77  
   99.78 -#ifndef SERIALGC
   99.79 +#if INCLUDE_ALL_GCS
   99.80  // Flush G1-related queues.
   99.81  void JavaThread::flush_barrier_queues() {
   99.82    satb_mark_queue().flush();
   99.83 @@ -1936,7 +1937,7 @@
   99.84    // active field set to true.
   99.85    assert(dirty_queue.is_active(), "dirty card queue should be active");
   99.86  }
   99.87 -#endif // !SERIALGC
   99.88 +#endif // INCLUDE_ALL_GCS
   99.89  
   99.90  void JavaThread::cleanup_failed_attach_current_thread() {
   99.91    if (get_thread_profiler() != NULL) {
   99.92 @@ -1964,11 +1965,11 @@
   99.93      tlab().make_parsable(true);  // retire TLAB, if any
   99.94    }
   99.95  
   99.96 -#ifndef SERIALGC
   99.97 +#if INCLUDE_ALL_GCS
   99.98    if (UseG1GC) {
   99.99      flush_barrier_queues();
  99.100    }
  99.101 -#endif
  99.102 +#endif // INCLUDE_ALL_GCS
  99.103  
  99.104    Threads::remove(this);
  99.105    delete this;
  99.106 @@ -3600,7 +3601,7 @@
  99.107      vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
  99.108    }
  99.109  
  99.110 -#ifndef SERIALGC
  99.111 +#if INCLUDE_ALL_GCS
  99.112    // Support for ConcurrentMarkSweep. This should be cleaned up
  99.113    // and better encapsulated. The ugly nested if test would go away
  99.114    // once things are properly refactored. XXX YSR
  99.115 @@ -3614,7 +3615,7 @@
  99.116        vm_exit_during_initialization(Handle(THREAD, PENDING_EXCEPTION));
  99.117      }
  99.118    }
  99.119 -#endif // SERIALGC
  99.120 +#endif // INCLUDE_ALL_GCS
  99.121  
  99.122    // Always call even when there are not JVMTI environments yet, since environments
  99.123    // may be attached late and JVMTI must track phases of VM execution
  99.124 @@ -4209,7 +4210,7 @@
  99.125    }
  99.126  }
  99.127  
  99.128 -#ifndef SERIALGC
  99.129 +#if INCLUDE_ALL_GCS
  99.130  // Used by ParallelScavenge
  99.131  void Threads::create_thread_roots_tasks(GCTaskQueue* q) {
  99.132    ALL_JAVA_THREADS(p) {
  99.133 @@ -4225,7 +4226,7 @@
  99.134    }
  99.135    q->enqueue(new ThreadRootsMarkingTask(VMThread::vm_thread()));
  99.136  }
  99.137 -#endif // SERIALGC
  99.138 +#endif // INCLUDE_ALL_GCS
  99.139  
  99.140  void Threads::nmethods_do(CodeBlobClosure* cf) {
  99.141    ALL_JAVA_THREADS(p) {
  99.142 @@ -4333,13 +4334,13 @@
  99.143                 );
  99.144    st->cr();
  99.145  
  99.146 -#ifndef SERIALGC
  99.147 +#if INCLUDE_ALL_GCS
  99.148    // Dump concurrent locks
  99.149    ConcurrentLocksDump concurrent_locks;
  99.150    if (print_concurrent_locks) {
  99.151      concurrent_locks.dump_at_safepoint();
  99.152    }
  99.153 -#endif // SERIALGC
  99.154 +#endif // INCLUDE_ALL_GCS
  99.155  
  99.156    ALL_JAVA_THREADS(p) {
  99.157      ResourceMark rm;
  99.158 @@ -4352,11 +4353,11 @@
  99.159        }
  99.160      }
  99.161      st->cr();
  99.162 -#ifndef SERIALGC
  99.163 +#if INCLUDE_ALL_GCS
  99.164      if (print_concurrent_locks) {
  99.165        concurrent_locks.print_locks_on(p, st);
  99.166      }
  99.167 -#endif // SERIALGC
  99.168 +#endif // INCLUDE_ALL_GCS
  99.169    }
  99.170  
  99.171    VMThread::vm_thread()->print_on(st);