lib/Support/Windows/Process.inc

   1 //===- Win32/Process.cpp - Win32 Process 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 Process class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "Windows.h"
  15 #include <psapi.h>
  16 #include <malloc.h>
  17 #include <io.h>
  18 #include <direct.h>
  19
  20 #ifdef __MINGW32__
  21  #if (HAVE_LIBPSAPI != 1)
  22   #error "libpsapi.a should be present"
  23  #endif
  24 #else
  25  #pragma comment(lib, "psapi.lib")
  26 #endif
  27
  28 //===----------------------------------------------------------------------===//
  29 //=== WARNING: Implementation here must contain only Win32 specific code
  30 //===          and must not be UNIX code
  31 //===----------------------------------------------------------------------===//
  32
  33 #ifdef __MINGW32__
  34 // This ban should be lifted when MinGW 1.0+ has defined this value.
  35 #  define _HEAPOK (-2)
  36 #endif
  37
  38 namespace llvm {
  39 using namespace sys;
  40
  41 // This function retrieves the page size using GetSystemInfo and is present
  42 // solely so it can be called once in Process::GetPageSize to initialize the
  43 // static variable PageSize.
  44 inline unsigned GetPageSizeOnce() {
  45   // NOTE: A 32-bit application running under WOW64 is supposed to use
  46   // GetNativeSystemInfo.  However, this interface is not present prior
  47   // to Windows XP so to use it requires dynamic linking.  It is not clear
  48   // how this affects the reported page size, if at all.  One could argue
  49   // that LLVM ought to run as 64-bits on a 64-bit system, anyway.
  50   SYSTEM_INFO info;
  51   GetSystemInfo(&info);
  52   return static_cast<unsigned>(info.dwPageSize);
  53 }
  54
  55 unsigned
  56 Process::GetPageSize() {
  57   static const unsigned PageSize = GetPageSizeOnce();
  58   return PageSize;
  59 }
  60
  61 size_t
  62 Process::GetMallocUsage()
  63 {
  64   _HEAPINFO hinfo;
  65   hinfo._pentry = NULL;
  66
  67   size_t size = 0;
  68
  69   while (_heapwalk(&hinfo) == _HEAPOK)
  70     size += hinfo._size;
  71
  72   return size;
  73 }
  74
  75 size_t
  76 Process::GetTotalMemoryUsage()
  77 {
  78   PROCESS_MEMORY_COUNTERS pmc;
  79   GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
  80   return pmc.PagefileUsage;
  81 }
  82
  83 void
  84 Process::GetTimeUsage(
  85   TimeValue& elapsed, TimeValue& user_time, TimeValue& sys_time)
  86 {
  87   elapsed = TimeValue::now();
  88
  89   uint64_t ProcCreate, ProcExit, KernelTime, UserTime;
  90   GetProcessTimes(GetCurrentProcess(), (FILETIME*)&ProcCreate,
  91                   (FILETIME*)&ProcExit, (FILETIME*)&KernelTime,
  92                   (FILETIME*)&UserTime);
  93
  94   // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
  95   user_time.seconds( UserTime / 10000000 );
  96   user_time.nanoseconds( unsigned(UserTime % 10000000) * 100 );
  97   sys_time.seconds( KernelTime / 10000000 );
  98   sys_time.nanoseconds( unsigned(KernelTime % 10000000) * 100 );
  99 }
 100
 101 int Process::GetCurrentUserId()
 102 {
 103   return 65536;
 104 }
 105
 106 int Process::GetCurrentGroupId()
 107 {
 108   return 65536;
 109 }
 110
 111 // Some LLVM programs such as bugpoint produce core files as a normal part of
 112 // their operation. To prevent the disk from filling up, this configuration item
 113 // does what's necessary to prevent their generation.
 114 void Process::PreventCoreFiles() {
 115   // Windows doesn't do core files, but it does do modal pop-up message
 116   // boxes.  As this method is used by bugpoint, preventing these pop-ups
 117   // is the moral equivalent of suppressing core files.
 118   SetErrorMode(SEM_FAILCRITICALERRORS |
 119                SEM_NOGPFAULTERRORBOX |
 120                SEM_NOOPENFILEERRORBOX);
 121 }
 122
 123 bool Process::StandardInIsUserInput() {
 124   return FileDescriptorIsDisplayed(0);
 125 }
 126
 127 bool Process::StandardOutIsDisplayed() {
 128   return FileDescriptorIsDisplayed(1);
 129 }
 130
 131 bool Process::StandardErrIsDisplayed() {
 132   return FileDescriptorIsDisplayed(2);
 133 }
 134
 135 bool Process::FileDescriptorIsDisplayed(int fd) {
 136   DWORD Mode;   // Unused
 137   return (GetConsoleMode((HANDLE)_get_osfhandle(fd), &Mode) != 0);
 138 }
 139
 140 unsigned Process::StandardOutColumns() {
 141   unsigned Columns = 0;
 142   CONSOLE_SCREEN_BUFFER_INFO csbi;
 143   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
 144     Columns = csbi.dwSize.X;
 145   return Columns;
 146 }
 147
 148 unsigned Process::StandardErrColumns() {
 149   unsigned Columns = 0;
 150   CONSOLE_SCREEN_BUFFER_INFO csbi;
 151   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE), &csbi))
 152     Columns = csbi.dwSize.X;
 153   return Columns;
 154 }
 155
 156 // It always has colors.
 157 bool Process::StandardErrHasColors() {
 158   return StandardErrIsDisplayed();
 159 }
 160
 161 bool Process::StandardOutHasColors() {
 162   return StandardOutIsDisplayed();
 163 }
 164
 165 namespace {
 166 class DefaultColors
 167 {
 168   private:
 169     WORD defaultColor;
 170   public:
 171     DefaultColors()
 172      :defaultColor(GetCurrentColor()) {}
 173     static unsigned GetCurrentColor() {
 174       CONSOLE_SCREEN_BUFFER_INFO csbi;
 175       if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
 176         return csbi.wAttributes;
 177       return 0;
 178     }
 179     WORD operator()() const { return defaultColor; }
 180 };
 181
 182 DefaultColors defaultColors;
 183 }
 184
 185 bool Process::ColorNeedsFlush() {
 186   return true;
 187 }
 188
 189 const char *Process::OutputBold(bool bg) {
 190   WORD colors = DefaultColors::GetCurrentColor();
 191   if (bg)
 192     colors |= BACKGROUND_INTENSITY;
 193   else
 194     colors |= FOREGROUND_INTENSITY;
 195   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
 196   return 0;
 197 }
 198
 199 const char *Process::OutputColor(char code, bool bold, bool bg) {
 200   WORD colors;
 201   if (bg) {
 202     colors = ((code&1) ? BACKGROUND_RED : 0) |
 203       ((code&2) ? BACKGROUND_GREEN : 0 ) |
 204       ((code&4) ? BACKGROUND_BLUE : 0);
 205     if (bold)
 206       colors |= BACKGROUND_INTENSITY;
 207   } else {
 208     colors = ((code&1) ? FOREGROUND_RED : 0) |
 209       ((code&2) ? FOREGROUND_GREEN : 0 ) |
 210       ((code&4) ? FOREGROUND_BLUE : 0);
 211     if (bold)
 212       colors |= FOREGROUND_INTENSITY;
 213   }
 214   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
 215   return 0;
 216 }
 217
 218 const char *Process::ResetColor() {
 219   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), defaultColors());
 220   return 0;
 221 }
 222
 223 void Process::SetWorkingDirectory(std::string Path) {
 224   ::_chdir(Path.c_str());
 225 }
 226
 227 }