[sanitizer] Add char **GetEnviron() on all other platforms

[morehouse]

LGTM

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

 void PrintModuleMap();
 const char *GetEnv(const char *name);
 bool SetEnv(const char *name, const char *value);
 
 u32 GetUid();
 void ReExec();
 void CheckASLR();
 char **GetArgv();
+char **GetEnviron();
 void PrintCmdline();
 bool StackSizeIsUnlimited();
 uptr GetStackSizeLimitInBytes();
 void SetStackSizeLimitInBytes(uptr limit);
 bool AddressSpaceIsUnlimited();
 void SetAddressSpaceUnlimited();
 void AdjustStackSize(void *attr);
 void PlatformPrepareForSandboxing(__sanitizer_sandbox_arguments *args);

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

 void CatastrophicErrorWrite(const char *buffer, uptr length) {
   __sanitizer_log_write(buffer, length);
 }
 
 char **StoredArgv;
 char **StoredEnviron;
 
 char **GetArgv() { return StoredArgv; }
+char **GetEnviron() { return StoredEnviron; }
 
 const char *GetEnv(const char *name) {
   if (StoredEnviron) {
     uptr NameLen = internal_strlen(name);
     for (char **Env = StoredEnviron; *Env != 0; Env++) {
       if (internal_strncmp(*Env, name, NameLen) == 0 && (*Env)[NameLen] == '=')
         return (*Env) + NameLen + 1;
     }

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

 }
 
 char **GetArgv() {
   char **argv, **envp;
   GetArgsAndEnv(&argv, &envp);
   return argv;
 }
 
-void ReExec() {
+char **GetEnviron() {
   char **argv, **envp;
+  GetArgsAndEnv(&argv, &envp);
+  return envp;
+}
+
+void ReExec() {
   const char *pathname = "/proc/self/exe";
 
 #if SANITIZER_NETBSD
   static const int name[] = {
     CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME,
   };
   char path[400];
   uptr len;
 
   len = sizeof(path);
   if (internal_sysctl(name, ARRAY_SIZE(name), path, &len, NULL, 0) != -1)
     pathname = path;
 #elif SANITIZER_SOLARIS
   pathname = getexecname();
   CHECK_NE(pathname, NULL);
 #elif SANITIZER_USE_GETAUXVAL
   // Calling execve with /proc/self/exe sets that as $EXEC_ORIGIN. Binaries that
   // rely on that will fail to load shared libraries. Query AT_EXECFN instead.
   pathname = reinterpret_cast<const char *>(getauxval(AT_EXECFN));
 #endif
 
-  GetArgsAndEnv(&argv, &envp);
-  uptr rv = internal_execve(pathname, argv, envp);
+  uptr rv = internal_execve(pathname, GetArgv(), GetEnviron());
   int rverrno;
   CHECK_EQ(internal_iserror(rv, &rverrno), true);
   Printf("execve failed, errno %d\n", rverrno);
   Die();
 }
 #endif
 
 #if !SANITIZER_SOLARIS

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

 }
 
 char **GetArgv() {
   char **argv, **envp;
   GetArgsAndEnv(&argv, &envp);
   return argv;
 }
 
+char **GetEnviron() {
+  char **argv, **envp;
+  GetArgsAndEnv(&argv, &envp);
+  return envp;
+}
+
 void ReExec() {
   UNIMPLEMENTED();
 }
 
 }  // namespace __sanitizer
 
 #endif  // SANITIZER_OPENBSD

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

 void DumpProcessMap() {}
 
 // There is no page protection so everything is "accessible."
 bool IsAccessibleMemoryRange(uptr beg, uptr size) {
   return true;
 }
 
 char **GetArgv() { return nullptr; }
+char **GetEnviron() { return nullptr; }
 
 const char *GetEnv(const char *name) {
   return getenv(name);
 }
 
 uptr ReadBinaryName(/*out*/char *buf, uptr buf_len) {
   internal_strncpy(buf, "StubBinaryName", buf_len);
   return internal_strlen(buf);

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

void CheckASLR() {
   // Do nothing
 }
 
 char **GetArgv() {
   // FIXME: Actually implement this function.
   return 0;
 }
 
+char **GetEnviron() {
+  // FIXME: Actually implement this function.
+  return 0;
+}
+
 pid_t StartSubprocess(const char *program, const char *const argv[],
                       fd_t stdin_fd, fd_t stdout_fd, fd_t stderr_fd) {
   // FIXME: implement on this platform
   // Should be implemented based on
   // SymbolizerProcess::StarAtSymbolizerSubprocess
   // from lib/sanitizer_common/sanitizer_symbolizer_win.cc.
   return -1;
 }