Improve error message when '=' is missing in {ASAN,...}_OPTIONS.

[marxin]

Summary

It's handling isses as described here:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=89832

Patch by Martin Liška.

[marxin]

I've made the error message more verbose.

[marxin]

May I please ping this..

[marxin]

Updated patch with a test-case.

[vitalybuka]

lib/asan/asan_flags.cc

123 ↗

(On Diff #199771)

If we are making ParseString to know that this is an env option we should just add

asan_parser.ParseStringFromEnv("ASAN_OPTIONS");
and call GetEnv in implementation

Is anything blocks us from that?

test/asan/TestCases/Linux/asan_options_error_message.cc

6 ↗

(On Diff #199771)

can you make it sanitizer_common test?

[marxin]

lib/asan/asan_flags.cc

123 ↗

(On Diff #199771)

No, good point!

[marxin]

Updated version of the patch.

[vitalybuka]

lib/hwasan/hwasan.cpp

132 ↗

(On Diff #203988)

parser.ParseStringFromEnv("HWASAN_OPTIONS");

lib/msan/msan.cc

178 ↗

(On Diff #203988)

ubsan_parser.ParseStringFromEnv("MSAN_OPTIONS")

if you keep this for VPrintf just move VPrintf into ParseStringFromEnv

lib/sanitizer_common/sanitizer_flag_parser.cc

83 ↗

(On Diff #203988)

probably we can skip "environment variable" to handle ubsan_default_options-like sources
Printf("%s: ERROR: expected '=' in %s\n", SanitizerToolName, source);

lib/sanitizer_common/sanitizer_flag_parser.h

118 ↗

(On Diff #203988)

How about:
void ParseString(const char *s, const char* source /* without = 0 */);
and set it everywhere?
ParseString(s, "ubsan_default_options()");

[marxin]

lib/sanitizer_common/sanitizer_flag_parser.h

118 ↗

(On Diff #203988)

Well, I don't like it much. There are quite some usages of the function:

git grep '\<ParseString\>' | cat
lib/asan/asan_activation.cc:      parser.ParseString(env);
lib/asan/asan_flags.cc:  asan_parser.ParseString(asan_compile_def);
lib/asan/asan_flags.cc:  asan_parser.ParseString(asan_default_options);
lib/asan/asan_flags.cc:  ubsan_parser.ParseString(ubsan_default_options);
lib/asan/asan_flags.cc:  lsan_parser.ParseString(lsan_default_options);
lib/cfi/cfi.cpp:  ubsan_parser.ParseString(ubsan_default_options);
lib/hwasan/hwasan.cpp:    parser.ParseString(__hwasan_default_options());
lib/hwasan/hwasan.cpp:  ubsan_parser.ParseString(ubsan_default_options);
lib/lsan/lsan.cc:  parser.ParseString(lsan_default_options);
lib/msan/msan.cc:    parser.ParseString(__msan_default_options());
lib/msan/msan.cc:  ubsan_parser.ParseString(ubsan_default_options);
lib/sanitizer_common/sancov_flags.cc:  parser.ParseString(MaybeCallSancovDefaultOptions());
lib/sanitizer_common/sanitizer_flag_parser.cc:  ParseString(env, env_name);
lib/sanitizer_common/sanitizer_flag_parser.cc:void FlagParser::ParseString(const char *s, const char *env_option_name) {
lib/sanitizer_common/sanitizer_flag_parser.cc:  // Backup current parser state to allow nested ParseString() calls.
lib/sanitizer_common/sanitizer_flag_parser.cc:  ParseString(data, path);
lib/sanitizer_common/sanitizer_flag_parser.h:  void ParseString(const char *s, const char *env_name = 0);
lib/sanitizer_common/tests/sanitizer_flags_test.cc:  parser.ParseString(env);
lib/sanitizer_common/tests/sanitizer_flags_test.cc:  parser.ParseString(env);
lib/sanitizer_common/tests/sanitizer_flags_test.cc:  parser.ParseString(env);
lib/sanitizer_common/tests/sanitizer_flags_test.cc:  parser.ParseString("symbolize=1:heap_profile=false log_path='path/two'");
lib/scudo/scudo_flags.cpp:  ScudoParser.ParseString(getCompileDefinitionScudoDefaultOptions());
lib/scudo/scudo_flags.cpp:  ScudoParser.ParseString(getScudoDefaultOptions());
lib/tsan/rtl/tsan_flags.cc:  parser.ParseString(__tsan_default_options());
lib/tsan/rtl/tsan_flags.cc:  ubsan_parser.ParseString(ubsan_default_options);
lib/tsan/rtl/tsan_flags.cc:  parser.ParseString(env, env_option_name);
lib/ubsan/ubsan_flags.cc:  parser.ParseString(MaybeCallUbsanDefaultOptions());
lib/xray/xray_basic_logging.cc:  P.ParseString(useCompilerDefinedBasicFlags());
lib/xray/xray_basic_logging.cc:  P.ParseString(EnvOpts);
lib/xray/xray_basic_logging.cc:  P.ParseString(static_cast<const char *>(Options));
lib/xray/xray_fdr_logging.cc:  FDRParser.ParseString(useCompilerDefinedFlags());
lib/xray/xray_fdr_logging.cc:  FDRParser.ParseString(useCompilerDefinedFDRFlags());
lib/xray/xray_fdr_logging.cc:  FDRParser.ParseString(EnvOpts);
lib/xray/xray_fdr_logging.cc:  FDRParser.ParseString(static_cast<const char *>(Options));
lib/xray/xray_flags.cc:  XRayParser.ParseString(XRayCompileFlags);
lib/xray/xray_profiling.cc:    ConfigParser.ParseString(profilingCompilerDefinedFlags());
lib/xray/xray_profiling.cc:    ConfigParser.ParseString(Env);
lib/xray/xray_profiling.cc:    ConfigParser.ParseString(static_cast<const char *>(Options));
lib/xray/xray_profiling.cc:    ProfilingParser.ParseString(profilingCompilerDefinedFlags());

sometimes the argument is some pointer casting.

[vitalybuka]

LGTM

[marxin]

Thank you for review. Can you please install the commit?

[vitalybuka]

In D59876#1541080, @marxin wrote:

Thank you for review. Can you please install the commit?

http://lab.llvm.org:8011 is down
I'll commit it after buildbots get online.

compiler-rt/trunk/lib/asan/asan_flags.cc

#if CAN_SANITIZE_UB
   ubsan_parser.ParseString(ubsan_default_options);
 #endif
 #if CAN_SANITIZE_LEAKS
   const char *lsan_default_options = __lsan::MaybeCallLsanDefaultOptions();
   lsan_parser.ParseString(lsan_default_options);
 #endif
 
   // Override from command line.
-  asan_parser.ParseString(GetEnv("ASAN_OPTIONS"));
+  asan_parser.ParseStringFromEnv("ASAN_OPTIONS");
 #if CAN_SANITIZE_LEAKS
-  lsan_parser.ParseString(GetEnv("LSAN_OPTIONS"));
+  lsan_parser.ParseStringFromEnv("LSAN_OPTIONS");
 #endif
 #if CAN_SANITIZE_UB
-  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
 #endif
 
   InitializeCommonFlags();
 
   // TODO(eugenis): dump all flags at verbosity>=2?
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) {

compiler-rt/trunk/lib/cfi/cfi.cpp

void InitializeFlags() {
   SetCommonFlagsDefaults();
 #ifdef CFI_ENABLE_DIAG
   __ubsan::Flags *uf = __ubsan::flags();
   uf->SetDefaults();
 #endif
 
   FlagParser cfi_parser;
   RegisterCommonFlags(&cfi_parser);
-  cfi_parser.ParseString(GetEnv("CFI_OPTIONS"));
+  cfi_parser.ParseStringFromEnv("CFI_OPTIONS");
 
 #ifdef CFI_ENABLE_DIAG
   FlagParser ubsan_parser;
   __ubsan::RegisterUbsanFlags(&ubsan_parser, uf);
   RegisterCommonFlags(&ubsan_parser);
 
   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
   ubsan_parser.ParseString(ubsan_default_options);
-  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
 #endif
 
   InitializeCommonFlags();
 
   if (Verbosity())
     ReportUnrecognizedFlags();
 
   if (common_flags()->help) {

compiler-rt/trunk/lib/dfsan/dfsan.cc

 
 static void InitializeFlags() {
   SetCommonFlagsDefaults();
   flags().SetDefaults();
 
   FlagParser parser;
   RegisterCommonFlags(&parser);
   RegisterDfsanFlags(&parser, &flags());
-  parser.ParseString(GetEnv("DFSAN_OPTIONS"));
+  parser.ParseStringFromEnv("DFSAN_OPTIONS");
   InitializeCommonFlags();
   if (Verbosity()) ReportUnrecognizedFlags();
   if (common_flags()->help) parser.PrintFlagDescriptions();
 }
 
 static void InitializePlatformEarly() {
   AvoidCVE_2016_2143();
 #ifdef DFSAN_RUNTIME_VMA

compiler-rt/trunk/lib/hwasan/hwasan.cpp

#endif
   // Override from user-specified string.
   if (__hwasan_default_options)
     parser.ParseString(__hwasan_default_options());
 #if HWASAN_CONTAINS_UBSAN
   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
   ubsan_parser.ParseString(ubsan_default_options);
 #endif
 
-  const char *hwasan_options = GetEnv("HWASAN_OPTIONS");
-  parser.ParseString(hwasan_options);
+  parser.ParseStringFromEnv("HWASAN_OPTIONS");
 #if HWASAN_CONTAINS_UBSAN
-  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
 #endif
-  VPrintf(1, "HWASAN_OPTIONS: %s\n",
-          hwasan_options ? hwasan_options : "<empty>");
 
   InitializeCommonFlags();
 
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 }
 

compiler-rt/trunk/lib/lsan/lsan.cc

static void InitializeFlags() {
 
   FlagParser parser;
   RegisterLsanFlags(&parser, f);
   RegisterCommonFlags(&parser);
 
   // Override from user-specified string.
   const char *lsan_default_options = MaybeCallLsanDefaultOptions();
   parser.ParseString(lsan_default_options);
-  parser.ParseString(GetEnv("LSAN_OPTIONS"));
+  parser.ParseStringFromEnv("LSAN_OPTIONS");
 
   SetVerbosity(common_flags()->verbosity);
 
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 
   __sanitizer_set_report_path(common_flags()->log_path);

compiler-rt/trunk/lib/msan/msan.cc

#endif
   // Override from user-specified string.
   if (__msan_default_options)
     parser.ParseString(__msan_default_options());
 #if MSAN_CONTAINS_UBSAN
   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
   ubsan_parser.ParseString(ubsan_default_options);
 #endif
 
-  const char *msan_options = GetEnv("MSAN_OPTIONS");
-  parser.ParseString(msan_options);
+  parser.ParseStringFromEnv("MSAN_OPTIONS");
 #if MSAN_CONTAINS_UBSAN
-  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
 #endif
-  VPrintf(1, "MSAN_OPTIONS: %s\n", msan_options ? msan_options : "<empty>");
 
   InitializeCommonFlags();
 
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 
   // Check if deprecated exit_code MSan flag is set.

compiler-rt/trunk/lib/sanitizer_common/sancov_flags.cc

 void InitializeSancovFlags() {
   SancovFlags *f = sancov_flags();
   f->SetDefaults();
 
   FlagParser parser;
   RegisterSancovFlags(&parser, f);
 
   parser.ParseString(MaybeCallSancovDefaultOptions());
-  parser.ParseString(GetEnv("SANCOV_OPTIONS"));
+  parser.ParseStringFromEnv("SANCOV_OPTIONS");
 
   ReportUnrecognizedFlags();
   if (f->help) parser.PrintFlagDescriptions();
 }
 
 }  // namespace __sancov

compiler-rt/trunk/lib/sanitizer_common/sanitizer_flag_parser.h

class FlagParser {
 
   const char *buf_;
   uptr pos_;
 
  public:
   FlagParser();
   void RegisterHandler(const char *name, FlagHandlerBase *handler,
                        const char *desc);
-  void ParseString(const char *s);
+  void ParseString(const char *s, const char *env_name = 0);
+  void ParseStringFromEnv(const char *env_name);
   bool ParseFile(const char *path, bool ignore_missing);
   void PrintFlagDescriptions();
 
   static LowLevelAllocator Alloc;
 
  private:
   void fatal_error(const char *err);
   bool is_space(char c);
   void skip_whitespace();
-  void parse_flags();
-  void parse_flag();
+  void parse_flags(const char *env_option_name);
+  void parse_flag(const char *env_option_name);
   bool run_handler(const char *name, const char *value);
   char *ll_strndup(const char *s, uptr n);
 };
 
 template <typename T>
 static void RegisterFlag(FlagParser *parser, const char *name, const char *desc,
                          T *var) {
   FlagHandler<T> *fh = new (FlagParser::Alloc) FlagHandler<T>(var);  // NOLINT
   parser->RegisterHandler(name, fh, desc);
 }
 
 void ReportUnrecognizedFlags();
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_FLAG_REGISTRY_H

compiler-rt/trunk/lib/sanitizer_common/sanitizer_flag_parser.cc

 
 void FlagParser::PrintFlagDescriptions() {
   Printf("Available flags for %s:\n", SanitizerToolName);
   for (int i = 0; i < n_flags_; ++i)
     Printf("\t%s\n\t\t- %s\n", flags_[i].name, flags_[i].desc);
 }
 
 void FlagParser::fatal_error(const char *err) {
-  Printf("ERROR: %s\n", err);
+  Printf("%s: ERROR: %s\n", SanitizerToolName, err);
   Die();
 }
 
 bool FlagParser::is_space(char c) {
   return c == ' ' || c == ',' || c == ':' || c == '\n' || c == '\t' ||
          c == '\r';
 }
 
 void FlagParser::skip_whitespace() {
   while (is_space(buf_[pos_])) ++pos_;
 }
 
-void FlagParser::parse_flag() {
+void FlagParser::parse_flag(const char *env_option_name) {
   uptr name_start = pos_;
   while (buf_[pos_] != 0 && buf_[pos_] != '=' && !is_space(buf_[pos_])) ++pos_;
-  if (buf_[pos_] != '=') fatal_error("expected '='");
+  if (buf_[pos_] != '=') {
+    if (env_option_name) {
+      Printf("%s: ERROR: expected '=' in %s\n", SanitizerToolName,
+             env_option_name);
+      Die();
+    } else
+      fatal_error("expected '='");
+  }
   char *name = ll_strndup(buf_ + name_start, pos_ - name_start);
 
   uptr value_start = ++pos_;
   char *value;
   if (buf_[pos_] == '\'' || buf_[pos_] == '"') {
     char quote = buf_[pos_++];
     while (buf_[pos_] != 0 && buf_[pos_] != quote) ++pos_;
     if (buf_[pos_] == 0) fatal_error("unterminated string");
     value = ll_strndup(buf_ + value_start + 1, pos_ - value_start - 1);
     ++pos_; // consume the closing quote
   } else {
     while (buf_[pos_] != 0 && !is_space(buf_[pos_])) ++pos_;
     if (buf_[pos_] != 0 && !is_space(buf_[pos_]))
       fatal_error("expected separator or eol");
     value = ll_strndup(buf_ + value_start, pos_ - value_start);
   }
 
   bool res = run_handler(name, value);
   if (!res) fatal_error("Flag parsing failed.");
 }
 
-void FlagParser::parse_flags() {
+void FlagParser::parse_flags(const char *env_option_name) {
   while (true) {
     skip_whitespace();
     if (buf_[pos_] == 0) break;
-    parse_flag();
+    parse_flag(env_option_name);
   }
 
   // Do a sanity check for certain flags.
   if (common_flags_dont_use.malloc_context_size < 1)
     common_flags_dont_use.malloc_context_size = 1;
 }
 
-void FlagParser::ParseString(const char *s) {
+void FlagParser::ParseStringFromEnv(const char *env_name) {
+  const char *env = GetEnv(env_name);
+  VPrintf(1, "%s: %s\n", env_name, env ? env : "<empty>");
+  ParseString(env, env_name);
+}
+
+void FlagParser::ParseString(const char *s, const char *env_option_name) {
   if (!s) return;
   // Backup current parser state to allow nested ParseString() calls.
   const char *old_buf_ = buf_;
   uptr old_pos_ = pos_;
   buf_ = s;
   pos_ = 0;
 
-  parse_flags();
+  parse_flags(env_option_name);
 
   buf_ = old_buf_;
   pos_ = old_pos_;
 }
 
 bool FlagParser::ParseFile(const char *path, bool ignore_missing) {
   static const uptr kMaxIncludeSize = 1 << 15;
   char *data;
   uptr data_mapped_size;
   error_t err;
   uptr len;
   if (!ReadFileToBuffer(path, &data, &data_mapped_size, &len,
                         Max(kMaxIncludeSize, GetPageSizeCached()), &err)) {
     if (ignore_missing)
       return true;
     Printf("Failed to read options from '%s': error %d\n", path, err);
     return false;
   }
-  ParseString(data);
+  ParseString(data, path);
   UnmapOrDie(data, data_mapped_size);
   return true;
 }
 
 bool FlagParser::run_handler(const char *name, const char *value) {
   for (int i = 0; i < n_flags_; ++i) {
     if (internal_strcmp(name, flags_[i].name) == 0)
       return flags_[i].handler->Parse(value);

compiler-rt/trunk/lib/scudo/scudo_flags.cpp

void initFlags() {
 
   // Override from compile definition.
   ScudoParser.ParseString(getCompileDefinitionScudoDefaultOptions());
 
   // Override from user-specified string.
   ScudoParser.ParseString(getScudoDefaultOptions());
 
   // Override from environment.
-  ScudoParser.ParseString(GetEnv("SCUDO_OPTIONS"));
+  ScudoParser.ParseStringFromEnv("SCUDO_OPTIONS");
 
   InitializeCommonFlags();
 
   // Sanity checks and default settings for the Quarantine parameters.
 
   if (f->QuarantineSizeMb >= 0) {
     // Backward compatible logic if QuarantineSizeMb is set.
     if (f->QuarantineSizeKb >= 0) {

compiler-rt/trunk/lib/tsan/dd/dd_rtl.cc

SetCommonFlagsDefaults();
     cf.allow_addr2line = true;
     OverrideCommonFlags(cf);
   }
 
   // Override from command line.
   FlagParser parser;
   RegisterFlag(&parser, "second_deadlock_stack", "", &f->second_deadlock_stack);
   RegisterCommonFlags(&parser);
-  parser.ParseString(GetEnv("DSAN_OPTIONS"));
+  parser.ParseStringFromEnv("DSAN_OPTIONS");
   SetVerbosity(common_flags()->verbosity);
 }
 
 void Initialize() {
   static u64 ctx_mem[sizeof(Context) / sizeof(u64) + 1];
   ctx = new(ctx_mem) Context();
 
   InitializeInterceptors();

compiler-rt/trunk/lib/tsan/rtl/tsan_flags.h

 #define TSAN_FLAG(Type, Name, DefaultValue, Description) Type Name;
 #include "tsan_flags.inc"
 #undef TSAN_FLAG
 
   void SetDefaults();
   void ParseFromString(const char *str);
 };
 
-void InitializeFlags(Flags *flags, const char *env);
+void InitializeFlags(Flags *flags, const char *env,
+                     const char *env_option_name = nullptr);
 }  // namespace __tsan
 
 #endif  // TSAN_FLAGS_H

compiler-rt/trunk/lib/tsan/rtl/tsan_flags.cc

 #include "tsan_flags.inc"
 #undef TSAN_FLAG
   // DDFlags
   RegisterFlag(parser, "second_deadlock_stack",
       "Report where each mutex is locked in deadlock reports",
       &f->second_deadlock_stack);
 }
 
-void InitializeFlags(Flags *f, const char *env) {
+void InitializeFlags(Flags *f, const char *env, const char *env_option_name) {
   SetCommonFlagsDefaults();
   {
     // Override some common flags defaults.
     CommonFlags cf;
     cf.CopyFrom(*common_flags());
     cf.allow_addr2line = true;
     if (SANITIZER_GO) {
       // Does not work as expected for Go: runtime handles SIGABRT and crashes.
#endif
 
   // Let a frontend override.
   parser.ParseString(__tsan_default_options());
 #if TSAN_CONTAINS_UBSAN
   const char *ubsan_default_options = __ubsan::MaybeCallUbsanDefaultOptions();
   ubsan_parser.ParseString(ubsan_default_options);
 #endif
   // Override from command line.
-  parser.ParseString(env);
+  parser.ParseString(env, env_option_name);
 #if TSAN_CONTAINS_UBSAN
-  ubsan_parser.ParseString(GetEnv("UBSAN_OPTIONS"));
+  ubsan_parser.ParseStringFromEnv("UBSAN_OPTIONS");
 #endif
 
   // Sanity check.
   if (!f->report_bugs) {
     f->report_thread_leaks = false;
     f->report_destroy_locked = false;
     f->report_signal_unsafe = false;
   }

compiler-rt/trunk/lib/tsan/rtl/tsan_rtl.cc

void Initialize(ThreadState *thr) {
   is_initialized = true;
   // We are not ready to handle interceptors yet.
   ScopedIgnoreInterceptors ignore;
   SanitizerToolName = "ThreadSanitizer";
   // Install tool-specific callbacks in sanitizer_common.
   SetCheckFailedCallback(TsanCheckFailed);
 
   ctx = new(ctx_placeholder) Context;
-  const char *options = GetEnv(SANITIZER_GO ? "GORACE" : "TSAN_OPTIONS");
+  const char *env_name = SANITIZER_GO ? "GORACE" : "TSAN_OPTIONS";
+  const char *options = GetEnv(env_name);
   CacheBinaryName();
   CheckASLR();
-  InitializeFlags(&ctx->flags, options);
+  InitializeFlags(&ctx->flags, options, env_name);
   AvoidCVE_2016_2143();
   __sanitizer::InitializePlatformEarly();
   __tsan::InitializePlatformEarly();
 
 #if !SANITIZER_GO
   // Re-exec ourselves if we need to set additional env or command line args.
   MaybeReexec();
 

compiler-rt/trunk/lib/ubsan/ubsan_flags.cc

void InitializeFlags() {
 
   FlagParser parser;
   RegisterCommonFlags(&parser);
   RegisterUbsanFlags(&parser, f);
 
   // Override from user-specified string.
   parser.ParseString(MaybeCallUbsanDefaultOptions());
   // Override from environment variable.
-  parser.ParseString(GetFlag("UBSAN_OPTIONS"));
+  parser.ParseStringFromEnv("UBSAN_OPTIONS");
   InitializeCommonFlags();
   if (Verbosity()) ReportUnrecognizedFlags();
 
   if (common_flags()->help) parser.PrintFlagDescriptions();
 }
 
 }  // namespace __ubsan
 
 SANITIZER_INTERFACE_WEAK_DEF(const char *, __ubsan_default_options, void) {
   return "";
 }
 
 #endif  // CAN_SANITIZE_UB

compiler-rt/trunk/lib/xray/xray_flags.cc

void initializeFlags() XRAY_NEVER_INSTRUMENT {
   registerXRayFlags(&XRayParser, F);
   RegisterCommonFlags(&XRayParser);
 
   // Use options defaulted at compile-time for the runtime.
   const char *XRayCompileFlags = useCompilerDefinedFlags();
   XRayParser.ParseString(XRayCompileFlags);
 
   // Override from environment variables.
-  XRayParser.ParseString(GetEnv("XRAY_OPTIONS"));
+  XRayParser.ParseStringFromEnv("XRAY_OPTIONS");
 
   // Override from command line.
   InitializeCommonFlags();
 
   if (Verbosity())
     ReportUnrecognizedFlags();
 
   if (common_flags()->help) {
     XRayParser.PrintFlagDescriptions();
   }
 }
 
 } // namespace __xray