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 <direct.h>
  16 #include <io.h>
  17 #include <malloc.h>
  18 #include <psapi.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
  42 process::id_type self_process::get_id() {
  43   return GetCurrentProcess();
  44 }
  45
  46
  47 // This function retrieves the page size using GetSystemInfo and is present
  48 // solely so it can be called once in Process::GetPageSize to initialize the
  49 // static variable PageSize.
  50 inline unsigned GetPageSizeOnce() {
  51   // NOTE: A 32-bit application running under WOW64 is supposed to use
  52   // GetNativeSystemInfo.  However, this interface is not present prior
  53   // to Windows XP so to use it requires dynamic linking.  It is not clear
  54   // how this affects the reported page size, if at all.  One could argue
  55   // that LLVM ought to run as 64-bits on a 64-bit system, anyway.
  56   SYSTEM_INFO info;
  57   GetSystemInfo(&info);
  58   return static_cast<unsigned>(info.dwPageSize);
  59 }
  60
  61 unsigned
  62 Process::GetPageSize() {
  63   static const unsigned PageSize = GetPageSizeOnce();
  64   return PageSize;
  65 }
  66
  67 size_t
  68 Process::GetMallocUsage()
  69 {
  70   _HEAPINFO hinfo;
  71   hinfo._pentry = NULL;
  72
  73   size_t size = 0;
  74
  75   while (_heapwalk(&hinfo) == _HEAPOK)
  76     size += hinfo._size;
  77
  78   return size;
  79 }
  80
  81 size_t
  82 Process::GetTotalMemoryUsage()
  83 {
  84   PROCESS_MEMORY_COUNTERS pmc;
  85   GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof(pmc));
  86   return pmc.PagefileUsage;
  87 }
  88
  89 void
  90 Process::GetTimeUsage(
  91   TimeValue& elapsed, TimeValue& user_time, TimeValue& sys_time)
  92 {
  93   elapsed = TimeValue::now();
  94
  95   uint64_t ProcCreate, ProcExit, KernelTime, UserTime;
  96   GetProcessTimes(GetCurrentProcess(), (FILETIME*)&ProcCreate,
  97                   (FILETIME*)&ProcExit, (FILETIME*)&KernelTime,
  98                   (FILETIME*)&UserTime);
  99
 100   // FILETIME's are # of 100 nanosecond ticks (1/10th of a microsecond)
 101   user_time.seconds( UserTime / 10000000 );
 102   user_time.nanoseconds( unsigned(UserTime % 10000000) * 100 );
 103   sys_time.seconds( KernelTime / 10000000 );
 104   sys_time.nanoseconds( unsigned(KernelTime % 10000000) * 100 );
 105 }
 106
 107 int Process::GetCurrentUserId()
 108 {
 109   return 65536;
 110 }
 111
 112 int Process::GetCurrentGroupId()
 113 {
 114   return 65536;
 115 }
 116
 117 // Some LLVM programs such as bugpoint produce core files as a normal part of
 118 // their operation. To prevent the disk from filling up, this configuration item
 119 // does what's necessary to prevent their generation.
 120 void Process::PreventCoreFiles() {
 121   // Windows doesn't do core files, but it does do modal pop-up message
 122   // boxes.  As this method is used by bugpoint, preventing these pop-ups
 123   // is the moral equivalent of suppressing core files.
 124   SetErrorMode(SEM_FAILCRITICALERRORS |
 125                SEM_NOGPFAULTERRORBOX |
 126                SEM_NOOPENFILEERRORBOX);
 127 }
 128
 129 bool Process::StandardInIsUserInput() {
 130   return FileDescriptorIsDisplayed(0);
 131 }
 132
 133 bool Process::StandardOutIsDisplayed() {
 134   return FileDescriptorIsDisplayed(1);
 135 }
 136
 137 bool Process::StandardErrIsDisplayed() {
 138   return FileDescriptorIsDisplayed(2);
 139 }
 140
 141 bool Process::FileDescriptorIsDisplayed(int fd) {
 142   DWORD Mode;  // Unused
 143   return (GetConsoleMode((HANDLE)_get_osfhandle(fd), &Mode) != 0);
 144 }
 145
 146 unsigned Process::StandardOutColumns() {
 147   unsigned Columns = 0;
 148   CONSOLE_SCREEN_BUFFER_INFO csbi;
 149   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
 150     Columns = csbi.dwSize.X;
 151   return Columns;
 152 }
 153
 154 unsigned Process::StandardErrColumns() {
 155   unsigned Columns = 0;
 156   CONSOLE_SCREEN_BUFFER_INFO csbi;
 157   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE), &csbi))
 158     Columns = csbi.dwSize.X;
 159   return Columns;
 160 }
 161
 162 // The terminal always has colors.
 163 bool Process::FileDescriptorHasColors(int fd) {
 164   return FileDescriptorIsDisplayed(fd);
 165 }
 166
 167 bool Process::StandardOutHasColors() {
 168   return FileDescriptorHasColors(1);
 169 }
 170
 171 bool Process::StandardErrHasColors() {
 172   return FileDescriptorHasColors(2);
 173 }
 174
 175 namespace {
 176 class DefaultColors
 177 {
 178   private:
 179     WORD defaultColor;
 180   public:
 181     DefaultColors()
 182      :defaultColor(GetCurrentColor()) {}
 183     static unsigned GetCurrentColor() {
 184       CONSOLE_SCREEN_BUFFER_INFO csbi;
 185       if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi))
 186         return csbi.wAttributes;
 187       return 0;
 188     }
 189     WORD operator()() const { return defaultColor; }
 190 };
 191
 192 DefaultColors defaultColors;
 193 }
 194
 195 bool Process::ColorNeedsFlush() {
 196   return true;
 197 }
 198
 199 const char *Process::OutputBold(bool bg) {
 200   WORD colors = DefaultColors::GetCurrentColor();
 201   if (bg)
 202     colors |= BACKGROUND_INTENSITY;
 203   else
 204     colors |= FOREGROUND_INTENSITY;
 205   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
 206   return 0;
 207 }
 208
 209 const char *Process::OutputColor(char code, bool bold, bool bg) {
 210   WORD colors;
 211   if (bg) {
 212     colors = ((code&1) ? BACKGROUND_RED : 0) |
 213       ((code&2) ? BACKGROUND_GREEN : 0 ) |
 214       ((code&4) ? BACKGROUND_BLUE : 0);
 215     if (bold)
 216       colors |= BACKGROUND_INTENSITY;
 217   } else {
 218     colors = ((code&1) ? FOREGROUND_RED : 0) |
 219       ((code&2) ? FOREGROUND_GREEN : 0 ) |
 220       ((code&4) ? FOREGROUND_BLUE : 0);
 221     if (bold)
 222       colors |= FOREGROUND_INTENSITY;
 223   }
 224   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), colors);
 225   return 0;
 226 }
 227
 228 static WORD GetConsoleTextAttribute(HANDLE hConsoleOutput) {
 229   CONSOLE_SCREEN_BUFFER_INFO info;
 230   GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info);
 231   return info.wAttributes;
 232 }
 233
 234 const char *Process::OutputReverse() {
 235   const WORD attributes
 236    = GetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE));
 237
 238   const WORD foreground_mask = FOREGROUND_BLUE | FOREGROUND_GREEN |
 239     FOREGROUND_RED | FOREGROUND_INTENSITY;
 240   const WORD background_mask = BACKGROUND_BLUE | BACKGROUND_GREEN |
 241     BACKGROUND_RED | BACKGROUND_INTENSITY;
 242   const WORD color_mask = foreground_mask | background_mask;
 243
 244   WORD new_attributes =
 245     ((attributes & FOREGROUND_BLUE     )?BACKGROUND_BLUE     :0) |
 246     ((attributes & FOREGROUND_GREEN    )?BACKGROUND_GREEN    :0) |
 247     ((attributes & FOREGROUND_RED      )?BACKGROUND_RED      :0) |
 248     ((attributes & FOREGROUND_INTENSITY)?BACKGROUND_INTENSITY:0) |
 249     ((attributes & BACKGROUND_BLUE     )?FOREGROUND_BLUE     :0) |
 250     ((attributes & BACKGROUND_GREEN    )?FOREGROUND_GREEN    :0) |
 251     ((attributes & BACKGROUND_RED      )?FOREGROUND_RED      :0) |
 252     ((attributes & BACKGROUND_INTENSITY)?FOREGROUND_INTENSITY:0) |
 253     0;
 254   new_attributes = (attributes & ~color_mask) | (new_attributes & color_mask);
 255
 256   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), new_attributes);
 257   return 0;
 258 }
 259
 260 const char *Process::ResetColor() {
 261   SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), defaultColors());
 262   return 0;
 263 }
 264
 265 }