LLVM  7.0.0svn
Program.inc
Go to the documentation of this file.
1 //===- Win32/Program.cpp - Win32 Program Implementation ------- -*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file provides the Win32 specific implementation of the Program class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "WindowsSupport.h"
15 #include "llvm/ADT/StringExtras.h"
17 #include "llvm/Support/Errc.h"
19 #include "llvm/Support/Path.h"
22 #include <cstdio>
23 #include <fcntl.h>
24 #include <io.h>
25 #include <malloc.h>
26 #include <numeric>
27 
28 //===----------------------------------------------------------------------===//
29 //=== WARNING: Implementation here must contain only Win32 specific code
30 //=== and must not be UNIX code
31 //===----------------------------------------------------------------------===//
32 
33 namespace llvm {
34 
35 ProcessInfo::ProcessInfo() : Pid(0), Process(0), ReturnCode(0) {}
36 
37 ErrorOr<std::string> sys::findProgramByName(StringRef Name,
38  ArrayRef<StringRef> Paths) {
39  assert(!Name.empty() && "Must have a name!");
40 
41  if (Name.find_first_of("/\\") != StringRef::npos)
42  return std::string(Name);
43 
44  const wchar_t *Path = nullptr;
45  std::wstring PathStorage;
46  if (!Paths.empty()) {
47  PathStorage.reserve(Paths.size() * MAX_PATH);
48  for (unsigned i = 0; i < Paths.size(); ++i) {
49  if (i)
50  PathStorage.push_back(L';');
51  StringRef P = Paths[i];
52  SmallVector<wchar_t, MAX_PATH> TmpPath;
53  if (std::error_code EC = windows::UTF8ToUTF16(P, TmpPath))
54  return EC;
55  PathStorage.append(TmpPath.begin(), TmpPath.end());
56  }
57  Path = PathStorage.c_str();
58  }
59 
60  SmallVector<wchar_t, MAX_PATH> U16Name;
61  if (std::error_code EC = windows::UTF8ToUTF16(Name, U16Name))
62  return EC;
63 
64  SmallVector<StringRef, 12> PathExts;
65  PathExts.push_back("");
66  PathExts.push_back(".exe"); // FIXME: This must be in %PATHEXT%.
67  if (const char *PathExtEnv = std::getenv("PATHEXT"))
68  SplitString(PathExtEnv, PathExts, ";");
69 
70  SmallVector<wchar_t, MAX_PATH> U16Result;
71  DWORD Len = MAX_PATH;
72  for (StringRef Ext : PathExts) {
73  SmallVector<wchar_t, MAX_PATH> U16Ext;
74  if (std::error_code EC = windows::UTF8ToUTF16(Ext, U16Ext))
75  return EC;
76 
77  do {
78  U16Result.reserve(Len);
79  // Lets attach the extension manually. That is needed for files
80  // with a point in name like aaa.bbb. SearchPathW will not add extension
81  // from its argument to such files because it thinks they already had one.
82  SmallVector<wchar_t, MAX_PATH> U16NameExt;
83  if (std::error_code EC =
84  windows::UTF8ToUTF16(Twine(Name + Ext).str(), U16NameExt))
85  return EC;
86 
87  Len = ::SearchPathW(Path, c_str(U16NameExt), nullptr,
88  U16Result.capacity(), U16Result.data(), nullptr);
89  } while (Len > U16Result.capacity());
90 
91  if (Len != 0)
92  break; // Found it.
93  }
94 
95  if (Len == 0)
96  return mapWindowsError(::GetLastError());
97 
98  U16Result.set_size(Len);
99 
100  SmallVector<char, MAX_PATH> U8Result;
101  if (std::error_code EC =
102  windows::UTF16ToUTF8(U16Result.data(), U16Result.size(), U8Result))
103  return EC;
104 
105  return std::string(U8Result.begin(), U8Result.end());
106 }
107 
108 static HANDLE RedirectIO(Optional<StringRef> Path, int fd,
109  std::string *ErrMsg) {
110  HANDLE h;
111  if (!Path) {
112  if (!DuplicateHandle(GetCurrentProcess(), (HANDLE)_get_osfhandle(fd),
113  GetCurrentProcess(), &h,
114  0, TRUE, DUPLICATE_SAME_ACCESS))
115  return INVALID_HANDLE_VALUE;
116  return h;
117  }
118 
119  std::string fname;
120  if (Path->empty())
121  fname = "NUL";
122  else
123  fname = *Path;
124 
125  SECURITY_ATTRIBUTES sa;
126  sa.nLength = sizeof(sa);
127  sa.lpSecurityDescriptor = 0;
128  sa.bInheritHandle = TRUE;
129 
130  SmallVector<wchar_t, 128> fnameUnicode;
131  if (Path->empty()) {
132  // Don't play long-path tricks on "NUL".
133  if (windows::UTF8ToUTF16(fname, fnameUnicode))
134  return INVALID_HANDLE_VALUE;
135  } else {
136  if (path::widenPath(fname, fnameUnicode))
137  return INVALID_HANDLE_VALUE;
138  }
139  h = CreateFileW(fnameUnicode.data(), fd ? GENERIC_WRITE : GENERIC_READ,
140  FILE_SHARE_READ, &sa, fd == 0 ? OPEN_EXISTING : CREATE_ALWAYS,
141  FILE_ATTRIBUTE_NORMAL, NULL);
142  if (h == INVALID_HANDLE_VALUE) {
143  MakeErrMsg(ErrMsg, fname + ": Can't open file for " +
144  (fd ? "input" : "output"));
145  }
146 
147  return h;
148 }
149 
150 }
151 
152 static bool Execute(ProcessInfo &PI, StringRef Program,
153  ArrayRef<StringRef> Args, Optional<ArrayRef<StringRef>> Env,
154  ArrayRef<Optional<StringRef>> Redirects,
155  unsigned MemoryLimit, std::string *ErrMsg) {
156  if (!sys::fs::can_execute(Program)) {
157  if (ErrMsg)
158  *ErrMsg = "program not executable";
159  return false;
160  }
161 
162  // can_execute may succeed by looking at Program + ".exe". CreateProcessW
163  // will implicitly add the .exe if we provide a command line without an
164  // executable path, but since we use an explicit executable, we have to add
165  // ".exe" ourselves.
166  SmallString<64> ProgramStorage;
167  if (!sys::fs::exists(Program))
168  Program = Twine(Program + ".exe").toStringRef(ProgramStorage);
169 
170  // Windows wants a command line, not an array of args, to pass to the new
171  // process. We have to concatenate them all, while quoting the args that
172  // have embedded spaces (or are empty).
173  std::string Command = flattenWindowsCommandLine(Args);
174 
175  // The pointer to the environment block for the new process.
176  std::vector<wchar_t> EnvBlock;
177 
178  if (Env) {
179  // An environment block consists of a null-terminated block of
180  // null-terminated strings. Convert the array of environment variables to
181  // an environment block by concatenating them.
182  for (const auto E : *Env) {
183  SmallVector<wchar_t, MAX_PATH> EnvString;
184  if (std::error_code ec = windows::UTF8ToUTF16(E, EnvString)) {
185  SetLastError(ec.value());
186  MakeErrMsg(ErrMsg, "Unable to convert environment variable to UTF-16");
187  return false;
188  }
189 
190  EnvBlock.insert(EnvBlock.end(), EnvString.begin(), EnvString.end());
191  EnvBlock.push_back(0);
192  }
193  EnvBlock.push_back(0);
194  }
195 
196  // Create a child process.
197  STARTUPINFOW si;
198  memset(&si, 0, sizeof(si));
199  si.cb = sizeof(si);
200  si.hStdInput = INVALID_HANDLE_VALUE;
201  si.hStdOutput = INVALID_HANDLE_VALUE;
202  si.hStdError = INVALID_HANDLE_VALUE;
203 
204  if (!Redirects.empty()) {
205  si.dwFlags = STARTF_USESTDHANDLES;
206 
207  si.hStdInput = RedirectIO(Redirects[0], 0, ErrMsg);
208  if (si.hStdInput == INVALID_HANDLE_VALUE) {
209  MakeErrMsg(ErrMsg, "can't redirect stdin");
210  return false;
211  }
212  si.hStdOutput = RedirectIO(Redirects[1], 1, ErrMsg);
213  if (si.hStdOutput == INVALID_HANDLE_VALUE) {
214  CloseHandle(si.hStdInput);
215  MakeErrMsg(ErrMsg, "can't redirect stdout");
216  return false;
217  }
218  if (Redirects[1] && Redirects[2] && *Redirects[1] == *Redirects[2]) {
219  // If stdout and stderr should go to the same place, redirect stderr
220  // to the handle already open for stdout.
221  if (!DuplicateHandle(GetCurrentProcess(), si.hStdOutput,
222  GetCurrentProcess(), &si.hStdError,
223  0, TRUE, DUPLICATE_SAME_ACCESS)) {
224  CloseHandle(si.hStdInput);
225  CloseHandle(si.hStdOutput);
226  MakeErrMsg(ErrMsg, "can't dup stderr to stdout");
227  return false;
228  }
229  } else {
230  // Just redirect stderr
231  si.hStdError = RedirectIO(Redirects[2], 2, ErrMsg);
232  if (si.hStdError == INVALID_HANDLE_VALUE) {
233  CloseHandle(si.hStdInput);
234  CloseHandle(si.hStdOutput);
235  MakeErrMsg(ErrMsg, "can't redirect stderr");
236  return false;
237  }
238  }
239  }
240 
241  PROCESS_INFORMATION pi;
242  memset(&pi, 0, sizeof(pi));
243 
244  fflush(stdout);
245  fflush(stderr);
246 
247  SmallVector<wchar_t, MAX_PATH> ProgramUtf16;
248  if (std::error_code ec = path::widenPath(Program, ProgramUtf16)) {
249  SetLastError(ec.value());
250  MakeErrMsg(ErrMsg,
251  std::string("Unable to convert application name to UTF-16"));
252  return false;
253  }
254 
255  SmallVector<wchar_t, MAX_PATH> CommandUtf16;
256  if (std::error_code ec = windows::UTF8ToUTF16(Command, CommandUtf16)) {
257  SetLastError(ec.value());
258  MakeErrMsg(ErrMsg,
259  std::string("Unable to convert command-line to UTF-16"));
260  return false;
261  }
262 
263  BOOL rc = CreateProcessW(ProgramUtf16.data(), CommandUtf16.data(), 0, 0,
264  TRUE, CREATE_UNICODE_ENVIRONMENT,
265  EnvBlock.empty() ? 0 : EnvBlock.data(), 0, &si,
266  &pi);
267  DWORD err = GetLastError();
268 
269  // Regardless of whether the process got created or not, we are done with
270  // the handles we created for it to inherit.
271  CloseHandle(si.hStdInput);
272  CloseHandle(si.hStdOutput);
273  CloseHandle(si.hStdError);
274 
275  // Now return an error if the process didn't get created.
276  if (!rc) {
277  SetLastError(err);
278  MakeErrMsg(ErrMsg, std::string("Couldn't execute program '") +
279  Program.str() + "'");
280  return false;
281  }
282 
283  PI.Pid = pi.dwProcessId;
284  PI.Process = pi.hProcess;
285 
286  // Make sure these get closed no matter what.
287  ScopedCommonHandle hThread(pi.hThread);
288 
289  // Assign the process to a job if a memory limit is defined.
290  ScopedJobHandle hJob;
291  if (MemoryLimit != 0) {
292  hJob = CreateJobObjectW(0, 0);
293  bool success = false;
294  if (hJob) {
295  JOBOBJECT_EXTENDED_LIMIT_INFORMATION jeli;
296  memset(&jeli, 0, sizeof(jeli));
297  jeli.BasicLimitInformation.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_MEMORY;
298  jeli.ProcessMemoryLimit = uintptr_t(MemoryLimit) * 1048576;
299  if (SetInformationJobObject(hJob, JobObjectExtendedLimitInformation,
300  &jeli, sizeof(jeli))) {
301  if (AssignProcessToJobObject(hJob, pi.hProcess))
302  success = true;
303  }
304  }
305  if (!success) {
306  SetLastError(GetLastError());
307  MakeErrMsg(ErrMsg, std::string("Unable to set memory limit"));
308  TerminateProcess(pi.hProcess, 1);
309  WaitForSingleObject(pi.hProcess, INFINITE);
310  return false;
311  }
312  }
313 
314  return true;
315 }
316 
317 static bool argNeedsQuotes(StringRef Arg) {
318  if (Arg.empty())
319  return true;
320  return StringRef::npos != Arg.find_first_of("\t \"&\'()*<>\\`^|");
321 }
322 
323 static std::string quoteSingleArg(StringRef Arg) {
324  std::string Result;
325  Result.push_back('"');
326 
327  while (!Arg.empty()) {
328  size_t FirstNonBackslash = Arg.find_first_not_of('\\');
329  size_t BackslashCount = FirstNonBackslash;
330  if (FirstNonBackslash == StringRef::npos) {
331  // The entire remainder of the argument is backslashes. Escape all of
332  // them and just early out.
333  BackslashCount = Arg.size();
334  Result.append(BackslashCount * 2, '\\');
335  break;
336  }
337 
338  if (Arg[FirstNonBackslash] == '\"') {
339  // This is an embedded quote. Escape all preceding backslashes, then
340  // add one additional backslash to escape the quote.
341  Result.append(BackslashCount * 2 + 1, '\\');
342  Result.push_back('\"');
343  } else {
344  // This is just a normal character. Don't escape any of the preceding
345  // backslashes, just append them as they are and then append the
346  // character.
347  Result.append(BackslashCount, '\\');
348  Result.push_back(Arg[FirstNonBackslash]);
349  }
350 
351  // Drop all the backslashes, plus the following character.
352  Arg = Arg.drop_front(FirstNonBackslash + 1);
353  }
354 
355  Result.push_back('"');
356  return Result;
357 }
358 
359 namespace llvm {
360 std::string sys::flattenWindowsCommandLine(ArrayRef<StringRef> Args) {
361  std::string Command;
362  for (StringRef Arg : Args) {
363  if (argNeedsQuotes(Arg))
364  Command += quoteSingleArg(Arg);
365  else
366  Command += Arg;
367 
368  Command.push_back(' ');
369  }
370 
371  return Command;
372 }
373 
374 ProcessInfo sys::Wait(const ProcessInfo &PI, unsigned SecondsToWait,
375  bool WaitUntilChildTerminates, std::string *ErrMsg) {
376  assert(PI.Pid && "invalid pid to wait on, process not started?");
377  assert((PI.Process && PI.Process != INVALID_HANDLE_VALUE) &&
378  "invalid process handle to wait on, process not started?");
379  DWORD milliSecondsToWait = 0;
380  if (WaitUntilChildTerminates)
381  milliSecondsToWait = INFINITE;
382  else if (SecondsToWait > 0)
383  milliSecondsToWait = SecondsToWait * 1000;
384 
385  ProcessInfo WaitResult = PI;
386  DWORD WaitStatus = WaitForSingleObject(PI.Process, milliSecondsToWait);
387  if (WaitStatus == WAIT_TIMEOUT) {
388  if (SecondsToWait) {
389  if (!TerminateProcess(PI.Process, 1)) {
390  if (ErrMsg)
391  MakeErrMsg(ErrMsg, "Failed to terminate timed-out program");
392 
393  // -2 indicates a crash or timeout as opposed to failure to execute.
394  WaitResult.ReturnCode = -2;
395  CloseHandle(PI.Process);
396  return WaitResult;
397  }
398  WaitForSingleObject(PI.Process, INFINITE);
399  CloseHandle(PI.Process);
400  } else {
401  // Non-blocking wait.
402  return ProcessInfo();
403  }
404  }
405 
406  // Get its exit status.
407  DWORD status;
408  BOOL rc = GetExitCodeProcess(PI.Process, &status);
409  DWORD err = GetLastError();
410  if (err != ERROR_INVALID_HANDLE)
411  CloseHandle(PI.Process);
412 
413  if (!rc) {
414  SetLastError(err);
415  if (ErrMsg)
416  MakeErrMsg(ErrMsg, "Failed getting status for program");
417 
418  // -2 indicates a crash or timeout as opposed to failure to execute.
419  WaitResult.ReturnCode = -2;
420  return WaitResult;
421  }
422 
423  if (!status)
424  return WaitResult;
425 
426  // Pass 10(Warning) and 11(Error) to the callee as negative value.
427  if ((status & 0xBFFF0000U) == 0x80000000U)
428  WaitResult.ReturnCode = static_cast<int>(status);
429  else if (status & 0xFF)
430  WaitResult.ReturnCode = status & 0x7FFFFFFF;
431  else
432  WaitResult.ReturnCode = 1;
433 
434  return WaitResult;
435 }
436 
437 std::error_code sys::ChangeStdinToBinary() {
438  int result = _setmode(_fileno(stdin), _O_BINARY);
439  if (result == -1)
440  return std::error_code(errno, std::generic_category());
441  return std::error_code();
442 }
443 
444 std::error_code sys::ChangeStdoutToBinary() {
445  int result = _setmode(_fileno(stdout), _O_BINARY);
446  if (result == -1)
447  return std::error_code(errno, std::generic_category());
448  return std::error_code();
449 }
450 
451 std::error_code
452 llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
453  WindowsEncodingMethod Encoding) {
454  std::error_code EC;
456  if (EC)
457  return EC;
458 
459  if (Encoding == WEM_UTF8) {
460  OS << Contents;
461  } else if (Encoding == WEM_CurrentCodePage) {
462  SmallVector<wchar_t, 1> ArgsUTF16;
463  SmallVector<char, 1> ArgsCurCP;
464 
465  if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
466  return EC;
467 
468  if ((EC = windows::UTF16ToCurCP(
469  ArgsUTF16.data(), ArgsUTF16.size(), ArgsCurCP)))
470  return EC;
471 
472  OS.write(ArgsCurCP.data(), ArgsCurCP.size());
473  } else if (Encoding == WEM_UTF16) {
474  SmallVector<wchar_t, 1> ArgsUTF16;
475 
476  if ((EC = windows::UTF8ToUTF16(Contents, ArgsUTF16)))
477  return EC;
478 
479  // Endianness guessing
480  char BOM[2];
481  uint16_t src = UNI_UTF16_BYTE_ORDER_MARK_NATIVE;
482  memcpy(BOM, &src, 2);
483  OS.write(BOM, 2);
484  OS.write((char *)ArgsUTF16.data(), ArgsUTF16.size() << 1);
485  } else {
486  llvm_unreachable("Unknown encoding");
487  }
488 
489  if (OS.has_error())
491 
492  return EC;
493 }
494 
495 bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program,
496  ArrayRef<StringRef> Args) {
497  // The documented max length of the command line passed to CreateProcess.
498  static const size_t MaxCommandStringLength = 32768;
499  SmallVector<StringRef, 8> FullArgs;
500  FullArgs.push_back(Program);
501  FullArgs.append(Args.begin(), Args.end());
502  std::string Result = flattenWindowsCommandLine(FullArgs);
503  return (Result.size() + 1) <= MaxCommandStringLength;
504 }
505 }
bool can_execute(const Twine &Path)
Can we execute this file?
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
std::error_code ChangeStdoutToBinary()
ErrorOr< std::string > findProgramByName(StringRef Name, ArrayRef< StringRef > Paths={})
Find the first executable file Name in Paths.
UTF-8 is the LLVM native encoding, being the same as "do not perform encoding conversion"...
Definition: Program.h:149
std::error_code make_error_code(BitcodeError E)
void SplitString(StringRef Source, SmallVectorImpl< StringRef > &OutFragments, StringRef Delimiters=" \\\)
SplitString - Split up the specified string according to the specified delimiters, appending the result fragments to the output list.
#define UNI_UTF16_BYTE_ORDER_MARK_NATIVE
Definition: ConvertUTF.h:124
#define rc(i)
#define P(N)
std::error_code status(const Twine &path, file_status &result, bool follow=true)
Get file status as if by POSIX stat().
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
bool commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef< StringRef > Args)
Return true if the given arguments fit within system-specific argument length limits.
std::error_code mapWindowsError(unsigned EV)
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
SmallVectorImpl< T >::const_pointer c_str(SmallVectorImpl< T > &str)
std::error_code writeFileWithEncoding(StringRef FileName, StringRef Contents, WindowsEncodingMethod Encoding=WEM_UTF8)
Saves the UTF8-encoded contents string into the file FileName using a specific encoding.
bool MakeErrMsg(std::string *ErrMsg, const std::string &prefix)
WindowsEncodingMethod
File encoding options when writing contents that a non-UTF8 tool will read (on Windows systems)...
Definition: Program.h:146
std::error_code ChangeStdinToBinary()
amdgpu Simplify well known AMD library false Value Value * Arg
success
Parameters (see the expansion example below): (the builder, addr, loaded, new_val, ordering, /* OUT.
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:366
static const size_t npos
Definition: StringRef.h:51
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
ProcessInfo Wait(const ProcessInfo &PI, unsigned SecondsToWait, bool WaitUntilTerminates, std::string *ErrMsg=nullptr)
This function waits for the process specified by PI to finish.
bool exists(const basic_file_status &status)
Does file exist?
Definition: Path.cpp:1014
constexpr char Args[]
Key for Kernel::Metadata::mArgs.