diff --git a/rts/RtsFlags.c b/rts/RtsFlags.c
index 12bb44ce98cc3d21b9ccc3f91e95e614dec7bfdf..573e701dc76a23fa9683a146d286afb0a3545146 100644
--- a/rts/RtsFlags.c
+++ b/rts/RtsFlags.c
@@ -99,23 +99,23 @@ void initRtsFlagsDefaults(void)
if (maxStkSize == 0)
maxStkSize = (8 * 1024 * 1024) / sizeof(W_);
- RtsFlags.GcFlags.statsFile = NULL;
- RtsFlags.GcFlags.giveStats = NO_GC_STATS;
+ RtsFlags.GcFlags.statsFile = NULL;
+ RtsFlags.GcFlags.giveStats = NO_GC_STATS;
- RtsFlags.GcFlags.maxStkSize = maxStkSize;
- RtsFlags.GcFlags.initialStkSize = 1024 / sizeof(W_);
+ RtsFlags.GcFlags.maxStkSize = maxStkSize;
+ RtsFlags.GcFlags.initialStkSize = 1024 / sizeof(W_);
RtsFlags.GcFlags.stkChunkSize = (32 * 1024) / sizeof(W_);
RtsFlags.GcFlags.stkChunkBufferSize = (1 * 1024) / sizeof(W_);
RtsFlags.GcFlags.minAllocAreaSize = (512 * 1024) / BLOCK_SIZE;
RtsFlags.GcFlags.minOldGenSize = (1024 * 1024) / BLOCK_SIZE;
- RtsFlags.GcFlags.maxHeapSize = 0; /* off by default */
- RtsFlags.GcFlags.heapSizeSuggestion = 0; /* none */
+ RtsFlags.GcFlags.maxHeapSize = 0; /* off by default */
+ RtsFlags.GcFlags.heapSizeSuggestion = 0; /* none */
RtsFlags.GcFlags.heapSizeSuggestionAuto = rtsFalse;
- RtsFlags.GcFlags.pcFreeHeap = 3; /* 3% */
+ RtsFlags.GcFlags.pcFreeHeap = 3; /* 3% */
RtsFlags.GcFlags.oldGenFactor = 2;
RtsFlags.GcFlags.generations = 2;
- RtsFlags.GcFlags.squeezeUpdFrames = rtsTrue;
+ RtsFlags.GcFlags.squeezeUpdFrames = rtsTrue;
RtsFlags.GcFlags.compact = rtsFalse;
RtsFlags.GcFlags.compactThreshold = 30.0;
RtsFlags.GcFlags.sweep = rtsFalse;
@@ -139,25 +139,25 @@ void initRtsFlagsDefaults(void)
#endif
#ifdef DEBUG
- RtsFlags.DebugFlags.scheduler = rtsFalse;
- RtsFlags.DebugFlags.interpreter = rtsFalse;
- RtsFlags.DebugFlags.weak = rtsFalse;
- RtsFlags.DebugFlags.gccafs = rtsFalse;
- RtsFlags.DebugFlags.gc = rtsFalse;
- RtsFlags.DebugFlags.block_alloc = rtsFalse;
- RtsFlags.DebugFlags.sanity = rtsFalse;
- RtsFlags.DebugFlags.stable = rtsFalse;
+ RtsFlags.DebugFlags.scheduler = rtsFalse;
+ RtsFlags.DebugFlags.interpreter = rtsFalse;
+ RtsFlags.DebugFlags.weak = rtsFalse;
+ RtsFlags.DebugFlags.gccafs = rtsFalse;
+ RtsFlags.DebugFlags.gc = rtsFalse;
+ RtsFlags.DebugFlags.block_alloc = rtsFalse;
+ RtsFlags.DebugFlags.sanity = rtsFalse;
+ RtsFlags.DebugFlags.stable = rtsFalse;
RtsFlags.DebugFlags.stm = rtsFalse;
- RtsFlags.DebugFlags.prof = rtsFalse;
- RtsFlags.DebugFlags.apply = rtsFalse;
- RtsFlags.DebugFlags.linker = rtsFalse;
- RtsFlags.DebugFlags.squeeze = rtsFalse;
- RtsFlags.DebugFlags.hpc = rtsFalse;
- RtsFlags.DebugFlags.sparks = rtsFalse;
+ RtsFlags.DebugFlags.prof = rtsFalse;
+ RtsFlags.DebugFlags.apply = rtsFalse;
+ RtsFlags.DebugFlags.linker = rtsFalse;
+ RtsFlags.DebugFlags.squeeze = rtsFalse;
+ RtsFlags.DebugFlags.hpc = rtsFalse;
+ RtsFlags.DebugFlags.sparks = rtsFalse;
#endif
#if defined(PROFILING)
- RtsFlags.CcFlags.doCostCentres = 0;
+ RtsFlags.CcFlags.doCostCentres = 0;
#endif /* PROFILING */
RtsFlags.ProfFlags.doHeapProfile = rtsFalse;
@@ -200,7 +200,7 @@ void initRtsFlagsDefaults(void)
RtsFlags.MiscFlags.linkerMemBase = 0;
#ifdef THREADED_RTS
- RtsFlags.ParFlags.nNodes = 1;
+ RtsFlags.ParFlags.nNodes = 1;
RtsFlags.ParFlags.migrate = rtsTrue;
RtsFlags.ParFlags.parGcEnabled = 1;
RtsFlags.ParFlags.parGcGen = 0;
@@ -211,12 +211,12 @@ void initRtsFlagsDefaults(void)
#endif
#if defined(THREADED_RTS)
- RtsFlags.ParFlags.maxLocalSparks = 4096;
+ RtsFlags.ParFlags.maxLocalSparks = 4096;
#endif /* THREADED_RTS */
#ifdef TICKY_TICKY
- RtsFlags.TickyFlags.showTickyStats = rtsFalse;
- RtsFlags.TickyFlags.tickyFile = NULL;
+ RtsFlags.TickyFlags.showTickyStats = rtsFalse;
+ RtsFlags.TickyFlags.tickyFile = NULL;
#endif
#ifdef USE_PAPI
@@ -437,18 +437,18 @@ static void splitRtsFlags(const char *s)
c1 = s;
do {
- while (isspace(*c1)) { c1++; };
- c2 = c1;
- while (!isspace(*c2) && *c2 != '\0') { c2++; };
+ while (isspace(*c1)) { c1++; };
+ c2 = c1;
+ while (!isspace(*c2) && *c2 != '\0') { c2++; };
- if (c1 == c2) { break; }
+ if (c1 == c2) { break; }
t = stgMallocBytes(c2-c1+1, "RtsFlags.c:splitRtsFlags()");
strncpy(t, c1, c2-c1);
t[c2-c1] = '\0';
appendRtsArg(t);
- c1 = c2;
+ c1 = c2;
} while (*c1 != '\0');
}
@@ -505,7 +505,7 @@ void setupRtsFlags (int *argc, char *argv[],
// (arguments from the GHCRTS environment variable and the command
// line override these).
{
- if (ghc_rts_opts != NULL) {
+ if (ghc_rts_opts != NULL) {
splitRtsFlags(ghc_rts_opts);
// opts from ghc_rts_opts are always enabled:
procRtsOpts(is_hs_main, rts_argc0, RtsOptsAll);
@@ -516,9 +516,9 @@ void setupRtsFlags (int *argc, char *argv[],
// process arguments from the GHCRTS environment variable next
// (arguments from the command line override these).
{
- char *ghc_rts = getenv("GHCRTS");
+ char *ghc_rts = getenv("GHCRTS");
- if (ghc_rts != NULL) {
+ if (ghc_rts != NULL) {
if (rtsOptsEnabled == RtsOptsNone) {
errorRtsOptsDisabled(is_hs_main, "Warning: Ignoring GHCRTS variable as RTS options are disabled.\n %s");
// We don't actually exit, just warn
@@ -534,32 +534,32 @@ void setupRtsFlags (int *argc, char *argv[],
// argv[0] must be PGM argument -- leave in argv
for (mode = PGM; arg < total_arg; arg++) {
- // The '--RTS' argument disables all future +RTS ... -RTS processing.
- if (strequal("--RTS", argv[arg])) {
- arg++;
- break;
- }
- // The '--' argument is passed through to the program, but
- // disables all further +RTS ... -RTS processing.
- else if (strequal("--", argv[arg])) {
- break;
- }
- else if (strequal("+RTS", argv[arg])) {
+ // The '--RTS' argument disables all future +RTS ... -RTS processing.
+ if (strequal("--RTS", argv[arg])) {
+ arg++;
+ break;
+ }
+ // The '--' argument is passed through to the program, but
+ // disables all further +RTS ... -RTS processing.
+ else if (strequal("--", argv[arg])) {
+ break;
+ }
+ else if (strequal("+RTS", argv[arg])) {
mode = RTS;
}
- else if (strequal("-RTS", argv[arg])) {
- mode = PGM;
- }
+ else if (strequal("-RTS", argv[arg])) {
+ mode = PGM;
+ }
else if (mode == RTS) {
appendRtsArg(copyArg(argv[arg]));
}
else {
argv[(*argc)++] = argv[arg];
- }
+ }
}
// process remaining program arguments
for (; arg < total_arg; arg++) {
- argv[(*argc)++] = argv[arg];
+ argv[(*argc)++] = argv[arg];
}
argv[*argc] = (char *) 0;
@@ -588,8 +588,8 @@ void setupRtsFlags (int *argc, char *argv[],
static void checkSuid(HsBool is_hs_main, RtsOptsEnabledEnum enabled)
{
if (enabled == RtsOptsSafeOnly) {
- /* This doesn't cover linux/posix capabilities like CAP_DAC_OVERRIDE,
- we'd have to link with -lcap for that. */
+ /* This doesn't cover linux/posix capabilities like CAP_DAC_OVERRIDE,
+ we'd have to link with -lcap for that. */
if ((getuid() != geteuid()) || (getgid() != getegid())) {
errorRtsOptsDisabled(is_hs_main, "RTS options are disabled for setuid binaries. %s");
stg_exit(EXIT_FAILURE);
@@ -628,29 +628,29 @@ static void procRtsOpts (HsBool is_hs_main, int rts_argc0, RtsOptsEnabledEnum rt
for (arg = rts_argc0; arg < rts_argc; arg++) {
/* We handle RtsOptsSafeOnly mode by declaring each option as
- either OPTION_SAFE or OPTION_UNSAFE. To make sure we cover
- every branch we use an option_checked flag which is reset
- at the start each iteration and checked at the end. */
+ either OPTION_SAFE or OPTION_UNSAFE. To make sure we cover
+ every branch we use an option_checked flag which is reset
+ at the start each iteration and checked at the end. */
rtsBool option_checked = rtsFalse;
#define OPTION_SAFE option_checked = rtsTrue;
#define OPTION_UNSAFE checkUnsafe(is_hs_main, rtsOptsEnabled); option_checked = rtsTrue;
if (rts_argv[arg][0] != '-') {
- fflush(stdout);
- errorBelch("unexpected RTS argument: %s", rts_argv[arg]);
- error = rtsTrue;
+ fflush(stdout);
+ errorBelch("unexpected RTS argument: %s", rts_argv[arg]);
+ error = rtsTrue;
} else {
switch(rts_argv[arg][1]) {
- /* process: general args, then PROFILING-only ones, then
- CONCURRENT-only, TICKY-only (same order as defined in
- RtsFlags.lh); within those groups, mostly in
- case-insensitive alphabetical order. Final group is
- x*, which allows for more options.
- */
+ /* process: general args, then PROFILING-only ones, then
+ CONCURRENT-only, TICKY-only (same order as defined in
+ RtsFlags.lh); within those groups, mostly in
+ case-insensitive alphabetical order. Final group is
+ x*, which allows for more options.
+ */
#ifdef TICKY_TICKY
# define TICKY_BUILD_ONLY(x) x
@@ -692,16 +692,16 @@ errorBelch("the flag %s requires the program to be built with -debug", rts_argv[
error = rtsTrue;
#endif
- /* =========== GENERAL ========================== */
- case '?':
- OPTION_SAFE;
- error = rtsTrue;
- break;
+ /* =========== GENERAL ========================== */
+ case '?':
+ OPTION_SAFE;
+ error = rtsTrue;
+ break;
/* This isn't going to allow us to keep related options
together as we add more --* flags. We really need a
proper options parser. */
- case '-':
+ case '-':
if (strequal("install-signal-handlers=yes",
&rts_argv[arg][2])) {
OPTION_UNSAFE;
@@ -724,37 +724,37 @@ error = rtsTrue;
stg_exit(0);
}
else {
- OPTION_SAFE;
- errorBelch("unknown RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
+ OPTION_SAFE;
+ errorBelch("unknown RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
}
- break;
- case 'A':
- OPTION_UNSAFE;
+ break;
+ case 'A':
+ OPTION_UNSAFE;
RtsFlags.GcFlags.minAllocAreaSize
= decodeSize(rts_argv[arg], 2, BLOCK_SIZE, HS_INT_MAX)
/ BLOCK_SIZE;
break;
#ifdef USE_PAPI
- case 'a':
- OPTION_UNSAFE;
- switch(rts_argv[arg][2]) {
- case '1':
- RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L1;
- break;
- case '2':
- RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L2;
- break;
- case 'b':
- RtsFlags.PapiFlags.eventType = PAPI_FLAG_BRANCH;
- break;
- case 's':
- RtsFlags.PapiFlags.eventType = PAPI_FLAG_STALLS;
- break;
- case 'e':
- RtsFlags.PapiFlags.eventType = PAPI_FLAG_CB_EVENTS;
- break;
+ case 'a':
+ OPTION_UNSAFE;
+ switch(rts_argv[arg][2]) {
+ case '1':
+ RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L1;
+ break;
+ case '2':
+ RtsFlags.PapiFlags.eventType = PAPI_FLAG_CACHE_L2;
+ break;
+ case 'b':
+ RtsFlags.PapiFlags.eventType = PAPI_FLAG_BRANCH;
+ break;
+ case 's':
+ RtsFlags.PapiFlags.eventType = PAPI_FLAG_STALLS;
+ break;
+ case 'e':
+ RtsFlags.PapiFlags.eventType = PAPI_FLAG_CB_EVENTS;
+ break;
case '+':
case '#':
if (RtsFlags.PapiFlags.numUserEvents >= MAX_PAPI_USER_EVENTS) {
@@ -769,112 +769,112 @@ error = rtsTrue;
RtsFlags.PapiFlags.eventType = PAPI_USER_EVENTS;
RtsFlags.PapiFlags.userEventsKind[eventNum] = eventKind;
break;
- default:
- bad_option( rts_argv[arg] );
- }
- break;
+ default:
+ bad_option( rts_argv[arg] );
+ }
+ break;
#endif
- case 'B':
- OPTION_UNSAFE;
- RtsFlags.GcFlags.ringBell = rtsTrue;
- break;
-
- case 'c':
- OPTION_UNSAFE;
- if (rts_argv[arg][2] != '\0') {
- RtsFlags.GcFlags.compactThreshold =
- atof(rts_argv[arg]+2);
- } else {
- RtsFlags.GcFlags.compact = rtsTrue;
- }
- break;
+ case 'B':
+ OPTION_UNSAFE;
+ RtsFlags.GcFlags.ringBell = rtsTrue;
+ break;
+
+ case 'c':
+ OPTION_UNSAFE;
+ if (rts_argv[arg][2] != '\0') {
+ RtsFlags.GcFlags.compactThreshold =
+ atof(rts_argv[arg]+2);
+ } else {
+ RtsFlags.GcFlags.compact = rtsTrue;
+ }
+ break;
case 'w':
- OPTION_UNSAFE;
- RtsFlags.GcFlags.sweep = rtsTrue;
- break;
+ OPTION_UNSAFE;
+ RtsFlags.GcFlags.sweep = rtsTrue;
+ break;
- case 'F':
- OPTION_UNSAFE;
- RtsFlags.GcFlags.oldGenFactor = atof(rts_argv[arg]+2);
+ case 'F':
+ OPTION_UNSAFE;
+ RtsFlags.GcFlags.oldGenFactor = atof(rts_argv[arg]+2);
- if (RtsFlags.GcFlags.oldGenFactor < 0)
- bad_option( rts_argv[arg] );
- break;
+ if (RtsFlags.GcFlags.oldGenFactor < 0)
+ bad_option( rts_argv[arg] );
+ break;
- case 'D':
+ case 'D':
OPTION_SAFE;
DEBUG_BUILD_ONLY(
- {
- char *c;
-
- for (c = rts_argv[arg] + 2; *c != '\0'; c++) {
- switch (*c) {
- case 's':
- RtsFlags.DebugFlags.scheduler = rtsTrue;
- break;
- case 'i':
- RtsFlags.DebugFlags.interpreter = rtsTrue;
- break;
- case 'w':
- RtsFlags.DebugFlags.weak = rtsTrue;
- break;
- case 'G':
- RtsFlags.DebugFlags.gccafs = rtsTrue;
- break;
- case 'g':
- RtsFlags.DebugFlags.gc = rtsTrue;
- break;
- case 'b':
- RtsFlags.DebugFlags.block_alloc = rtsTrue;
- break;
- case 'S':
- RtsFlags.DebugFlags.sanity = rtsTrue;
- break;
- case 't':
- RtsFlags.DebugFlags.stable = rtsTrue;
- break;
- case 'p':
- RtsFlags.DebugFlags.prof = rtsTrue;
- break;
- case 'l':
- RtsFlags.DebugFlags.linker = rtsTrue;
- break;
- case 'a':
- RtsFlags.DebugFlags.apply = rtsTrue;
- break;
- case 'm':
- RtsFlags.DebugFlags.stm = rtsTrue;
- break;
- case 'z':
- RtsFlags.DebugFlags.squeeze = rtsTrue;
- break;
- case 'c':
- RtsFlags.DebugFlags.hpc = rtsTrue;
- break;
- case 'r':
- RtsFlags.DebugFlags.sparks = rtsTrue;
- break;
- default:
- bad_option( rts_argv[arg] );
- }
- }
+ {
+ char *c;
+
+ for (c = rts_argv[arg] + 2; *c != '\0'; c++) {
+ switch (*c) {
+ case 's':
+ RtsFlags.DebugFlags.scheduler = rtsTrue;
+ break;
+ case 'i':
+ RtsFlags.DebugFlags.interpreter = rtsTrue;
+ break;
+ case 'w':
+ RtsFlags.DebugFlags.weak = rtsTrue;
+ break;
+ case 'G':
+ RtsFlags.DebugFlags.gccafs = rtsTrue;
+ break;
+ case 'g':
+ RtsFlags.DebugFlags.gc = rtsTrue;
+ break;
+ case 'b':
+ RtsFlags.DebugFlags.block_alloc = rtsTrue;
+ break;
+ case 'S':
+ RtsFlags.DebugFlags.sanity = rtsTrue;
+ break;
+ case 't':
+ RtsFlags.DebugFlags.stable = rtsTrue;
+ break;
+ case 'p':
+ RtsFlags.DebugFlags.prof = rtsTrue;
+ break;
+ case 'l':
+ RtsFlags.DebugFlags.linker = rtsTrue;
+ break;
+ case 'a':
+ RtsFlags.DebugFlags.apply = rtsTrue;
+ break;
+ case 'm':
+ RtsFlags.DebugFlags.stm = rtsTrue;
+ break;
+ case 'z':
+ RtsFlags.DebugFlags.squeeze = rtsTrue;
+ break;
+ case 'c':
+ RtsFlags.DebugFlags.hpc = rtsTrue;
+ break;
+ case 'r':
+ RtsFlags.DebugFlags.sparks = rtsTrue;
+ break;
+ default:
+ bad_option( rts_argv[arg] );
+ }
+ }
// -Dx also turns on -v. Use -l to direct trace
// events to the .eventlog file instead.
RtsFlags.TraceFlags.tracing = TRACE_STDERR;
- })
+ })
break;
- case 'K':
- OPTION_UNSAFE;
+ case 'K':
+ OPTION_UNSAFE;
RtsFlags.GcFlags.maxStkSize =
decodeSize(rts_argv[arg], 2, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
break;
- case 'k':
- OPTION_UNSAFE;
- switch(rts_argv[arg][2]) {
+ case 'k':
+ OPTION_UNSAFE;
+ switch(rts_argv[arg][2]) {
case 'c':
RtsFlags.GcFlags.stkChunkSize =
decodeSize(rts_argv[arg], 3, sizeof(W_), HS_WORD_MAX) / sizeof(W_);
@@ -895,14 +895,14 @@ error = rtsTrue;
break;
case 'M':
- OPTION_UNSAFE;
+ OPTION_UNSAFE;
RtsFlags.GcFlags.maxHeapSize =
decodeSize(rts_argv[arg], 2, BLOCK_SIZE, HS_WORD_MAX) / BLOCK_SIZE;
/* user give size in *bytes* but "maxHeapSize" is in *blocks* */
break;
- case 'm':
- OPTION_UNSAFE;
+ case 'm':
+ OPTION_UNSAFE;
RtsFlags.GcFlags.pcFreeHeap = atof(rts_argv[arg]+2);
if (RtsFlags.GcFlags.pcFreeHeap < 0 ||
@@ -910,14 +910,14 @@ error = rtsTrue;
bad_option( rts_argv[arg] );
break;
- case 'G':
- OPTION_UNSAFE;
+ case 'G':
+ OPTION_UNSAFE;
RtsFlags.GcFlags.generations =
decodeSize(rts_argv[arg], 2, 1, HS_INT_MAX);
break;
- case 'H':
- OPTION_UNSAFE;
+ case 'H':
+ OPTION_UNSAFE;
if (rts_argv[arg][2] == '\0') {
RtsFlags.GcFlags.heapSizeSuggestionAuto = rtsTrue;
} else {
@@ -926,11 +926,11 @@ error = rtsTrue;
}
break;
- case 'I': /* idle GC delay */
- OPTION_UNSAFE;
- if (rts_argv[arg][2] == '\0') {
- /* use default */
- } else {
+ case 'I': /* idle GC delay */
+ OPTION_UNSAFE;
+ if (rts_argv[arg][2] == '\0') {
+ /* use default */
+ } else {
Time t = fsecondsToTime(atof(rts_argv[arg]+2));
if (t == 0) {
RtsFlags.GcFlags.doIdleGC = rtsFalse;
@@ -938,225 +938,225 @@ error = rtsTrue;
RtsFlags.GcFlags.doIdleGC = rtsTrue;
RtsFlags.GcFlags.idleGCDelayTime = t;
}
- }
- break;
+ }
+ break;
case 'T':
- OPTION_SAFE;
+ OPTION_SAFE;
RtsFlags.GcFlags.giveStats = COLLECT_GC_STATS;
break; /* Don't initialize statistics file. */
- case 'S':
- OPTION_SAFE; /* but see below */
- RtsFlags.GcFlags.giveStats = VERBOSE_GC_STATS;
- goto stats;
-
- case 's':
- OPTION_SAFE; /* but see below */
- RtsFlags.GcFlags.giveStats = SUMMARY_GC_STATS;
- goto stats;
-
- case 't':
- OPTION_SAFE; /* but see below */
- RtsFlags.GcFlags.giveStats = ONELINE_GC_STATS;
- goto stats;
-
- stats:
- {
- int r;
- if (rts_argv[arg][2] != '\0') {
- OPTION_UNSAFE;
- }
+ case 'S':
+ OPTION_SAFE; /* but see below */
+ RtsFlags.GcFlags.giveStats = VERBOSE_GC_STATS;
+ goto stats;
+
+ case 's':
+ OPTION_SAFE; /* but see below */
+ RtsFlags.GcFlags.giveStats = SUMMARY_GC_STATS;
+ goto stats;
+
+ case 't':
+ OPTION_SAFE; /* but see below */
+ RtsFlags.GcFlags.giveStats = ONELINE_GC_STATS;
+ goto stats;
+
+ stats:
+ {
+ int r;
+ if (rts_argv[arg][2] != '\0') {
+ OPTION_UNSAFE;
+ }
r = openStatsFile(rts_argv[arg]+2, NULL,
&RtsFlags.GcFlags.statsFile);
- if (r == -1) { error = rtsTrue; }
- }
+ if (r == -1) { error = rtsTrue; }
+ }
break;
- case 'Z':
- OPTION_UNSAFE;
- RtsFlags.GcFlags.squeezeUpdFrames = rtsFalse;
- break;
+ case 'Z':
+ OPTION_UNSAFE;
+ RtsFlags.GcFlags.squeezeUpdFrames = rtsFalse;
+ break;
- /* =========== PROFILING ========================== */
+ /* =========== PROFILING ========================== */
- case 'P': /* detailed cost centre profiling (time/alloc) */
- case 'p': /* cost centre profiling (time/alloc) */
- OPTION_SAFE;
- PROFILING_BUILD_ONLY(
- switch (rts_argv[arg][2]) {
+ case 'P': /* detailed cost centre profiling (time/alloc) */
+ case 'p': /* cost centre profiling (time/alloc) */
+ OPTION_SAFE;
+ PROFILING_BUILD_ONLY(
+ switch (rts_argv[arg][2]) {
case 'a':
- RtsFlags.CcFlags.doCostCentres = COST_CENTRES_ALL;
- break;
- default:
- if (rts_argv[arg][1] == 'P') {
- RtsFlags.CcFlags.doCostCentres =
- COST_CENTRES_VERBOSE;
- } else {
- RtsFlags.CcFlags.doCostCentres =
- COST_CENTRES_SUMMARY;
- }
- break;
- }
- ) break;
-
- case 'R':
- OPTION_SAFE;
- PROFILING_BUILD_ONLY(
- RtsFlags.ProfFlags.maxRetainerSetSize = atof(rts_argv[arg]+2);
- ) break;
- case 'L':
- OPTION_SAFE;
- PROFILING_BUILD_ONLY(
- RtsFlags.ProfFlags.ccsLength = atof(rts_argv[arg]+2);
+ RtsFlags.CcFlags.doCostCentres = COST_CENTRES_ALL;
+ break;
+ default:
+ if (rts_argv[arg][1] == 'P') {
+ RtsFlags.CcFlags.doCostCentres =
+ COST_CENTRES_VERBOSE;
+ } else {
+ RtsFlags.CcFlags.doCostCentres =
+ COST_CENTRES_SUMMARY;
+ }
+ break;
+ }
+ ) break;
+
+ case 'R':
+ OPTION_SAFE;
+ PROFILING_BUILD_ONLY(
+ RtsFlags.ProfFlags.maxRetainerSetSize = atof(rts_argv[arg]+2);
+ ) break;
+ case 'L':
+ OPTION_SAFE;
+ PROFILING_BUILD_ONLY(
+ RtsFlags.ProfFlags.ccsLength = atof(rts_argv[arg]+2);
if(RtsFlags.ProfFlags.ccsLength <= 0) {
- bad_option(rts_argv[arg]);
+ bad_option(rts_argv[arg]);
}
- ) break;
- case 'h': /* serial heap profile */
+ ) break;
+ case 'h': /* serial heap profile */
#if !defined(PROFILING)
- OPTION_UNSAFE;
- switch (rts_argv[arg][2]) {
- case '\0':
- case 'T':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CLOSURE_TYPE;
- break;
- default:
- errorBelch("invalid heap profile option: %s",rts_argv[arg]);
- error = rtsTrue;
- }
+ OPTION_UNSAFE;
+ switch (rts_argv[arg][2]) {
+ case '\0':
+ case 'T':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CLOSURE_TYPE;
+ break;
+ default:
+ errorBelch("invalid heap profile option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ }
#else
- OPTION_SAFE;
- PROFILING_BUILD_ONLY(
- switch (rts_argv[arg][2]) {
- case '\0':
- case 'C':
- case 'c':
- case 'M':
- case 'm':
- case 'D':
- case 'd':
- case 'Y':
- case 'y':
- case 'R':
- case 'r':
- case 'B':
- case 'b':
- if (rts_argv[arg][2] != '\0' && rts_argv[arg][3] != '\0') {
- {
- char *left = strchr(rts_argv[arg], '{');
- char *right = strrchr(rts_argv[arg], '}');
-
- // curly braces are optional, for
- // backwards compat.
- if (left)
- left = left+1;
- else
- left = rts_argv[arg] + 3;
-
- if (!right)
- right = rts_argv[arg] + strlen(rts_argv[arg]);
-
- *right = '\0';
-
- switch (rts_argv[arg][2]) {
- case 'c': // cost centre label select
- RtsFlags.ProfFlags.ccSelector = left;
- break;
- case 'C':
- RtsFlags.ProfFlags.ccsSelector = left;
- break;
- case 'M':
- case 'm': // cost centre module select
- RtsFlags.ProfFlags.modSelector = left;
- break;
- case 'D':
- case 'd': // closure descr select
- RtsFlags.ProfFlags.descrSelector = left;
- break;
- case 'Y':
- case 'y': // closure type select
- RtsFlags.ProfFlags.typeSelector = left;
- break;
- case 'R':
- case 'r': // retainer select
- RtsFlags.ProfFlags.retainerSelector = left;
- break;
- case 'B':
- case 'b': // biography select
- RtsFlags.ProfFlags.bioSelector = left;
- break;
- }
- }
- break;
- }
-
- if (RtsFlags.ProfFlags.doHeapProfile != 0) {
- errorBelch("multiple heap profile options");
- error = rtsTrue;
- break;
- }
-
- switch (rts_argv[arg][2]) {
- case '\0':
- case 'C':
- case 'c':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CCS;
- break;
- case 'M':
- case 'm':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_MOD;
- break;
- case 'D':
- case 'd':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_DESCR;
- break;
- case 'Y':
- case 'y':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_TYPE;
- break;
- case 'R':
- case 'r':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_RETAINER;
- break;
- case 'B':
- case 'b':
- RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_LDV;
- break;
- }
- break;
-
- default:
- errorBelch("invalid heap profile option: %s",rts_argv[arg]);
- error = rtsTrue;
- }
- )
+ OPTION_SAFE;
+ PROFILING_BUILD_ONLY(
+ switch (rts_argv[arg][2]) {
+ case '\0':
+ case 'C':
+ case 'c':
+ case 'M':
+ case 'm':
+ case 'D':
+ case 'd':
+ case 'Y':
+ case 'y':
+ case 'R':
+ case 'r':
+ case 'B':
+ case 'b':
+ if (rts_argv[arg][2] != '\0' && rts_argv[arg][3] != '\0') {
+ {
+ char *left = strchr(rts_argv[arg], '{');
+ char *right = strrchr(rts_argv[arg], '}');
+
+ // curly braces are optional, for
+ // backwards compat.
+ if (left)
+ left = left+1;
+ else
+ left = rts_argv[arg] + 3;
+
+ if (!right)
+ right = rts_argv[arg] + strlen(rts_argv[arg]);
+
+ *right = '\0';
+
+ switch (rts_argv[arg][2]) {
+ case 'c': // cost centre label select
+ RtsFlags.ProfFlags.ccSelector = left;
+ break;
+ case 'C':
+ RtsFlags.ProfFlags.ccsSelector = left;
+ break;
+ case 'M':
+ case 'm': // cost centre module select
+ RtsFlags.ProfFlags.modSelector = left;
+ break;
+ case 'D':
+ case 'd': // closure descr select
+ RtsFlags.ProfFlags.descrSelector = left;
+ break;
+ case 'Y':
+ case 'y': // closure type select
+ RtsFlags.ProfFlags.typeSelector = left;
+ break;
+ case 'R':
+ case 'r': // retainer select
+ RtsFlags.ProfFlags.retainerSelector = left;
+ break;
+ case 'B':
+ case 'b': // biography select
+ RtsFlags.ProfFlags.bioSelector = left;
+ break;
+ }
+ }
+ break;
+ }
+
+ if (RtsFlags.ProfFlags.doHeapProfile != 0) {
+ errorBelch("multiple heap profile options");
+ error = rtsTrue;
+ break;
+ }
+
+ switch (rts_argv[arg][2]) {
+ case '\0':
+ case 'C':
+ case 'c':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_CCS;
+ break;
+ case 'M':
+ case 'm':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_MOD;
+ break;
+ case 'D':
+ case 'd':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_DESCR;
+ break;
+ case 'Y':
+ case 'y':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_TYPE;
+ break;
+ case 'R':
+ case 'r':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_RETAINER;
+ break;
+ case 'B':
+ case 'b':
+ RtsFlags.ProfFlags.doHeapProfile = HEAP_BY_LDV;
+ break;
+ }
+ break;
+
+ default:
+ errorBelch("invalid heap profile option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ }
+ )
#endif /* PROFILING */
- break;
+ break;
- case 'i': /* heap sample interval */
- OPTION_UNSAFE;
- if (rts_argv[arg][2] == '\0') {
- /* use default */
- } else {
+ case 'i': /* heap sample interval */
+ OPTION_UNSAFE;
+ if (rts_argv[arg][2] == '\0') {
+ /* use default */
+ } else {
RtsFlags.ProfFlags.heapProfileInterval =
fsecondsToTime(atof(rts_argv[arg]+2));
}
- break;
-
- /* =========== CONCURRENT ========================= */
- case 'C': /* context switch interval */
- OPTION_UNSAFE;
- if (rts_argv[arg][2] == '\0')
- RtsFlags.ConcFlags.ctxtSwitchTime = 0;
- else {
+ break;
+
+ /* =========== CONCURRENT ========================= */
+ case 'C': /* context switch interval */
+ OPTION_UNSAFE;
+ if (rts_argv[arg][2] == '\0')
+ RtsFlags.ConcFlags.ctxtSwitchTime = 0;
+ else {
RtsFlags.ConcFlags.ctxtSwitchTime =
fsecondsToTime(atof(rts_argv[arg]+2));
}
- break;
+ break;
case 'V': /* master tick interval */
- OPTION_UNSAFE;
+ OPTION_UNSAFE;
if (rts_argv[arg][2] == '\0') {
// turns off ticks completely
RtsFlags.MiscFlags.tickInterval = 0;
@@ -1167,55 +1167,55 @@ error = rtsTrue;
break;
#if !defined(NOSMP)
- case 'N':
- OPTION_SAFE;
- THREADED_BUILD_ONLY(
- if (rts_argv[arg][2] == '\0') {
+ case 'N':
+ OPTION_SAFE;
+ THREADED_BUILD_ONLY(
+ if (rts_argv[arg][2] == '\0') {
#if defined(PROFILING)
- RtsFlags.ParFlags.nNodes = 1;
+ RtsFlags.ParFlags.nNodes = 1;
#else
RtsFlags.ParFlags.nNodes = getNumberOfProcessors();
#endif
- } else {
- int nNodes;
- OPTION_SAFE; /* but see extra checks below... */
- nNodes = strtol(rts_argv[arg]+2, (char **) NULL, 10);
- if (nNodes <= 0) {
- errorBelch("bad value for -N");
- error = rtsTrue;
- }
+ } else {
+ int nNodes;
+ OPTION_SAFE; /* but see extra checks below... */
+ nNodes = strtol(rts_argv[arg]+2, (char **) NULL, 10);
+ if (nNodes <= 0) {
+ errorBelch("bad value for -N");
+ error = rtsTrue;
+ }
if (rtsOptsEnabled == RtsOptsSafeOnly &&
- nNodes > (int)getNumberOfProcessors()) {
+ nNodes > (int)getNumberOfProcessors()) {
errorRtsOptsDisabled(is_hs_main, "Using large values for -N is not allowed by default. %s");
stg_exit(EXIT_FAILURE);
}
RtsFlags.ParFlags.nNodes = (nat)nNodes;
- }
- ) break;
+ }
+ ) break;
- case 'g':
- OPTION_UNSAFE;
- THREADED_BUILD_ONLY(
- switch (rts_argv[arg][2]) {
+ case 'g':
+ OPTION_UNSAFE;
+ THREADED_BUILD_ONLY(
+ switch (rts_argv[arg][2]) {
case '1':
// backwards compat only
RtsFlags.ParFlags.parGcEnabled = rtsFalse;
break;
- default:
- errorBelch("unknown RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
- break;
+ default:
+ errorBelch("unknown RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ break;
}
) break;
- case 'q':
- OPTION_UNSAFE;
- THREADED_BUILD_ONLY(
- switch (rts_argv[arg][2]) {
- case '\0':
- errorBelch("incomplete RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
- break;
+ case 'q':
+ OPTION_UNSAFE;
+ THREADED_BUILD_ONLY(
+ switch (rts_argv[arg][2]) {
+ case '\0':
+ errorBelch("incomplete RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ break;
case 'g':
if (rts_argv[arg][3] == '\0') {
RtsFlags.ParFlags.parGcEnabled = rtsFalse;
@@ -1225,7 +1225,7 @@ error = rtsTrue;
= strtol(rts_argv[arg]+3, (char **) NULL, 10);
}
break;
- case 'b':
+ case 'b':
if (rts_argv[arg][3] == '\0') {
RtsFlags.ParFlags.parGcLoadBalancingEnabled = rtsFalse;
}
@@ -1240,82 +1240,82 @@ error = rtsTrue;
= strtol(rts_argv[arg]+3, (char **) NULL, 10);
break;
case 'a':
- RtsFlags.ParFlags.setAffinity = rtsTrue;
- break;
- case 'm':
- RtsFlags.ParFlags.migrate = rtsFalse;
- break;
+ RtsFlags.ParFlags.setAffinity = rtsTrue;
+ break;
+ case 'm':
+ RtsFlags.ParFlags.migrate = rtsFalse;
+ break;
case 'w':
// -qw was removed; accepted for backwards compat
break;
default:
- errorBelch("unknown RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
- break;
- }
+ errorBelch("unknown RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ break;
+ }
) break;
#endif
- /* =========== PARALLEL =========================== */
- case 'e':
- OPTION_UNSAFE;
- THREADED_BUILD_ONLY(
- if (rts_argv[arg][2] != '\0') {
- RtsFlags.ParFlags.maxLocalSparks
- = strtol(rts_argv[arg]+2, (char **) NULL, 10);
- if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
- errorBelch("bad value for -e");
- error = rtsTrue;
- }
- }
- ) break;
-
- /* =========== TICKY ============================== */
-
- case 'r': /* Basic profiling stats */
- OPTION_SAFE;
- TICKY_BUILD_ONLY(
-
- RtsFlags.TickyFlags.showTickyStats = rtsTrue;
-
- {
- int r;
- if (rts_argv[arg][2] != '\0') {
- OPTION_UNSAFE;
- }
+ /* =========== PARALLEL =========================== */
+ case 'e':
+ OPTION_UNSAFE;
+ THREADED_BUILD_ONLY(
+ if (rts_argv[arg][2] != '\0') {
+ RtsFlags.ParFlags.maxLocalSparks
+ = strtol(rts_argv[arg]+2, (char **) NULL, 10);
+ if (RtsFlags.ParFlags.maxLocalSparks <= 0) {
+ errorBelch("bad value for -e");
+ error = rtsTrue;
+ }
+ }
+ ) break;
+
+ /* =========== TICKY ============================== */
+
+ case 'r': /* Basic profiling stats */
+ OPTION_SAFE;
+ TICKY_BUILD_ONLY(
+
+ RtsFlags.TickyFlags.showTickyStats = rtsTrue;
+
+ {
+ int r;
+ if (rts_argv[arg][2] != '\0') {
+ OPTION_UNSAFE;
+ }
r = openStatsFile(rts_argv[arg]+2,
TICKY_FILENAME_FMT,
&RtsFlags.TickyFlags.tickyFile);
- if (r == -1) { error = rtsTrue; }
- }
- ) break;
+ if (r == -1) { error = rtsTrue; }
+ }
+ ) break;
- /* =========== TRACING ---------=================== */
+ /* =========== TRACING ---------=================== */
case 'l':
- OPTION_SAFE;
+ OPTION_SAFE;
TRACING_BUILD_ONLY(
RtsFlags.TraceFlags.tracing = TRACE_EVENTLOG;
read_trace_flags(&rts_argv[arg][2]);
);
break;
- case 'v':
- OPTION_SAFE;
+ case 'v':
+ OPTION_SAFE;
DEBUG_BUILD_ONLY(
RtsFlags.TraceFlags.tracing = TRACE_STDERR;
read_trace_flags(&rts_argv[arg][2]);
);
break;
- /* =========== EXTENDED OPTIONS =================== */
+ /* =========== EXTENDED OPTIONS =================== */
case 'x': /* Extend the argument space */
switch(rts_argv[arg][2]) {
case '\0':
- OPTION_SAFE;
- errorBelch("incomplete RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
- break;
+ OPTION_SAFE;
+ errorBelch("incomplete RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ break;
case 'b': /* heapBase in hex; undocumented */
OPTION_UNSAFE;
@@ -1347,42 +1347,42 @@ error = rtsTrue;
case 'c': /* Debugging tool: show current cost centre on an exception */
OPTION_SAFE;
PROFILING_BUILD_ONLY(
- RtsFlags.ProfFlags.showCCSOnException = rtsTrue;
- );
- break;
+ RtsFlags.ProfFlags.showCCSOnException = rtsTrue;
+ );
+ break;
- case 't': /* Include memory used by TSOs in a heap profile */
- OPTION_SAFE;
- PROFILING_BUILD_ONLY(
- RtsFlags.ProfFlags.includeTSOs = rtsTrue;
- );
- break;
+ case 't': /* Include memory used by TSOs in a heap profile */
+ OPTION_SAFE;
+ PROFILING_BUILD_ONLY(
+ RtsFlags.ProfFlags.includeTSOs = rtsTrue;
+ );
+ break;
/* The option prefix '-xx' is reserved for future extension. KSW 1999-11. */
- default:
- OPTION_SAFE;
- errorBelch("unknown RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
- break;
+ default:
+ OPTION_SAFE;
+ errorBelch("unknown RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ break;
}
break; /* defensive programming */
- /* =========== OH DEAR ============================ */
- default:
- OPTION_SAFE;
- errorBelch("unknown RTS option: %s",rts_argv[arg]);
- error = rtsTrue;
- break;
- }
+ /* =========== OH DEAR ============================ */
+ default:
+ OPTION_SAFE;
+ errorBelch("unknown RTS option: %s",rts_argv[arg]);
+ error = rtsTrue;
+ break;
+ }
if (!option_checked) {
- /* Naughty! Someone didn't use OPTION_UNSAFE / OPTION_SAFE for
- an option above */
- errorBelch("Internal error in the RTS options parser");
- stg_exit(EXIT_FAILURE);
+ /* Naughty! Someone didn't use OPTION_UNSAFE / OPTION_SAFE for
+ an option above */
+ errorBelch("Internal error in the RTS options parser");
+ stg_exit(EXIT_FAILURE);
}
- }
+ }
}
if (error) errorUsage();
@@ -1466,9 +1466,9 @@ stats_fprintf(FILE *f, char *s, ...)
va_list ap;
va_start(ap,s);
if (f == NULL) {
- vdebugBelch(s, ap);
+ vdebugBelch(s, ap);
} else {
- vfprintf(f, s, ap);
+ vfprintf(f, s, ap);
}
va_end(ap);
}
@@ -1498,10 +1498,10 @@ openStatsFile (char *filename, // filename, or NULL
sprintf(stats_filename, filename_fmt, prog_name);
f = fopen(stats_filename,"w");
}
- if (f == NULL) {
+ if (f == NULL) {
errorBelch("Can't open stats file %s\n", filename);
- return -1;
- }
+ return -1;
+ }
}
*file_ret = f;
@@ -1709,18 +1709,18 @@ setProgName(char *argv[])
/* Remove directory from argv[0] -- default files in current directory */
#if !defined(mingw32_HOST_OS)
if ( (last_slash = (char *) strrchr(argv[0], '/')) != NULL ) {
- prog_name = last_slash+1;
+ prog_name = last_slash+1;
} else {
- prog_name = argv[0];
+ prog_name = argv[0];
}
#else
last_slash = argv[0] + (strlen(argv[0]) - 1);
while ( last_slash > argv[0] ) {
- if ( *last_slash == '/' || *last_slash == '\\' ) {
- prog_name = last_slash+1;
- return;
- }
- last_slash--;
+ if ( *last_slash == '/' || *last_slash == '\\' ) {
+ prog_name = last_slash+1;
+ return;
+ }
+ last_slash--;
}
prog_name = argv[0];
#endif
@@ -1811,15 +1811,15 @@ getWin32ProgArgv(int *argc, wchar_t **argv[])
void
setWin32ProgArgv(int argc, wchar_t *argv[])
{
- int i;
+ int i;
- freeWin32ProgArgv();
+ freeWin32ProgArgv();
win32_prog_argc = argc;
- if (argv == NULL) {
- win32_prog_argv = NULL;
- return;
- }
+ if (argv == NULL) {
+ win32_prog_argv = NULL;
+ return;
+ }
win32_prog_argv = stgCallocBytes(argc + 1, sizeof (wchar_t *),
"setWin32ProgArgv 1");