Rename TARGET_OS_* to HOST_OS_*.

runtime/vm/profiler.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/address_sanitizer.h"
 #include "platform/memory_sanitizer.h"
 #include "platform/utils.h"
 
 #include "vm/allocation.h"
 #include "vm/atomic.h"
@@ skipping 13 matching lines @@
 #include "vm/simulator.h"
 #include "vm/stack_frame.h"
 
 namespace dart {
 
 static const intptr_t kSampleSize = 8;
 static const intptr_t kMaxSamplesPerTick = 4;
 
 DEFINE_FLAG(bool, trace_profiled_isolates, false, "Trace profiled isolates.");
 
-#if defined(TARGET_OS_ANDROID) || defined(TARGET_ARCH_ARM64) ||                \
+#if defined(HOST_OS_ANDROID) || defined(TARGET_ARCH_ARM64) ||                  \
     defined(TARGET_ARCH_ARM) || defined(TARGET_ARCH_MIPS)
 DEFINE_FLAG(int,
             profile_period,
             10000,
             "Time between profiler samples in microseconds. Minimum 50.");
 #else
 DEFINE_FLAG(int,
             profile_period,
             1000,
             "Time between profiler samples in microseconds. Minimum 50.");
@@ skipping 682 matching lines @@
     for (intptr_t i = 0; i < Sample::kStackBufferSizeInWords; i++) {
       MSAN_UNPOISON(sp, kWordSize);
       ASAN_UNPOISON(sp, kWordSize);
       buffer[i] = *sp;
       sp++;
     }
   }
 }
 
 
-#if defined(TARGET_OS_WINDOWS)
+#if defined(HOST_OS_WINDOWS)
 // On Windows this code is synchronously executed from the thread interrupter
 // thread. This means we can safely have a static fault_address.
 static uword fault_address = 0;
 static LONG GuardPageExceptionFilter(EXCEPTION_POINTERS* ep) {
   fault_address = 0;
   if (ep->ExceptionRecord->ExceptionCode != STATUS_GUARD_PAGE_VIOLATION) {
     return EXCEPTION_CONTINUE_SEARCH;
   }
   // https://goo.gl/p5Fe10
   fault_address = ep->ExceptionRecord->ExceptionInformation[1];
   // Read access.
   ASSERT(ep->ExceptionRecord->ExceptionInformation[0] == 0);
   return EXCEPTION_EXECUTE_HANDLER;
 }
 #endif
 
 // All memory access done to collect the sample is performed in CollectSample.
 static void CollectSample(Isolate* isolate,
                           bool exited_dart_code,
                           bool in_dart_code,
                           Sample* sample,
                           ProfilerNativeStackWalker* native_stack_walker,
                           ProfilerDartStackWalker* dart_stack_walker,
                           uword pc,
                           uword fp,
                           uword sp,
                           ProfilerCounters* counters) {
   ASSERT(counters != NULL);
-#if defined(TARGET_OS_WINDOWS)
+#if defined(HOST_OS_WINDOWS)
   // Use structured exception handling to trap guard page access on Windows.
   __try {
 #endif
 
     if (in_dart_code) {
       // We can only trust the stack pointer if we are executing Dart code.
       // See http://dartbug.com/20421 for details.
       CopyStackBuffer(sample, sp);
     }
 
     if (FLAG_profile_vm) {
       // Always walk the native stack collecting both native and Dart frames.
       AtomicOperations::IncrementInt64By(&counters->stack_walker_native, 1);
       native_stack_walker->walk();
     } else if (StubCode::HasBeenInitialized() && exited_dart_code) {
       AtomicOperations::IncrementInt64By(&counters->stack_walker_dart_exit, 1);
       // We have a valid exit frame info, use the Dart stack walker.
       dart_stack_walker->walk();
     } else if (StubCode::HasBeenInitialized() && in_dart_code) {
       AtomicOperations::IncrementInt64By(&counters->stack_walker_dart, 1);
       // We are executing Dart code. We have frame pointers.
       dart_stack_walker->walk();
     } else {
       AtomicOperations::IncrementInt64By(&counters->stack_walker_none, 1);
       sample->SetAt(0, pc);
     }
 
-#if defined(TARGET_OS_WINDOWS)
+#if defined(HOST_OS_WINDOWS)
     // Use structured exception handling to trap guard page access.
   } __except (GuardPageExceptionFilter(GetExceptionInformation())) {  // NOLINT
     // Sample collection triggered a guard page fault:
     // 1) discard entire sample.
     sample->set_ignore_sample(true);
 
     // 2) Reenable guard bit on page that triggered the fault.
     // https://goo.gl/5mCsXW
     DWORD new_protect = PAGE_READWRITE | PAGE_GUARD;
     DWORD old_protect = 0;
@@ skipping 149 matching lines @@
 static bool CheckIsolate(Isolate* isolate) {
   if ((isolate == NULL) || (Dart::vm_isolate() == NULL)) {
     // No isolate.
     return false;
   }
   return isolate != Dart::vm_isolate();
 }
 
 
 void Profiler::DumpStackTrace(void* context) {
-#if defined(TARGET_OS_LINUX) || defined(TARGET_OS_MACOS)
+#if defined(HOST_OS_LINUX) || defined(HOST_OS_MACOS)
   ucontext_t* ucontext = reinterpret_cast<ucontext_t*>(context);
   mcontext_t mcontext = ucontext->uc_mcontext;
   uword pc = SignalHandler::GetProgramCounter(mcontext);
   uword fp = SignalHandler::GetFramePointer(mcontext);
   uword sp = SignalHandler::GetCStackPointer(mcontext);
   DumpStackTrace(sp, fp, pc);
 #else
 // TODO(fschneider): Add support for more platforms.
 // Do nothing on unsupported platforms.
 #endif
@@ skipping 617 matching lines @@
 
 
 ProcessedSampleBuffer::ProcessedSampleBuffer()
     : code_lookup_table_(new CodeLookupTable(Thread::Current())) {
   ASSERT(code_lookup_table_ != NULL);
 }
 
 #endif  // !PRODUCT
 
 }  // namespace dart