[LLVM] Fix Clang-tidy modernize-deprecated-headers warnings in remaining files; other minor fixes

[Eugene.Zelenko]

Summary

Some Include What You Use suggestions were used too.

Use anonymous namespaces in source files.

I checked this patch on my own build on RHEL 6. Regressions were OK.

[aaron.ballman]

lib/Support/CrashRecoveryContext.cpp

12 ↗

(On Diff #52643)

Can you sort these includes, or was this the ordering generated?

lib/Support/SHA1.cpp

50 ↗

(On Diff #52643)

I think that having a single static function definition is a bit more clear than having an anonymous namespace, but I don't feel that strongly about it. Thoughts?

[Eugene.Zelenko]

lib/Support/CrashRecoveryContext.cpp

12 ↗

(On Diff #52643)

Will do in commit.

lib/Support/SHA1.cpp

50 ↗

(On Diff #52643)

I definitely saw single functions in anonymous namespace in LLVM code.

[aaron.ballman]

LGTM (with minor nit about header ordering).

lib/Support/SHA1.cpp

50 ↗

(On Diff #52643)

I've seen it before, I'm just not convinced it's actually worth the extra few lines of code. Regardless, we prefer inline namespaces, so I say it's good enough.

llvm/trunk/lib/Support/APFloat.cpp

 //===-- APFloat.cpp - Implement APFloat class -----------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements a class to represent arbitrary precision floating
 // point values and provide a variety of arithmetic operations on them.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/APSInt.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
 #include <cstring>
-#include <limits.h>
+#include <limits>
 
 using namespace llvm;
 
 /// A macro used to combine two fcCategory enums into one key which can be used
 /// in a switch statement to classify how the interaction of two APFloat's
 /// categories affects an operation.
 ///
 /// TODO: If clang source code is ever allowed to use constexpr in its own
/* A tight upper bound on number of parts required to hold the value
      being zero (consider the trivial case of 1 * 1, tcFullMultiply
      requires two parts to hold the single-part result).  So we add an
      extra one to guarantee enough space whilst multiplying.  */
   const unsigned int maxExponent = 16383;
   const unsigned int maxPrecision = 113;
   const unsigned int maxPowerOfFiveExponent = maxExponent + maxPrecision - 1;
   const unsigned int maxPowerOfFiveParts = 2 + ((maxPowerOfFiveExponent * 815)
                                                 / (351 * integerPartWidth));
-}
+
+} // end namespace llvm
+
+namespace {
 
 /* A bunch of private, handy routines.  */
 
-static inline unsigned int
+inline unsigned int
 partCountForBits(unsigned int bits)
 {
   return ((bits) + integerPartWidth - 1) / integerPartWidth;
 }
 
 /* Returns 0U-9U.  Return values >= 10U are not digits.  */
-static inline unsigned int
+inline unsigned int
 decDigitValue(unsigned int c)
 {
   return c - '0';
 }
 
 /* Return the value of a decimal exponent of the form
    [+-]ddddddd.
 
    If the exponent overflows, returns a large exponent with the
    appropriate sign.  */
-static int
+int
 readExponent(StringRef::iterator begin, StringRef::iterator end)
 {
   bool isNegative;
   unsigned int absExponent;
   const unsigned int overlargeExponent = 24000;  /* FIXME.  */
   StringRef::iterator p = begin;
 
   assert(p != end && "Exponent has no digits");
readExponent(StringRef::iterator begin, StringRef::iterator end)
   if (isNegative)
     return -(int) absExponent;
   else
     return (int) absExponent;
 }
 
 /* This is ugly and needs cleaning up, but I don't immediately see
    how whilst remaining safe.  */
-static int
+int
 totalExponent(StringRef::iterator p, StringRef::iterator end,
               int exponentAdjustment)
 {
   int unsignedExponent;
   bool negative, overflow;
   int exponent = 0;
 
   assert(p != end && "Exponent has no digits");
totalExponent(StringRef::iterator p, StringRef::iterator end,
   }
 
   if (overflow)
     exponent = negative ? -32768: 32767;
 
   return exponent;
 }
 
-static StringRef::iterator
+StringRef::iterator
 skipLeadingZeroesAndAnyDot(StringRef::iterator begin, StringRef::iterator end,
                            StringRef::iterator *dot)
 {
   StringRef::iterator p = begin;
   *dot = end;
   while (p != end && *p == '0')
     p++;
 

 */
 struct decimalInfo {
   const char *firstSigDigit;
   const char *lastSigDigit;
   int exponent;
   int normalizedExponent;
 };
 
-static void
+void
 interpretDecimal(StringRef::iterator begin, StringRef::iterator end,
                  decimalInfo *D)
 {
   StringRef::iterator dot = end;
   StringRef::iterator p = skipLeadingZeroesAndAnyDot (begin, end, &dot);
 
   D->firstSigDigit = p;
   D->exponent = 0;
interpretDecimal(StringRef::iterator begin, StringRef::iterator end,
   }
 
   D->lastSigDigit = p;
 }
 
 /* Return the trailing fraction of a hexadecimal number.
    DIGITVALUE is the first hex digit of the fraction, P points to
    the next digit.  */
-static lostFraction
+lostFraction
 trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
                             unsigned int digitValue)
 {
   unsigned int hexDigit;
 
   /* If the first trailing digit isn't 0 or 8 we can work out the
      fraction immediately.  */
   if (digitValue > 8)
trailingHexadecimalFraction(StringRef::iterator p, StringRef::iterator end,
   if (hexDigit == -1U)
     return digitValue == 0 ? lfExactlyZero: lfExactlyHalf;
   else
     return digitValue == 0 ? lfLessThanHalf: lfMoreThanHalf;
 }
 
 /* Return the fraction lost were a bignum truncated losing the least
    significant BITS bits.  */
-static lostFraction
+lostFraction
 lostFractionThroughTruncation(const integerPart *parts,
                               unsigned int partCount,
                               unsigned int bits)
 {
   unsigned int lsb;
 
   lsb = APInt::tcLSB(parts, partCount);
 
   /* Note this is guaranteed true if bits == 0, or LSB == -1U.  */
   if (bits <= lsb)
     return lfExactlyZero;
   if (bits == lsb + 1)
     return lfExactlyHalf;
   if (bits <= partCount * integerPartWidth &&
       APInt::tcExtractBit(parts, bits - 1))
     return lfMoreThanHalf;
 
   return lfLessThanHalf;
 }
 
 /* Shift DST right BITS bits noting lost fraction.  */
-static lostFraction
+lostFraction
 shiftRight(integerPart *dst, unsigned int parts, unsigned int bits)
 {
   lostFraction lost_fraction;
 
   lost_fraction = lostFractionThroughTruncation(dst, parts, bits);
 
   APInt::tcShiftRight(dst, parts, bits);
 
   return lost_fraction;
 }
 
 /* Combine the effect of two lost fractions.  */
-static lostFraction
+lostFraction
 combineLostFractions(lostFraction moreSignificant,
                      lostFraction lessSignificant)
 {
   if (lessSignificant != lfExactlyZero) {
     if (moreSignificant == lfExactlyZero)
       moreSignificant = lfLessThanHalf;
     else if (moreSignificant == lfExactlyHalf)
       moreSignificant = lfMoreThanHalf;
   }
 
   return moreSignificant;
 }
 
 /* The error from the true value, in half-ulps, on multiplying two
    floating point numbers, which differ from the value they
    approximate by at most HUE1 and HUE2 half-ulps, is strictly less
    than the returned value.
 
    See "How to Read Floating Point Numbers Accurately" by William D
    Clinger.  */
-static unsigned int
+unsigned int
 HUerrBound(bool inexactMultiply, unsigned int HUerr1, unsigned int HUerr2)
 {
   assert(HUerr1 < 2 || HUerr2 < 2 || (HUerr1 + HUerr2 < 8));
 
   if (HUerr1 + HUerr2 == 0)
     return inexactMultiply * 2;  /* <= inexactMultiply half-ulps.  */
   else
     return inexactMultiply + 2 * (HUerr1 + HUerr2);
 }
 
 /* The number of ulps from the boundary (zero, or half if ISNEAREST)
    when the least significant BITS are truncated.  BITS cannot be
    zero.  */
-static integerPart
+integerPart
 ulpsFromBoundary(const integerPart *parts, unsigned int bits, bool isNearest)
 {
   unsigned int count, partBits;
   integerPart part, boundary;
 
   assert(bits != 0);
 
   bits--;
if (part == boundary) {
     return -parts[0];
   }
 
   return ~(integerPart) 0; /* A lot.  */
 }
 
 /* Place pow(5, power) in DST, and return the number of parts used.
    DST must be at least one part larger than size of the answer.  */
-static unsigned int
+unsigned int
 powerOf5(integerPart *dst, unsigned int power)
 {
   static const integerPart firstEightPowers[] = { 1, 5, 25, 125, 625, 3125,
                                                   15625, 78125 };
   integerPart pow5s[maxPowerOfFiveParts * 2 + 5];
   pow5s[0] = 78125 * 5;
 
   unsigned int partsCount[16] = { 1 };
powerOf5(integerPart *dst, unsigned int power)
   if (p1 != dst)
     APInt::tcAssign(dst, p1, result);
 
   return result;
 }
 
 /* Zero at the end to avoid modular arithmetic when adding one; used
    when rounding up during hexadecimal output.  */
-static const char hexDigitsLower[] = "0123456789abcdef0";
-static const char hexDigitsUpper[] = "0123456789ABCDEF0";
-static const char infinityL[] = "infinity";
-static const char infinityU[] = "INFINITY";
-static const char NaNL[] = "nan";
-static const char NaNU[] = "NAN";
+const char hexDigitsLower[] = "0123456789abcdef0";
+const char hexDigitsUpper[] = "0123456789ABCDEF0";
+const char infinityL[] = "infinity";
+const char infinityU[] = "INFINITY";
+const char NaNL[] = "nan";
+const char NaNU[] = "NAN";
 
 /* Write out an integerPart in hexadecimal, starting with the most
    significant nibble.  Write out exactly COUNT hexdigits, return
    COUNT.  */
-static unsigned int
+unsigned int
 partAsHex (char *dst, integerPart part, unsigned int count,
            const char *hexDigitChars)
 {
   unsigned int result = count;
 
   assert(count != 0 && count <= integerPartWidth / 4);
 
   part >>= (integerPartWidth - 4 * count);
   while (count--) {
     dst[count] = hexDigitChars[part & 0xf];
     part >>= 4;
   }
 
   return result;
 }
 
 /* Write out an unsigned decimal integer.  */
-static char *
+char *
 writeUnsignedDecimal (char *dst, unsigned int n)
 {
   char buff[40], *p;
 
   p = buff;
   do
     *p++ = '0' + n % 10;
   while (n /= 10);
 
   do
     *dst++ = *--p;
   while (p != buff);
 
   return dst;
 }
 
 /* Write out a signed decimal integer.  */
-static char *
+char *
 writeSignedDecimal (char *dst, int value)
 {
   if (value < 0) {
     *dst++ = '-';
     dst = writeUnsignedDecimal(dst, -(unsigned) value);
   } else
     dst = writeUnsignedDecimal(dst, value);
 
   return dst;
 }
 
+} // end anonymous namespace
+
 /* Constructors.  */
 void
 APFloat::initialize(const fltSemantics *ourSemantics)
 {
   unsigned int count;
 
   semantics = ourSemantics;
   count = partCount();
APFloat::partCount() const
   return partCountForBits(semantics->precision + 1);
 }
 
 unsigned int
 APFloat::semanticsPrecision(const fltSemantics &semantics)
 {
   return semantics.precision;
 }
+
 APFloat::ExponentType
 APFloat::semanticsMaxExponent(const fltSemantics &semantics)
 {
   return semantics.maxExponent;
 }
+
 APFloat::ExponentType
 APFloat::semanticsMinExponent(const fltSemantics &semantics)
 {
   return semantics.minExponent;
 }
 unsigned int
 APFloat::semanticsSizeInBits(const fltSemantics &semantics)
 {
APFloat::opStatus APFloat::roundToIntegral(roundingMode rounding_mode) {
 
   // Restore the input sign.
   if (inputSign != isNegative())
     changeSign();
 
   return fs;
 }
 
-
 /* Comparison requires normalized numbers.  */
 APFloat::cmpResult
 APFloat::compare(const APFloat &rhs) const
 {
   cmpResult result;
 
   assert(semantics == rhs.semantics);
 
APFloat::convertFromDecimalString(StringRef str, roundingMode rounding_mode)
   // be at most one dot. On the other hand, if we have a zero with a non-zero
   // exponent, then we know that D.firstSigDigit will be non-numeric.
   if (D.firstSigDigit == str.end() || decDigitValue(*D.firstSigDigit) >= 10U) {
     category = fcZero;
     fs = opOK;
 
   /* Check whether the normalized exponent is high enough to overflow
      max during the log-rebasing in the max-exponent check below. */
-  } else if (D.normalizedExponent - 1 > INT_MAX / 42039) {
+  } else if (D.normalizedExponent - 1 >
+              std::numeric_limits<int>::max() / 42039) {
     fs = handleOverflow(rounding_mode);
 
   /* If it wasn't, then it also wasn't high enough to overflow max
      during the log-rebasing in the min-exponent check.  Check that it
      won't overflow min in either check, then perform the min-exponent
      check. */
-  } else if (D.normalizedExponent - 1 < INT_MIN / 42039 ||
+  } else if ((D.normalizedExponent - 1 <
+               std::numeric_limits<int>::min() / 42039) ||
              (D.normalizedExponent + 1) * 28738 <=
                8651 * (semantics->minExponent - (int) semantics->precision)) {
     /* Underflow to zero and round.  */
     category = fcNormal;
     zeroSignificand();
     fs = normalize(rounding_mode, lfLessThanHalf);
 
   /* We can finally safely perform the max-exponent check. */
APFloat::initFromQuadrupleAPInt(const APInt &api)
   assert(api.getBitWidth()==128);
   uint64_t i1 = api.getRawData()[0];
   uint64_t i2 = api.getRawData()[1];
   uint64_t myexponent = (i2 >> 48) & 0x7fff;
   uint64_t mysignificand  = i1;
   uint64_t mysignificand2 = i2 & 0xffffffffffffLL;
 
   initialize(&APFloat::IEEEquad);
-  assert(partCount()==2);
+  assert(partCount() == 2);
 
   sign = static_cast<unsigned int>(i2>>63);
   if (myexponent==0 &&
       (mysignificand==0 && mysignificand2==0)) {
     // exponent, significand meaningless
     category = fcZero;
   } else if (myexponent==0x7fff &&
              (mysignificand==0 && mysignificand2==0)) {
APFloat::APFloat(float f) {
   initFromAPInt(&IEEEsingle, APInt::floatToBits(f));
 }
 
 APFloat::APFloat(double d) {
   initFromAPInt(&IEEEdouble, APInt::doubleToBits(d));
 }
 
 namespace {
+
   void append(SmallVectorImpl<char> &Buffer, StringRef Str) {
     Buffer.append(Str.begin(), Str.end());
   }
 
   /// Removes data from the given significand until it is no more
   /// precise than is required for the desired precision.
   void AdjustToPrecision(APInt &significand,
                          int &exp, unsigned FormatPrecision) {
void AdjustToPrecision(APInt &significand,
     }
 
     significand = significand.udiv(divisor);
 
     // Truncate the significand down to its active bit count.
     significand = significand.trunc(significand.getActiveBits());
   }
 
-
   void AdjustToPrecision(SmallVectorImpl<char> &buffer,
                          int &exp, unsigned FormatPrecision) {
     unsigned N = buffer.size();
     if (N <= FormatPrecision) return;
 
     // The most significant figures are the last ones in the buffer.
     unsigned FirstSignificant = N - FormatPrecision;
 
if (FirstSignificant == N) {
       buffer.clear();
       buffer.push_back('1');
       return;
     }
 
     exp += FirstSignificant;
     buffer.erase(&buffer[0], &buffer[FirstSignificant]);
   }
-}
+
+} // end anonymous namespace
 
 void APFloat::toString(SmallVectorImpl<char> &Str,
                        unsigned FormatPrecision,
                        unsigned FormatMaxPadding) const {
   switch (category) {
   case fcInfinity:
     if (isNegative())
       return append(Str, "-Inf");

llvm/trunk/lib/Support/CrashRecoveryContext.cpp

 //===--- CrashRecoveryContext.cpp - Crash Recovery ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/CrashRecoveryContext.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/ThreadLocal.h"
-#include <setjmp.h>
+#include "llvm/Support/Threading.h"
+#include <cassert>
+#include <csetjmp>
+
 using namespace llvm;
 
 namespace {
 
 struct CrashRecoveryContextImpl;
 
-static ManagedStatic<
+ManagedStatic<
     sys::ThreadLocal<const CrashRecoveryContextImpl> > CurrentContext;
 
 struct CrashRecoveryContextImpl {
   // When threads are disabled, this links up all active
   // CrashRecoveryContextImpls.  When threads are enabled there's one thread
   // per CrashRecoveryContext and CurrentContext is a thread-local, so only one
   // CrashRecoveryContextImpl is active per thread and this is always null.
   const CrashRecoveryContextImpl *Next;
 
   CrashRecoveryContext *CRC;
   ::jmp_buf JumpBuffer;
   volatile unsigned Failed : 1;
   unsigned SwitchedThread : 1;
 
 public:
   CrashRecoveryContextImpl(CrashRecoveryContext *CRC) : CRC(CRC),
                                                         Failed(false),
                                                         SwitchedThread(false) {
     Next = CurrentContext->get();
     CurrentContext->set(this);
   }
+
   ~CrashRecoveryContextImpl() {
     if (!SwitchedThread)
       CurrentContext->set(Next);
   }
 
   /// \brief Called when the separate crash-recovery thread was finished, to
   /// indicate that we don't need to clear the thread-local CurrentContext.
   void setSwitchedThread() { 
void HandleCrash() {
 
     // FIXME: Stash the backtrace.
 
     // Jump back to the RunSafely we were called under.
     longjmp(JumpBuffer, 1);
   }
 };
 
-}
+ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
+bool gCrashRecoveryEnabled = false;
 
-static ManagedStatic<sys::Mutex> gCrashRecoveryContextMutex;
-static bool gCrashRecoveryEnabled = false;
-
-static ManagedStatic<sys::ThreadLocal<const CrashRecoveryContext>>
+ManagedStatic<sys::ThreadLocal<const CrashRecoveryContext>>
        tlIsRecoveringFromCrash;
 
+} // end anonymous namespace
+
 CrashRecoveryContextCleanup::~CrashRecoveryContextCleanup() {}
 
 CrashRecoveryContext::~CrashRecoveryContext() {
   // Reclaim registered resources.
   CrashRecoveryContextCleanup *i = head;
   const CrashRecoveryContext *PC = tlIsRecoveringFromCrash->get();
   tlIsRecoveringFromCrash->set(this);
   while (i) {

 // The vectored exception handler functionality was added in Windows
 // XP, so if support for older versions of Windows is required,
 // it will have to be added.
 //
 // If we want to support as far back as Win2k, we could use the
 // SetUnhandledExceptionFilter API, but there's a risk of that
 // being entirely overwritten (it's not a chain).
 
-static LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
+namespace {
+
+LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
 {
   // Lookup the current thread local recovery object.
   const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
 
   if (!CRCI) {
     // Something has gone horribly wrong, so let's just tell everyone
     // to keep searching
     CrashRecoveryContext::Disable();
LONG CALLBACK ExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo)
   llvm_unreachable("Handled the crash, should have longjmp'ed out of here");
 }
 
 // Because the Enable and Disable calls are static, it means that
 // there may not actually be an Impl available, or even a current
 // CrashRecoveryContext at all.  So we make use of a thread-local
 // exception table.  The handles contained in here will either be
 // non-NULL, valid VEH handles, or NULL.
-static sys::ThreadLocal<const void> sCurrentExceptionHandle;
+sys::ThreadLocal<const void> sCurrentExceptionHandle;
+
+} // end anonymous namespace
 
 void CrashRecoveryContext::Enable() {
   sys::ScopedLock L(*gCrashRecoveryContextMutex);
 
   if (gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = true;

 // current thread. We use a thread local object to keep track of the active
 // crash recovery context, and install signal handlers to invoke HandleCrash on
 // the active object.
 //
 // This implementation does not to attempt to chain signal handlers in any
 // reliable fashion -- if we get a signal outside of a crash recovery context we
 // simply disable crash recovery and raise the signal again.
 
-#include <signal.h>
+#include <csignal>
 
-static const int Signals[] =
-    { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP };
-static const unsigned NumSignals = array_lengthof(Signals);
-static struct sigaction PrevActions[NumSignals];
+namespace {
 
-static void CrashRecoverySignalHandler(int Signal) {
+const int Signals[] = { SIGABRT, SIGBUS, SIGFPE, SIGILL, SIGSEGV, SIGTRAP };
+const unsigned NumSignals = array_lengthof(Signals);
+struct sigaction PrevActions[NumSignals];
+
+void CrashRecoverySignalHandler(int Signal) {
   // Lookup the current thread local recovery object.
   const CrashRecoveryContextImpl *CRCI = CurrentContext->get();
 
   if (!CRCI) {
     // We didn't find a crash recovery context -- this means either we got a
     // signal on a thread we didn't expect it on, the application got a signal
     // outside of a crash recovery context, or something else went horribly
     // wrong.
void CrashRecoverySignalHandler(int Signal) {
   sigemptyset(&SigMask);
   sigaddset(&SigMask, Signal);
   sigprocmask(SIG_UNBLOCK, &SigMask, nullptr);
 
   if (CRCI)
     const_cast<CrashRecoveryContextImpl*>(CRCI)->HandleCrash();
 }
 
+} // end anonymous namespace
+
 void CrashRecoveryContext::Enable() {
   sys::ScopedLock L(*gCrashRecoveryContextMutex);
 
   if (gCrashRecoveryEnabled)
     return;
 
   gCrashRecoveryEnabled = true;
 

 }
 
 void CrashRecoveryContext::HandleCrash() {
   CrashRecoveryContextImpl *CRCI = (CrashRecoveryContextImpl *) Impl;
   assert(CRCI && "Crash recovery context never initialized!");
   CRCI->HandleCrash();
 }
 
+namespace {
+
 // FIXME: Portability.
-static void setThreadBackgroundPriority() {
+void setThreadBackgroundPriority() {
 #ifdef __APPLE__
   setpriority(PRIO_DARWIN_THREAD, 0, PRIO_DARWIN_BG);
 #endif
 }
 
-static bool hasThreadBackgroundPriority() {
+bool hasThreadBackgroundPriority() {
 #ifdef __APPLE__
   return getpriority(PRIO_DARWIN_THREAD, 0) == 1;
 #else
   return false;
 #endif
 }
 
-namespace {
 struct RunSafelyOnThreadInfo {
   function_ref<void()> Fn;
   CrashRecoveryContext *CRC;
   bool UseBackgroundPriority;
   bool Result;
 };
-}
 
-static void RunSafelyOnThread_Dispatch(void *UserData) {
+void RunSafelyOnThread_Dispatch(void *UserData) {
   RunSafelyOnThreadInfo *Info =
     reinterpret_cast<RunSafelyOnThreadInfo*>(UserData);
 
   if (Info->UseBackgroundPriority)
     setThreadBackgroundPriority();
 
   Info->Result = Info->CRC->RunSafely(Info->Fn);
 }
+
+} // end anonymous namespace
+
 bool CrashRecoveryContext::RunSafelyOnThread(function_ref<void()> Fn,
                                              unsigned RequestedStackSize) {
   bool UseBackgroundPriority = hasThreadBackgroundPriority();
   RunSafelyOnThreadInfo Info = { Fn, this, UseBackgroundPriority, false };
   llvm_execute_on_thread(RunSafelyOnThread_Dispatch, &Info, RequestedStackSize);
   if (CrashRecoveryContextImpl *CRC = (CrashRecoveryContextImpl *)Impl)
     CRC->setSwitchedThread();
   return Info.Result;
 }

llvm/trunk/lib/Support/Errno.cpp

 //===- Errno.cpp - errno support --------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the errno wrappers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Errno.h"
 #include "llvm/Config/config.h"     // Get autoconf configuration settings
 #include "llvm/Support/raw_ostream.h"
-#include <string.h>
-
-#if HAVE_ERRNO_H
-#include <errno.h>
-#endif
+#include <cerrno>
+#include <cstring>
+#include <string>
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only TRULY operating system
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
 namespace llvm {
 namespace sys {
 
 #if HAVE_ERRNO_H
 std::string StrError() {
   return StrError(errno);
 }
-#endif  // HAVE_ERRNO_H
+#endif // HAVE_ERRNO_H
 
 std::string StrError(int errnum) {
   std::string str;
   if (errnum == 0)
     return str;
 #if defined(HAVE_STRERROR_R) || HAVE_DECL_STRERROR_S
   const int MaxErrStrLen = 2000;
   char buffer[MaxErrStrLen];
#else
   // but, oh well, just use a generic message
   raw_string_ostream stream(str);
   stream << "Error #" << errnum;
   stream.flush();
 #endif
   return str;
 }
 
-}  // namespace sys
-}  // namespace llvm
+} // namespace sys
+} // namespace llvm

llvm/trunk/lib/Support/Host.cpp

 #include "llvm/Support/Host.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/raw_ostream.h"
-#include <string.h>
+#include <cstring>
+#include <string>
 
 // Include the platform-specific parts of this class.
 #ifdef LLVM_ON_UNIX
 #include "Unix/Host.inc"
 #endif
 #ifdef LLVM_ON_WIN32
 #include "Windows/Host.inc"
 #endif

 //===----------------------------------------------------------------------===//
 //
 //  Implementations of the CPU detection routines
 //
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 
+namespace {
+
 #if defined(__linux__)
-static ssize_t LLVM_ATTRIBUTE_UNUSED readCpuInfo(void *Buf, size_t Size) {
+ssize_t LLVM_ATTRIBUTE_UNUSED readCpuInfo(void *Buf, size_t Size) {
   // Note: We cannot mmap /proc/cpuinfo here and then process the resulting
   // memory buffer because the 'file' has 0 size (it can be read from only
   // as a stream).
 
   int FD;
   std::error_code EC = sys::fs::openFileForRead("/proc/cpuinfo", FD);
   if (EC) {
     DEBUG(dbgs() << "Unable to open /proc/cpuinfo: " << EC.message() << "\n");
     return -1;
   }
   int Ret = read(FD, Buf, Size);
   int CloseStatus = close(FD);
   if (CloseStatus)
     return -1;
   return Ret;
 }
 #endif
 
 #if defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)\
  || defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
 
 /// GetX86CpuIDAndInfo - Execute the specified cpuid and return the 4 values in the
 /// specified arguments.  If we can't run cpuid on the host, return true.
-static bool GetX86CpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX,
-                               unsigned *rECX, unsigned *rEDX) {
+bool GetX86CpuIDAndInfo(unsigned value, unsigned *rEAX, unsigned *rEBX,
 #if defined(__GNUC__) || defined(__clang__)
   #if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
     // gcc doesn't know cpuid would clobber ebx/rbx. Preseve it manually.
     asm ("movq\t%%rbx, %%rsi\n\t"
          "cpuid\n\t"
          "xchgq\t%%rbx, %%rsi\n\t"
          : "=a" (*rEAX),
            "=S" (*rEBX),

 #else
   return true;
 #endif
 }
 
 /// GetX86CpuIDAndInfoEx - Execute the specified cpuid with subleaf and return the
 /// 4 values in the specified arguments.  If we can't run cpuid on the host,
 /// return true.
-static bool GetX86CpuIDAndInfoEx(unsigned value, unsigned subleaf,
-                                 unsigned *rEAX, unsigned *rEBX, unsigned *rECX,
-                                 unsigned *rEDX) {
+bool GetX86CpuIDAndInfoEx(unsigned value, unsigned subleaf, unsigned *rEAX,
+                          unsigned *rEBX, unsigned *rECX, unsigned *rEDX) {
 #if defined(__x86_64__) || defined(_M_AMD64) || defined (_M_X64)
   #if defined(__GNUC__)
     // gcc doesn't know cpuid would clobber ebx/rbx. Preseve it manually.
     asm ("movq\t%%rbx, %%rsi\n\t"
          "cpuid\n\t"
          "xchgq\t%%rbx, %%rsi\n\t"
          : "=a" (*rEAX),
            "=S" (*rEBX),
#elif defined(i386) || defined(__i386__) || defined(__x86__) || defined(_M_IX86)
   #else
     return true;
   #endif
 #else
   return true;
 #endif
 }
 
-static bool GetX86XCR0(unsigned *rEAX, unsigned *rEDX) {
+bool GetX86XCR0(unsigned *rEAX, unsigned *rEDX) {
 #if defined(__GNUC__)
   // Check xgetbv; this uses a .byte sequence instead of the instruction
   // directly because older assemblers do not include support for xgetbv and
   // there is no easy way to conditionally compile based on the assembler used.
   __asm__ (".byte 0x0f, 0x01, 0xd0" : "=a" (*rEAX), "=d" (*rEDX) : "c" (0));
   return false;
 #elif defined(_MSC_FULL_VER) && defined(_XCR_XFEATURE_ENABLED_MASK)
   unsigned long long Result = _xgetbv(_XCR_XFEATURE_ENABLED_MASK);
   *rEAX = Result;
   *rEDX = Result >> 32;
   return false;
 #else
   return true;
 #endif
 }
 
-static void DetectX86FamilyModel(unsigned EAX, unsigned &Family,
-                                 unsigned &Model) {
+void DetectX86FamilyModel(unsigned EAX, unsigned &Family, unsigned &Model) {
   Family = (EAX >> 8) & 0xf; // Bits 8 - 11
   Model  = (EAX >> 4) & 0xf; // Bits 4 - 7
   if (Family == 6 || Family == 0xf) {
     if (Family == 0xf)
       // Examine extended family ID if family ID is F.
       Family += (EAX >> 20) & 0xff;    // Bits 20 - 27
     // Examine extended model ID if family ID is 6 or F.
     Model += ((EAX >> 16) & 0xf) << 4; // Bits 16 - 19
   }
 }
 
+} // end anonymous namespace
+
 StringRef sys::getHostCPUName() {
   unsigned EAX = 0, EBX = 0, ECX = 0, EDX = 0;
   if (GetX86CpuIDAndInfo(0x1, &EAX, &EBX, &ECX, &EDX))
     return "generic";
   unsigned Family = 0;
   unsigned Model  = 0;
   DetectX86FamilyModel(EAX, Family, Model);
 

llvm/trunk/lib/Support/MathExtras.cpp

-//===-- MathExtras.cpp - Implement the MathExtras header --------------===//
+//===-- MathExtras.cpp - Implement the MathExtras header ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the MathExtras.h header
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/MathExtras.h"
 
 #ifdef _MSC_VER
 #include <limits>
 #else
-#include <math.h>
+#include <cmath>
 #endif
 
 namespace llvm {
 
 #if defined(_MSC_VER)
   // Visual Studio defines the HUGE_VAL class of macros using purposeful
   // constant arithmetic overflow, which it then warns on when encountered.
   const float huge_valf = std::numeric_limits<float>::infinity();
 #else
   const float huge_valf = HUGE_VALF;
 #endif
 
-}
+} // end namespace llvm

llvm/trunk/lib/Support/Mutex.cpp

 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only TRULY operating system
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
 #if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
 // Define all methods as no-ops if threading is explicitly disabled
 namespace llvm {
+
 using namespace sys;
+
 MutexImpl::MutexImpl( bool recursive) { }
 MutexImpl::~MutexImpl() { }
 bool MutexImpl::acquire() { return true; }
 bool MutexImpl::release() { return true; }
 bool MutexImpl::tryacquire() { return true; }
-}
+
+} // end namespace llvm
 #else
 
 #if defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_MUTEX_LOCK)
 
 #include <cassert>
+#include <cstdlib>
 #include <pthread.h>
-#include <stdlib.h>
 
 namespace llvm {
+
 using namespace sys;
 
 // Construct a Mutex using pthread calls
 MutexImpl::MutexImpl( bool recursive)
   : data_(nullptr)
 {
   // Declare the pthread_mutex data structures
   pthread_mutex_t* mutex =

 {
   pthread_mutex_t* mutex = static_cast<pthread_mutex_t*>(data_);
   assert(mutex != nullptr);
 
   int errorcode = pthread_mutex_trylock(mutex);
   return errorcode == 0;
 }
 
-}
+} // end namespace llvm
 
 #elif defined(LLVM_ON_UNIX)
 #include "Unix/Mutex.inc"
 #elif defined( LLVM_ON_WIN32)
 #include "Windows/Mutex.inc"
 #else
 #warning Neither LLVM_ON_UNIX nor LLVM_ON_WIN32 was set in Support/Mutex.cpp
 #endif
 #endif

llvm/trunk/lib/Support/RWMutex.cpp

 //===- RWMutex.cpp - Reader/Writer Mutual Exclusion Lock --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the llvm::sys::RWMutex class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Config/config.h"
 #include "llvm/Support/RWMutex.h"
-#include <cstring>
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only TRULY operating system
 //===          independent code.
 //===----------------------------------------------------------------------===//
 
 #if !defined(LLVM_ENABLE_THREADS) || LLVM_ENABLE_THREADS == 0
 // Define all methods as no-ops if threading is explicitly disabled
 namespace llvm {
+
 using namespace sys;
+
 RWMutexImpl::RWMutexImpl() { }
 RWMutexImpl::~RWMutexImpl() { }
 bool RWMutexImpl::reader_acquire() { return true; }
 bool RWMutexImpl::reader_release() { return true; }
 bool RWMutexImpl::writer_acquire() { return true; }
 bool RWMutexImpl::writer_release() { return true; }
-}
+
+} // end namespace llvm
 #else
 
 #if defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_RWLOCK_INIT)
 
 #include <cassert>
+#include <cstdlib>
 #include <pthread.h>
-#include <stdlib.h>
 
 namespace llvm {
+
 using namespace sys;
 
 // Construct a RWMutex using pthread calls
 RWMutexImpl::RWMutexImpl()
   : data_(nullptr)
 {
   // Declare the pthread_rwlock data structures
   pthread_rwlock_t* rwlock =

 {
   pthread_rwlock_t* rwlock = static_cast<pthread_rwlock_t*>(data_);
   assert(rwlock != nullptr);
 
   int errorcode = pthread_rwlock_unlock(rwlock);
   return errorcode == 0;
 }
 
-}
+} // end namespace llvm
 
 #elif defined(LLVM_ON_UNIX)
 #include "Unix/RWMutex.inc"
 #elif defined( LLVM_ON_WIN32)
 #include "Windows/RWMutex.inc"
 #else
 #warning Neither LLVM_ON_UNIX nor LLVM_ON_WIN32 was set in Support/Mutex.cpp
 #endif
 #endif

llvm/trunk/lib/Support/SHA1.cpp

-//======- SHA1.h - Private copy of the SHA1 implementation ---*- C++ -* ======//
+//===--- SHA1.h - Private copy of the SHA1 implementation -------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 // This code is taken from public domain
 // (http://oauth.googlecode.com/svn/code/c/liboauth/src/sha1.c)
 // and modified by wrapping it in a C++ interface for LLVM,
 // and removing unnecessary code.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/SHA1.h"
-using namespace llvm;
 
-#include <stdint.h>
-#include <string.h>
+#include <cstring>
+
+using namespace llvm;
 
 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
 #define SHA_BIG_ENDIAN
 #endif
 
 /* code */
 #define SHA1_K0 0x5a827999
 #define SHA1_K20 0x6ed9eba1
void SHA1::init() {
   InternalState.State[1] = SEED_1;
   InternalState.State[2] = SEED_2;
   InternalState.State[3] = SEED_3;
   InternalState.State[4] = SEED_4;
   InternalState.ByteCount = 0;
   InternalState.BufferOffset = 0;
 }
 
-static uint32_t rol32(uint32_t number, uint8_t bits) {
+namespace {
+
+uint32_t rol32(uint32_t number, uint8_t bits) {
   return ((number << bits) | (number >> (32 - bits)));
 }
 
+} // end anonymous namespace
+
 void SHA1::hashBlock() {
   uint8_t i;
   uint32_t a, b, c, d, e, t;
 
   a = InternalState.State[0];
   b = InternalState.State[1];
   c = InternalState.State[2];
   d = InternalState.State[3];

llvm/trunk/lib/Support/SearchForAddressOfSpecialSymbol.cpp

 //===- SearchForAddressOfSpecialSymbol.cpp - Function addresses -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file pulls the addresses of certain symbols out of the linker.  It must
 //  include as few header files as possible because it declares the symbols as
 //  void*, which would conflict with the actual symbol type if any header
 //  declared it.
 //
 //===----------------------------------------------------------------------===//
 
-#include <string.h>
+#include <cstring>
+
+namespace {
 
 // Must declare the symbols in the global namespace.
-static void *DoSearch(const char* symbolName) {
+void *DoSearch(const char* symbolName) {
 #define EXPLICIT_SYMBOL(SYM) \
    extern void *SYM; if (!strcmp(symbolName, #SYM)) return &SYM
 
   // If this is darwin, it has some funky issues, try to solve them here.  Some
   // important symbols are marked 'private external' which doesn't allow
   // SearchForAddressOfSymbol to find them.  As such, we special case them here,
   // there is only a small handful of them.
 
#ifdef __CYGWIN__
     EXPLICIT_SYMBOL(__main);
   }
 #endif
 
 #undef EXPLICIT_SYMBOL
   return nullptr;
 }
 
+} // end anonymous namespace
+
 namespace llvm {
+
 void *SearchForAddressOfSpecialSymbol(const char* symbolName) {
   return DoSearch(symbolName);
 }
-}  // namespace llvm
+
+} // end namespace llvm

llvm/trunk/lib/Support/Unix/Path.inc

 //===----------------------------------------------------------------------===//
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on *all* UNIX variants.
 //===----------------------------------------------------------------------===//
 
 #include "Unix.h"
-#include <limits.h>
-#include <stdio.h>
+#include <cassert>
+#include <climits>
+#include <cstdio>
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #if HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
 #ifdef HAVE_SYS_MMAN_H
 #include <sys/mman.h>

 using namespace llvm;
 
 namespace llvm {
 namespace sys  {
 namespace fs {
 #if defined(__FreeBSD__) || defined (__NetBSD__) || defined(__Bitrig__) || \
     defined(__OpenBSD__) || defined(__minix) || defined(__FreeBSD_kernel__) || \
     defined(__linux__) || defined(__CYGWIN__) || defined(__DragonFly__)
-static int
+
+namespace {
+
+int
 test_dir(char ret[PATH_MAX], const char *dir, const char *bin)
 {
   struct stat sb;
   char fullpath[PATH_MAX];
 
   snprintf(fullpath, PATH_MAX, "%s/%s", dir, bin);
   if (!realpath(fullpath, ret))
     return 1;
   if (stat(fullpath, &sb) != 0)
     return 1;
 
   return 0;
 }
 
-static char *
+char *
 getprogpath(char ret[PATH_MAX], const char *bin)
 {
   char *pv, *s, *t;
 
   /* First approach: absolute path. */
   if (bin[0] == '/') {
     if (test_dir(ret, "/", bin) == 0)
       return ret;
while ((t = strsep(&s, ":")) != nullptr) {
     if (test_dir(ret, t, bin) == 0) {
       free(pv);
       return ret;
     }
   }
   free(pv);
   return nullptr;
 }
+
+} // end anonymous namespace
+
 #endif // __FreeBSD__ || __NetBSD__ || __FreeBSD_kernel__
 
 /// GetMainExecutable - Return the path to the main executable, given the
 /// value of argv[0] from program startup.
 std::string getMainExecutable(const char *argv0, void *MainAddr) {
 #if defined(__APPLE__)
   // On OS X the executable path is saved to the stack by dyld. Reading it
   // from there is much faster than calling dladdr, especially for large

 
 std::error_code resize_file(int FD, uint64_t Size) {
   if (::ftruncate(FD, Size) == -1)
     return std::error_code(errno, std::generic_category());
 
   return std::error_code();
 }
 
-static int convertAccessMode(AccessMode Mode) {
+namespace {
+
+int convertAccessMode(AccessMode Mode) {
   switch (Mode) {
   case AccessMode::Exist:
     return F_OK;
   case AccessMode::Write:
     return W_OK;
   case AccessMode::Execute:
     return R_OK | X_OK; // scripts also need R_OK.
   }
   llvm_unreachable("invalid enum");
 }
 
+} // end anonymous namespace
+
 std::error_code access(const Twine &Path, AccessMode Mode) {
   SmallString<128> PathStorage;
   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 
   if (::access(P.begin(), convertAccessMode(Mode)) == -1)
     return std::error_code(errno, std::generic_category());
 
   if (Mode == AccessMode::Execute) {
std::error_code equivalent(const Twine &A, const Twine &B, bool &result) {
   if (std::error_code ec = status(A, fsA))
     return ec;
   if (std::error_code ec = status(B, fsB))
     return ec;
   result = equivalent(fsA, fsB);
   return std::error_code();
 }
 
-static std::error_code fillStatus(int StatRet, const struct stat &Status,
-                             file_status &Result) {
+namespace {
+
+std::error_code fillStatus(int StatRet, const struct stat &Status,
   if (StatRet != 0) {
     std::error_code ec(errno, std::generic_category());
     if (ec == errc::no_such_file_or_directory)
       Result = file_status(file_type::file_not_found);
     else
       Result = file_status(file_type::status_error);
     return ec;
   }
std::error_code fillStatus(int StatRet, const struct stat &Status,
   Result =
       file_status(Type, Perms, Status.st_dev, Status.st_ino, Status.st_atime,
                   Status.st_mtime, Status.st_uid, Status.st_gid,
                   Status.st_size);
 
   return std::error_code();
 }
 
+} // end anonymous namespace
+
 std::error_code status(const Twine &Path, file_status &Result) {
   SmallString<128> PathStorage;
   StringRef P = Path.toNullTerminatedStringRef(PathStorage);
 
   struct stat Status;
   int StatRet = ::stat(P.begin(), &Status);
   return fillStatus(StatRet, Status, Result);
 }
if (char *RequestedDir = getenv("HOME")) {
     result.clear();
     result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
     return true;
   }
 
   return false;
 }
 
-static bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) {
+namespace {
+
+bool getDarwinConfDir(bool TempDir, SmallVectorImpl<char> &Result) {
   #if defined(_CS_DARWIN_USER_TEMP_DIR) && defined(_CS_DARWIN_USER_CACHE_DIR)
   // On Darwin, use DARWIN_USER_TEMP_DIR or DARWIN_USER_CACHE_DIR.
   // macros defined in <unistd.h> on darwin >= 9
   int ConfName = TempDir ? _CS_DARWIN_USER_TEMP_DIR
                          : _CS_DARWIN_USER_CACHE_DIR;
   size_t ConfLen = confstr(ConfName, nullptr, 0);
   if (ConfLen > 0) {
     do {
       Result.resize(ConfLen);
       ConfLen = confstr(ConfName, Result.data(), Result.size());
     } while (ConfLen > 0 && ConfLen != Result.size());
 
     if (ConfLen > 0) {
       assert(Result.back() == 0);
       Result.pop_back();
       return true;
     }
 
     Result.clear();
   }
   #endif
   return false;
 }
 
-static bool getUserCacheDir(SmallVectorImpl<char> &Result) {
+bool getUserCacheDir(SmallVectorImpl<char> &Result) {
   // First try using XDG_CACHE_HOME env variable,
   // as specified in XDG Base Directory Specification at
   // http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
   if (const char *XdgCacheDir = std::getenv("XDG_CACHE_HOME")) {
     Result.clear();
     Result.append(XdgCacheDir, XdgCacheDir + strlen(XdgCacheDir));
     return true;
   }
 
   // Try Darwin configuration query
   if (getDarwinConfDir(false, Result))
     return true;
 
   // Use "$HOME/.cache" if $HOME is available
   if (home_directory(Result)) {
     append(Result, ".cache");
     return true;
   }
 
   return false;
 }
 
-static const char *getEnvTempDir() {
+const char *getEnvTempDir() {
   // Check whether the temporary directory is specified by an environment
   // variable.
   const char *EnvironmentVariables[] = {"TMPDIR", "TMP", "TEMP", "TEMPDIR"};
   for (const char *Env : EnvironmentVariables) {
     if (const char *Dir = std::getenv(Env))
       return Dir;
   }
 
   return nullptr;
 }
 
-static const char *getDefaultTempDir(bool ErasedOnReboot) {
+const char *getDefaultTempDir(bool ErasedOnReboot) {
 #ifdef P_tmpdir
   if ((bool)P_tmpdir)
     return P_tmpdir;
 #endif
 
   if (ErasedOnReboot)
     return "/tmp";
   return "/var/tmp";
 }
 
+} // end anonymous namespace
+
 void system_temp_directory(bool ErasedOnReboot, SmallVectorImpl<char> &Result) {
   Result.clear();
 
   if (ErasedOnReboot) {
     // There is no env variable for the cache directory.
     if (const char *RequestedDir = getEnvTempDir()) {
       Result.append(RequestedDir, RequestedDir + strlen(RequestedDir));
       return;

llvm/trunk/lib/Support/Unix/Process.inc

 #include <sys/time.h>
 #endif
 #ifdef HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
 #endif
 #ifdef HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
-#if HAVE_SIGNAL_H
-#include <signal.h>
-#endif
+#include <csignal>
 // DragonFlyBSD, OpenBSD, and Bitrig have deprecated <malloc.h> for
 // <stdlib.h> instead. Unix.h includes this for us already.
 #if defined(HAVE_MALLOC_H) && !defined(__DragonFly__) && \
     !defined(__OpenBSD__) && !defined(__Bitrig__)
 #include <malloc.h>
 #endif
 #if defined(HAVE_MALLCTL)
 #include <malloc_np.h>

 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on *all* UNIX variants.
 //===----------------------------------------------------------------------===//
 
 using namespace llvm;
 using namespace sys;
 
-static std::pair<TimeValue, TimeValue> getRUsageTimes() {
+namespace {
+
+std::pair<TimeValue, TimeValue> getRUsageTimes() {
 #if defined(HAVE_GETRUSAGE)
   struct rusage RU;
   ::getrusage(RUSAGE_SELF, &RU);
   return std::make_pair(
       TimeValue(
           static_cast<TimeValue::SecondsType>(RU.ru_utime.tv_sec),
           static_cast<TimeValue::NanoSecondsType>(
               RU.ru_utime.tv_usec * TimeValue::NANOSECONDS_PER_MICROSECOND)),
       TimeValue(
           static_cast<TimeValue::SecondsType>(RU.ru_stime.tv_sec),
           static_cast<TimeValue::NanoSecondsType>(
               RU.ru_stime.tv_usec * TimeValue::NANOSECONDS_PER_MICROSECOND)));
 #else
 #warning Cannot get usage times on this platform
   return std::make_pair(TimeValue(), TimeValue());
 #endif
 }
 
+} // end anonymous namespace
+
 // On Cygwin, getpagesize() returns 64k(AllocationGranularity) and
 // offset in mmap(3) should be aligned to the AllocationGranularity.
 unsigned Process::getPageSize() {
 #if defined(HAVE_GETPAGESIZE)
   static const int page_size = ::getpagesize();
 #elif defined(HAVE_SYSCONF)
   static long page_size = ::sysconf(_SC_PAGE_SIZE);
 #else
Process::GetArgumentVector(SmallVectorImpl<const char *> &ArgsOut,
                            ArrayRef<const char *> ArgsIn,
                            SpecificBumpPtrAllocator<char> &) {
   ArgsOut.append(ArgsIn.begin(), ArgsIn.end());
 
   return std::error_code();
 }
 
 namespace {
+
 class FDCloser {
 public:
   FDCloser(int &FD) : FD(FD), KeepOpen(false) {}
   void keepOpen() { KeepOpen = true; }
   ~FDCloser() {
     if (!KeepOpen && FD >= 0)
       ::close(FD);
   }
 
 private:
   FDCloser(const FDCloser &) = delete;
   void operator=(const FDCloser &) = delete;
 
   int &FD;
   bool KeepOpen;
 };
-}
+
+} // end anonymous namespace
 
 std::error_code Process::FixupStandardFileDescriptors() {
   int NullFD = -1;
   FDCloser FDC(NullFD);
   const int StandardFDs[] = {STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO};
   for (int StandardFD : StandardFDs) {
     struct stat st;
     errno = 0;

 #if HAVE_ISATTY
   return isatty(fd);
 #else
   // If we don't have isatty, just return false.
   return false;
 #endif
 }
 
-static unsigned getColumns(int FileID) {
+namespace {
+
+unsigned getColumns(int FileID) {
   // If COLUMNS is defined in the environment, wrap to that many columns.
   if (const char *ColumnsStr = std::getenv("COLUMNS")) {
     int Columns = std::atoi(ColumnsStr);
     if (Columns > 0)
       return Columns;
   }
 
   unsigned Columns = 0;
 
 #if defined(HAVE_SYS_IOCTL_H) && defined(HAVE_TERMIOS_H)
   // Try to determine the width of the terminal.
   struct winsize ws;
   if (ioctl(FileID, TIOCGWINSZ, &ws) == 0)
     Columns = ws.ws_col;
 #endif
 
   return Columns;
 }
 
+} // end anonymous namespace
+
 unsigned Process::StandardOutColumns() {
   if (!StandardOutIsDisplayed())
     return 0;
 
   return getColumns(1);
 }
 
 unsigned Process::StandardErrColumns() {
   if (!StandardErrIsDisplayed())
     return 0;
 
   return getColumns(2);
 }
 
 #ifdef HAVE_TERMINFO
 // We manually declare these extern functions because finding the correct
 // headers from various terminfo, curses, or other sources is harder than
 // writing their specs down.
 extern "C" int setupterm(char *term, int filedes, int *errret);
 extern "C" struct term *set_curterm(struct term *termp);
 extern "C" int del_curterm(struct term *termp);
 extern "C" int tigetnum(char *capname);
 #endif
 
+namespace {
+
 #ifdef HAVE_TERMINFO
-static ManagedStatic<sys::Mutex> TermColorMutex;
+ManagedStatic<sys::Mutex> TermColorMutex;
 #endif
 
-static bool terminalHasColors(int fd) {
+bool terminalHasColors(int fd) {
 #ifdef HAVE_TERMINFO
   // First, acquire a global lock because these C routines are thread hostile.
   MutexGuard G(*TermColorMutex);
 
   int errret = 0;
   if (setupterm((char *)nullptr, fd, &errret) != 0)
     // Regardless of why, if we can't get terminfo, we shouldn't try to print
     // colors.
#ifdef HAVE_TERMINFO
   if (HasColors)
     return true;
 #endif
 
   // Otherwise, be conservative.
   return false;
 }
 
+} // end anonymous namespace
+
 bool Process::FileDescriptorHasColors(int fd) {
   // A file descriptor has colors if it is displayed and the terminal has
   // colors.
   return FileDescriptorIsDisplayed(fd) && terminalHasColors(fd);
 }
 
 bool Process::StandardOutHasColors() {
   return FileDescriptorHasColors(STDOUT_FILENO);
const char *Process::OutputReverse() {
   return "\033[7m";
 }
 
 const char *Process::ResetColor() {
   return "\033[0m";
 }
 
 #if !defined(HAVE_DECL_ARC4RANDOM) || !HAVE_DECL_ARC4RANDOM
-static unsigned GetRandomNumberSeed() {
+
+namespace {
+
+unsigned GetRandomNumberSeed() {
   // Attempt to get the initial seed from /dev/urandom, if possible.
   int urandomFD = open("/dev/urandom", O_RDONLY);
 
   if (urandomFD != -1) {
     unsigned seed;
     // Don't use a buffered read to avoid reading more data
     // from /dev/urandom than we need.
     int count = read(urandomFD, (void *)&seed, sizeof(seed));
 
     close(urandomFD);
 
     // Return the seed if the read was successful.
     if (count == sizeof(seed))
       return seed;
   }
 
   // Otherwise, swizzle the current time and the process ID to form a reasonable
   // seed.
   TimeValue Now = TimeValue::now();
   return hash_combine(Now.seconds(), Now.nanoseconds(), ::getpid());
 }
+
+} // end anonymous namespace
+
 #endif
 
 unsigned llvm::sys::Process::GetRandomNumber() {
 #if defined(HAVE_DECL_ARC4RANDOM) && HAVE_DECL_ARC4RANDOM
   return arc4random();
 #else
   static int x = (static_cast<void>(::srand(GetRandomNumberSeed())), 0);
   (void)x;
   return ::rand();
 #endif
 }

llvm/trunk/lib/Support/Unix/Program.inc

-//===- llvm/Support/Unix/Program.cpp -----------------------------*- C++ -*-===//
+//===- llvm/Support/Unix/Program.cpp ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #if HAVE_SYS_RESOURCE_H
 #include <sys/resource.h>
 #endif
-#if HAVE_SIGNAL_H
-#include <signal.h>
-#endif
+#include <csignal>
 #if HAVE_FCNTL_H
 #include <fcntl.h>
 #endif
 #if HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 #ifdef HAVE_POSIX_SPAWN
 #ifdef __sun__
for (auto Path : Paths) {
     SmallString<128> FilePath(Path);
     sys::path::append(FilePath, Name);
     if (sys::fs::can_execute(FilePath.c_str()))
       return std::string(FilePath.str()); // Found the executable!
   }
   return errc::no_such_file_or_directory;
 }
 
-static bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) {
+namespace {
+
+bool RedirectIO(const StringRef *Path, int FD, std::string* ErrMsg) {
   if (!Path) // Noop
     return false;
   std::string File;
   if (Path->empty())
     // Redirect empty paths to /dev/null
     File = "/dev/null";
   else
     File = *Path;
if (dup2(InFD, FD) == -1) {
     close(InFD);
     return true;
   }
   close(InFD);      // Close the original FD
   return false;
 }
 
 #ifdef HAVE_POSIX_SPAWN
-static bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg,
-                          posix_spawn_file_actions_t *FileActions) {
+bool RedirectIO_PS(const std::string *Path, int FD, std::string *ErrMsg,
   if (!Path) // Noop
     return false;
   const char *File;
   if (Path->empty())
     // Redirect empty paths to /dev/null
     File = "/dev/null";
   else
     File = Path->c_str();
 
   if (int Err = posix_spawn_file_actions_addopen(
           FileActions, FD, File,
           FD == 0 ? O_RDONLY : O_WRONLY | O_CREAT, 0666))
     return MakeErrMsg(ErrMsg, "Cannot dup2", Err);
   return false;
 }
 #endif
 
-static void TimeOutHandler(int Sig) {
+void TimeOutHandler(int Sig) {
 }
 
-static void SetMemoryLimits (unsigned size)
+void SetMemoryLimits (unsigned size)
 {
 #if HAVE_SYS_RESOURCE_H && HAVE_GETRLIMIT && HAVE_SETRLIMIT
   struct rlimit r;
   __typeof__ (r.rlim_cur) limit = (__typeof__ (r.rlim_cur)) (size) * 1048576;
 
   // Heap size
   getrlimit (RLIMIT_DATA, &r);
   r.rlim_cur = limit;
#if !LLVM_MEMORY_SANITIZER_BUILD && !LLVM_ADDRESS_SANITIZER_BUILD
   getrlimit (RLIMIT_AS, &r);
   r.rlim_cur = limit;
   setrlimit (RLIMIT_AS, &r);
 #endif
 #endif
 #endif
 }
 
-}
+} // end anonymous namespace
+
+} // end namespace llvm
 
 static bool Execute(ProcessInfo &PI, StringRef Program, const char **args,
                     const char **envp, const StringRef **redirects,
                     unsigned memoryLimit, std::string *ErrMsg) {
   if (!llvm::sys::fs::exists(Program)) {
     if (ErrMsg)
       *ErrMsg = std::string("Executable \"") + Program.str() +
                 std::string("\" doesn't exist!");
#endif
     }
     // Return a special value to indicate that the process received an unhandled
     // signal during execution as opposed to failing to execute.
     WaitResult.ReturnCode = -2;
   }
   return WaitResult;
 }
 
-  std::error_code sys::ChangeStdinToBinary(){
+std::error_code sys::ChangeStdinToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
     return std::error_code();
 }
 
-  std::error_code sys::ChangeStdoutToBinary(){
+std::error_code sys::ChangeStdoutToBinary() {
   // Do nothing, as Unix doesn't differentiate between text and binary.
     return std::error_code();
 }
 
 std::error_code
 llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
                                  WindowsEncodingMethod Encoding /*unused*/) {
   std::error_code EC;
for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
        I != E; ++I) {
     ArgLength += strlen(*I) + 1;
     if (ArgLength > size_t(HalfArgMax)) {
       return false;
     }
   }
   return true;
 }
-}
+
+} // end namespace llvm

llvm/trunk/lib/Support/Unix/Signals.inc

-//===- Signals.cpp - Generic Unix Signals Implementation -----*- C++ -*-===//
+//===- Signals.cpp - Generic Unix Signals Implementation --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //

 #include "llvm/Support/Program.h"
 #include "llvm/Support/UniqueLock.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <string>
 #if HAVE_EXECINFO_H
 # include <execinfo.h>         // For backtrace().
 #endif
-#if HAVE_SIGNAL_H
-#include <signal.h>
-#endif
+#include <csignal>
 #if HAVE_SYS_STAT_H
 #include <sys/stat.h>
 #endif
 #if HAVE_CXXABI_H
 #include <cxxabi.h>
 #endif
 #if HAVE_DLFCN_H
 #include <dlfcn.h>
 #endif
 #if HAVE_MACH_MACH_H
 #include <mach/mach.h>
 #endif
 #if HAVE_LINK_H
 #include <link.h>
 #endif
 
 using namespace llvm;
 
-static RETSIGTYPE SignalHandler(int Sig);  // defined below.
+namespace {
+
+RETSIGTYPE SignalHandler(int Sig);  // defined below.
 
-static ManagedStatic<SmartMutex<true> > SignalsMutex;
+ManagedStatic<SmartMutex<true> > SignalsMutex;
 
 /// InterruptFunction - The function to call if ctrl-c is pressed.
-static void (*InterruptFunction)() = nullptr;
+void (*InterruptFunction)() = nullptr;
 
-static ManagedStatic<std::vector<std::string>> FilesToRemove;
+ManagedStatic<std::vector<std::string>> FilesToRemove;
 
 // IntSigs - Signals that represent requested termination. There's no bug
 // or failure, or if there is, it's not our direct responsibility. For whatever
 // reason, our continued execution is no longer desirable.
-static const int IntSigs[] = {
+const int IntSigs[] = {
   SIGHUP, SIGINT, SIGPIPE, SIGTERM, SIGUSR1, SIGUSR2
 };
 
 // KillSigs - Signals that represent that we have a bug, and our prompt
 // termination has been ordered.
-static const int KillSigs[] = {
+const int KillSigs[] = {
   SIGILL, SIGTRAP, SIGABRT, SIGFPE, SIGBUS, SIGSEGV, SIGQUIT
 #ifdef SIGSYS
   , SIGSYS
 #endif
 #ifdef SIGXCPU
   , SIGXCPU
 #endif
 #ifdef SIGXFSZ
   , SIGXFSZ
 #endif
 #ifdef SIGEMT
   , SIGEMT
 #endif
 };
 
-static unsigned NumRegisteredSignals = 0;
-static struct {
+unsigned NumRegisteredSignals = 0;
+struct {
   struct sigaction SA;
   int SigNo;
 } RegisteredSignalInfo[array_lengthof(IntSigs) + array_lengthof(KillSigs)];
 
-
-static void RegisterHandler(int Signal) {
+void RegisterHandler(int Signal) {
   assert(NumRegisteredSignals < array_lengthof(RegisteredSignalInfo) &&
          "Out of space for signal handlers!");
 
   struct sigaction NewHandler;
 
   NewHandler.sa_handler = SignalHandler;
   NewHandler.sa_flags = SA_NODEFER|SA_RESETHAND;
   sigemptyset(&NewHandler.sa_mask);
 
   // Install the new handler, save the old one in RegisteredSignalInfo.
   sigaction(Signal, &NewHandler,
             &RegisteredSignalInfo[NumRegisteredSignals].SA);
   RegisteredSignalInfo[NumRegisteredSignals].SigNo = Signal;
   ++NumRegisteredSignals;
 }
 
-static void RegisterHandlers() {
+void RegisterHandlers() {
   // We need to dereference the signals mutex during handler registration so
   // that we force its construction. This is to prevent the first use being
   // during handling an actual signal because you can't safely call new in a
   // signal handler.
   *SignalsMutex;
 
   // If the handlers are already registered, we're done.
   if (NumRegisteredSignals != 0) return;
 
   for (auto S : IntSigs) RegisterHandler(S);
   for (auto S : KillSigs) RegisterHandler(S);
 }
 
-static void UnregisterHandlers() {
+void UnregisterHandlers() {
   // Restore all of the signal handlers to how they were before we showed up.
   for (unsigned i = 0, e = NumRegisteredSignals; i != e; ++i)
     sigaction(RegisteredSignalInfo[i].SigNo,
               &RegisteredSignalInfo[i].SA, nullptr);
   NumRegisteredSignals = 0;
 }
 
-
 /// RemoveFilesToRemove - Process the FilesToRemove list. This function
 /// should be called with the SignalsMutex lock held.
 /// NB: This must be an async signal safe function. It cannot allocate or free
 /// memory, even in debug builds.
-static void RemoveFilesToRemove() {
+void RemoveFilesToRemove() {
   // Avoid constructing ManagedStatic in the signal handler.
   // If FilesToRemove is not constructed, there are no files to remove.
   if (!FilesToRemove.isConstructed())
     return;
 
   // We avoid iterators in case of debug iterators that allocate or release
   // memory.
   std::vector<std::string>& FilesToRemoveRef = *FilesToRemove;
for (unsigned i = 0, e = FilesToRemoveRef.size(); i != e; ++i) {
 
     // Otherwise, remove the file. We ignore any errors here as there is nothing
     // else we can do.
     unlink(path);
   }
 }
 
 // SignalHandler - The signal handler that runs.
-static RETSIGTYPE SignalHandler(int Sig) {
+RETSIGTYPE SignalHandler(int Sig) {
   // Restore the signal behavior to default, so that the program actually
   // crashes when we return and the signal reissues.  This also ensures that if
   // we crash in our signal handler that the program will terminate immediately
   // instead of recursing in the signal handler.
   UnregisterHandlers();
 
   // Unmask all potentially blocked kill signals.
   sigset_t SigMask;
#ifdef __s390__
   // *after* the faulting instruction.  Simply returning from the signal
   // handler would continue execution after that point, instead of
   // re-raising the signal.  Raise the signal manually in those cases.
   if (Sig == SIGILL || Sig == SIGFPE || Sig == SIGTRAP)
     raise(Sig);
 #endif
 }
 
+} // end anonymous namespace
+
 void llvm::sys::RunInterruptHandlers() {
   sys::SmartScopedLock<true> Guard(*SignalsMutex);
   RemoveFilesToRemove();
 }
 
 void llvm::sys::SetInterruptFunction(void (*IF)()) {
   {
     sys::SmartScopedLock<true> Guard(*SignalsMutex);
struct DlIteratePhdrData {
   void **StackTrace;
   int depth;
   bool first;
   const char **modules;
   intptr_t *offsets;
   const char *main_exec_name;
 };
 
-static int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
+namespace {
+
+int dl_iterate_phdr_cb(dl_phdr_info *info, size_t size, void *arg) {
   DlIteratePhdrData *data = (DlIteratePhdrData*)arg;
   const char *name = data->first ? data->main_exec_name : info->dlpi_name;
   data->first = false;
   for (int i = 0; i < info->dlpi_phnum; i++) {
     const auto *phdr = &info->dlpi_phdr[i];
     if (phdr->p_type != PT_LOAD)
       continue;
     intptr_t beg = info->dlpi_addr + phdr->p_vaddr;
     intptr_t end = beg + phdr->p_memsz;
     for (int j = 0; j < data->depth; j++) {
       if (data->modules[j])
         continue;
       intptr_t addr = (intptr_t)data->StackTrace[j];
       if (beg <= addr && addr < end) {
         data->modules[j] = name;
         data->offsets[j] = addr - info->dlpi_addr;
       }
     }
   }
   return 0;
 }
 
+} // end anonymous namespace
+
 /// If this is an ELF platform, we can find all loaded modules and their virtual
 /// addresses with dl_iterate_phdr.
 static bool findModulesAndOffsets(void **StackTrace, int Depth,
                                   const char **Modules, intptr_t *Offsets,
                                   const char *MainExecutableName,
                                   StringSaver &StrPool) {
   DlIteratePhdrData data = {StackTrace, Depth,   true,
                             Modules,    Offsets, MainExecutableName};
#  endif
     OS << '\n';
   }
 #else
   backtrace_symbols_fd(StackTrace, depth, STDERR_FILENO);
 #endif
 #endif
 }
 
-static void PrintStackTraceSignalHandler(void *) {
+namespace {
+
+void PrintStackTraceSignalHandler(void *) {
   PrintStackTrace(llvm::errs());
 }
 
+} // end anonymous namespace
+
 void llvm::sys::DisableSystemDialogsOnCrash() {}
 
 /// PrintStackTraceOnErrorSignal - When an error signal (such as SIGABRT or
 /// SIGSEGV) is delivered to the process, print a stack trace and then exit.
 void llvm::sys::PrintStackTraceOnErrorSignal(bool DisableCrashReporting) {
   AddSignalHandler(PrintStackTraceSignalHandler, nullptr);
 
 #if defined(__APPLE__) && defined(ENABLE_CRASH_OVERRIDES)
   // Environment variable to disable any kind of crash dialog.
   if (DisableCrashReporting || getenv("LLVM_DISABLE_CRASH_REPORT")) {
     mach_port_t self = mach_task_self();
 
     exception_mask_t mask = EXC_MASK_CRASH;
 
     kern_return_t ret = task_set_exception_ports(self,
                              mask,
                              MACH_PORT_NULL,
                              EXCEPTION_STATE_IDENTITY | MACH_EXCEPTION_CODES,
                              THREAD_STATE_NONE);
     (void)ret;
   }
 #endif
 }
 
-
-/***/
-
 // On Darwin, raise sends a signal to the main thread instead of the current
 // thread. This has the unfortunate effect that assert() and abort() will end up
 // bypassing our crash recovery attempts. We work around this for anything in
 // the same linkage unit by just defining our own versions of the assert handler
 // and abort.
 
 #if defined(__APPLE__) && defined(ENABLE_CRASH_OVERRIDES)
 

llvm/trunk/lib/Support/Unix/ThreadLocal.inc

 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on *all* UNIX variants.
 //===----------------------------------------------------------------------===//
 
 #if defined(HAVE_PTHREAD_H) && defined(HAVE_PTHREAD_GETSPECIFIC)
 
 #include <cassert>
+#include <cstdlib>
 #include <pthread.h>
-#include <stdlib.h>
 
 namespace llvm {
+
 using namespace sys;
 
 ThreadLocalImpl::ThreadLocalImpl() : data() {
   static_assert(sizeof(pthread_key_t) <= sizeof(data), "size too big");
   pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
   int errorcode = pthread_key_create(key, nullptr);
   assert(errorcode == 0);
   (void) errorcode;
void *ThreadLocalImpl::getInstance() {
   pthread_key_t* key = reinterpret_cast<pthread_key_t*>(&data);
   return pthread_getspecific(*key);
 }
 
 void ThreadLocalImpl::removeInstance() {
   setInstance(nullptr);
 }
 
-}
+} // end namespace llvm
 #else
+
 namespace llvm {
+
 using namespace sys;
+
 ThreadLocalImpl::ThreadLocalImpl() : data() { }
 ThreadLocalImpl::~ThreadLocalImpl() { }
 void ThreadLocalImpl::setInstance(const void* d) { data = const_cast<void*>(d);}
 void *ThreadLocalImpl::getInstance() { return data; }
 void ThreadLocalImpl::removeInstance() { setInstance(0); }
-}
+
+} // end namespace llvm
+
 #endif

llvm/trunk/lib/Support/Unix/Unix.h

-//===- llvm/Support/Unix/Unix.h - Common Unix Include File -------*- C++ -*-===//
+//===- llvm/Support/Unix/Unix.h - Common Unix Include File ------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines things specific to Unix implementations.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIB_SUPPORT_UNIX_UNIX_H
 #define LLVM_LIB_SUPPORT_UNIX_UNIX_H
 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only generic UNIX code that
 //===          is guaranteed to work on all UNIX variants.
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Config/config.h"     // Get autoconf configuration settings
 #include "llvm/Support/Errno.h"
 #include <algorithm>
-#include <assert.h>
+#include <cassert>
 #include <cerrno>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <sys/types.h>
 #include <sys/wait.h>
 
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif
 
 #ifdef HAVE_SYS_PARAM_H
 #include <sys/param.h>
 #endif
 
 #ifdef HAVE_SYS_TIME_H
 # include <sys/time.h>
 #endif
-#include <time.h>
+#include <ctime>
 
 #ifdef HAVE_DLFCN_H
 # include <dlfcn.h>
 #endif
 
 /// This function builds an error message into \p ErrMsg using the \p prefix
 /// string and the Unix error number given by \p errnum. If errnum is -1, the
 /// default then the value of errno is used.
 /// @brief Make an error message
 ///
 /// If the error number can be converted to a string, it will be
 /// separated from prefix by ": ".
 static inline bool MakeErrMsg(
   std::string* ErrMsg, const std::string& prefix, int errnum = -1) {
   if (!ErrMsg)
     return true;
   if (errnum == -1)
     errnum = errno;
   *ErrMsg = prefix + ": " + llvm::sys::StrError(errnum);
   return true;
 }
 
-#endif
+#endif // LLVM_LIB_SUPPORT_UNIX_UNIX_H

llvm/trunk/lib/Target/X86/X86ISelDAGToDAG.cpp

 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
-#include <stdint.h>
+#include <cstdint>
+
 using namespace llvm;
 
 #define DEBUG_TYPE "x86-isel"
 
 STATISTIC(NumLoadMoved, "Number of loads moved below TokenFactor");
 
 //===----------------------------------------------------------------------===//
 //                      Pattern Matcher Implementation
void dump() {
       if (MCSym)
         dbgs() << MCSym;
       else
         dbgs() << "nul";
       dbgs() << " JT" << JT << " Align" << Align << '\n';
     }
 #endif
   };
-}
+} // end anonymous namespace
 
 namespace {
   //===--------------------------------------------------------------------===//
   /// ISel - X86-specific code to select X86 machine instructions for
   /// SelectionDAG operations.
   ///
   class X86DAGToDAGISel final : public SelectionDAGISel {
     /// Keep a pointer to the X86Subtarget around so that we can
bool shouldAvoidImmediateInstFormsForSize(SDNode *N) const {
       // TODO: We'd like to remove this restriction.
       // See the comment in X86InstrInfo.td for more info.
       if (!OptForSize)
         return false;
 
       // Walk all the users of the immediate.
       for (SDNode::use_iterator UI = N->use_begin(),
            UE = N->use_end(); (UI != UE) && (UseCount < 2); ++UI) {
-
         SDNode *User = *UI;
 
         // This user is already selected. Count it as a legitimate use and
         // move on.
         if (User->isMachineOpcode()) {
           UseCount++;
           continue;
         }
private:
 
     /// \brief Address-mode matching performs shift-of-and to and-of-shift
     /// reassociation in order to expose more scaled addressing
     /// opportunities.
     bool ComplexPatternFuncMutatesDAG() const override {
       return true;
     }
   };
-}
-
+} // end anonymous namespace
 
 bool
 X86DAGToDAGISel::IsProfitableToFold(SDValue N, SDNode *U, SDNode *Root) const {
   if (OptLevel == CodeGenOpt::None) return false;
 
   if (!N.hasOneUse())
     return false;
 
case ISD::XOR: {
       }
     }
     }
   }
 
   return true;
 }
 
+namespace {
+
 /// Replace the original chain operand of the call with
 /// load's chain operand and move load below the call's chain operand.
-static void moveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load,
-                               SDValue Call, SDValue OrigChain) {
+void moveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load, SDValue Call,
+                        SDValue OrigChain) {
   SmallVector<SDValue, 8> Ops;
   SDValue Chain = OrigChain.getOperand(0);
   if (Chain.getNode() == Load.getNode())
     Ops.push_back(Load.getOperand(0));
   else {
     assert(Chain.getOpcode() == ISD::TokenFactor &&
            "Unexpected chain operand");
     for (unsigned i = 0, e = Chain.getNumOperands(); i != e; ++i)
void moveBelowOrigChain(SelectionDAG *CurDAG, SDValue Load, SDValue Call,
   CurDAG->UpdateNodeOperands(Call.getNode(), Ops);
 }
 
 /// Return true if call address is a load and it can be
 /// moved below CALLSEQ_START and the chains leading up to the call.
 /// Return the CALLSEQ_START by reference as a second output.
 /// In the case of a tail call, there isn't a callseq node between the call
 /// chain and the load.
-static bool isCalleeLoad(SDValue Callee, SDValue &Chain, bool HasCallSeq) {
+bool isCalleeLoad(SDValue Callee, SDValue &Chain, bool HasCallSeq) {
   // The transformation is somewhat dangerous if the call's chain was glued to
   // the call. After MoveBelowOrigChain the load is moved between the call and
   // the chain, this can create a cycle if the load is not folded. So it is
   // *really* important that we are sure the load will be folded.
   if (Callee.getNode() == Chain.getNode() || !Callee.hasOneUse())
     return false;
   LoadSDNode *LD = dyn_cast<LoadSDNode>(Callee.getNode());
   if (!LD ||
if (Chain.getOperand(0).getNode() == Callee.getNode())
     return true;
   if (Chain.getOperand(0).getOpcode() == ISD::TokenFactor &&
       Callee.getValue(1).isOperandOf(Chain.getOperand(0).getNode()) &&
       Callee.getValue(1).hasOneUse())
     return true;
   return false;
 }
 
+} // end anonymous namespace
+
 void X86DAGToDAGISel::PreprocessISelDAG() {
   // OptFor[Min]Size are used in pattern predicates that isel is matching.
   OptForSize = MF->getFunction()->optForSize();
   OptForMinSize = MF->getFunction()->optForMinSize();
   assert((!OptForMinSize || OptForSize) && "OptForMinSize implies OptForSize");
 
   for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
        E = CurDAG->allnodes_end(); I != E; ) {
for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
 
     // Now that we did that, the node is dead.  Increment the iterator to the
     // next node to process, then delete N.
     ++I;
     CurDAG->DeleteNode(N);
   }
 }
 
-
 /// Emit any code that needs to be executed only in the main function.
 void X86DAGToDAGISel::emitSpecialCodeForMain() {
   if (Subtarget->isTargetCygMing()) {
     TargetLowering::ArgListTy Args;
     auto &DL = CurDAG->getDataLayout();
 
     TargetLowering::CallLoweringInfo CLI(*CurDAG);
     CLI.setChain(CurDAG->getRoot())
         .setCallee(CallingConv::C, Type::getVoidTy(*CurDAG->getContext()),
                    CurDAG->getExternalSymbol("__main", TLI->getPointerTy(DL)),
                    std::move(Args), 0);
     const TargetLowering &TLI = CurDAG->getTargetLoweringInfo();
     std::pair<SDValue, SDValue> Result = TLI.LowerCallTo(CLI);
     CurDAG->setRoot(Result.second);
   }
 }
 
 void X86DAGToDAGISel::EmitFunctionEntryCode() {
   // If this is main, emit special code for main.
   if (const Function *Fn = MF->getFunction())
     if (Fn->hasExternalLinkage() && Fn->getName() == "main")
       emitSpecialCodeForMain();
 }
 
-static bool isDispSafeForFrameIndex(int64_t Val) {
+namespace {
+
+bool isDispSafeForFrameIndex(int64_t Val) {
   // On 64-bit platforms, we can run into an issue where a frame index
   // includes a displacement that, when added to the explicit displacement,
   // will overflow the displacement field. Assuming that the frame index
   // displacement fits into a 31-bit integer  (which is only slightly more
   // aggressive than the current fundamental assumption that it fits into
   // a 32-bit integer), a 31-bit disp should always be safe.
   return isInt<31>(Val);
 }
 
+} // end anonymous namespace
+
 bool X86DAGToDAGISel::foldOffsetIntoAddress(uint64_t Offset,
                                             X86ISelAddressMode &AM) {
   // Cannot combine ExternalSymbol displacements with integer offsets.
   if (Offset != 0 && (AM.ES || AM.MCSym))
     return true;
   int64_t Val = AM.Disp + Offset;
   CodeModel::Model M = TM.getCodeModel();
   if (Subtarget->is64Bit()) {
     if (!X86::isOffsetSuitableForCodeModel(Val, M,
                                            AM.hasSymbolicDisplacement()))
       return true;
     // In addition to the checks required for a register base, check that
     // we do not try to use an unsafe Disp with a frame index.
     if (AM.BaseType == X86ISelAddressMode::FrameIndexBase &&
         !isDispSafeForFrameIndex(Val))
       return true;
   }
   AM.Disp = Val;
   return false;
-
 }
 
 bool X86DAGToDAGISel::matchLoadInAddress(LoadSDNode *N, X86ISelAddressMode &AM){
   SDValue Address = N->getOperand(1);
 
   // load gs:0 -> GS segment register.
   // load fs:0 -> FS segment register.
   //
if (AM.BaseType == X86ISelAddressMode::RegBase &&
     AM.IndexReg = N.getOperand(1);
     AM.Scale = 1;
     return false;
   }
   N = Handle.getValue();
   return true;
 }
 
+namespace {
+
 // Insert a node into the DAG at least before the Pos node's position. This
 // will reposition the node as needed, and will assign it a node ID that is <=
 // the Pos node's ID. Note that this does *not* preserve the uniqueness of node
 // IDs! The selection DAG must no longer depend on their uniqueness when this
 // is used.
-static void insertDAGNode(SelectionDAG &DAG, SDValue Pos, SDValue N) {
+void insertDAGNode(SelectionDAG &DAG, SDValue Pos, SDValue N) {
   if (N.getNode()->getNodeId() == -1 ||
       N.getNode()->getNodeId() > Pos.getNode()->getNodeId()) {
     DAG.RepositionNode(Pos.getNode()->getIterator(), N.getNode());
     N.getNode()->setNodeId(Pos.getNode()->getNodeId());
   }
 }
 
 // Transform "(X >> (8-C1)) & (0xff << C1)" to "((X >> 8) & 0xff) << C1" if
 // safe. This allows us to convert the shift and and into an h-register
 // extract and a scaled index. Returns false if the simplification is
 // performed.
-static bool foldMaskAndShiftToExtract(SelectionDAG &DAG, SDValue N,
-                                      uint64_t Mask,
-                                      SDValue Shift, SDValue X,
-                                      X86ISelAddressMode &AM) {
+bool foldMaskAndShiftToExtract(SelectionDAG &DAG, SDValue N, uint64_t Mask,
   if (Shift.getOpcode() != ISD::SRL ||
       !isa<ConstantSDNode>(Shift.getOperand(1)) ||
       !Shift.hasOneUse())
     return true;
 
   int ScaleLog = 8 - Shift.getConstantOperandVal(1);
   if (ScaleLog <= 0 || ScaleLog >= 4 ||
       Mask != (0xffu << ScaleLog))
bool foldMaskAndShiftToExtract(SelectionDAG &DAG, SDValue N, uint64_t Mask,
   AM.IndexReg = And;
   AM.Scale = (1 << ScaleLog);
   return false;
 }
 
 // Transforms "(X << C1) & C2" to "(X & (C2>>C1)) << C1" if safe and if this
 // allows us to fold the shift into this addressing mode. Returns false if the
 // transform succeeded.
-static bool foldMaskedShiftToScaledMask(SelectionDAG &DAG, SDValue N,
-                                        uint64_t Mask,
-                                        SDValue Shift, SDValue X,
-                                        X86ISelAddressMode &AM) {
+bool foldMaskedShiftToScaledMask(SelectionDAG &DAG, SDValue N, uint64_t Mask,
   if (Shift.getOpcode() != ISD::SHL ||
       !isa<ConstantSDNode>(Shift.getOperand(1)))
     return true;
 
   // Not likely to be profitable if either the AND or SHIFT node has more
   // than one use (unless all uses are for address computation). Besides,
   // isel mechanism requires their node ids to be reused.
   if (!N.hasOneUse() || !Shift.hasOneUse())

 //   movl %eax, %ecx
 //   shrl $9, %ecx
 //   andl $124, %rcx
 //   addl (%rsi,%rcx), %eax
 //
 // Note that this function assumes the mask is provided as a mask *after* the
 // value is shifted. The input chain may or may not match that, but computing
 // such a mask is trivial.
-static bool foldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N,
-                                    uint64_t Mask,
-                                    SDValue Shift, SDValue X,
-                                    X86ISelAddressMode &AM) {
+bool foldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N, uint64_t Mask,
+                             SDValue Shift, SDValue X, X86ISelAddressMode &AM) {
   if (Shift.getOpcode() != ISD::SRL || !Shift.hasOneUse() ||
       !isa<ConstantSDNode>(Shift.getOperand(1)))
     return true;
 
   unsigned ShiftAmt = Shift.getConstantOperandVal(1);
   unsigned MaskLZ = countLeadingZeros(Mask);
   unsigned MaskTZ = countTrailingZeros(Mask);
 
bool foldMaskAndShiftToScale(SelectionDAG &DAG, SDValue N, uint64_t Mask,
   insertDAGNode(DAG, N, NewSHL);
   DAG.ReplaceAllUsesWith(N, NewSHL);
 
   AM.Scale = 1 << AMShiftAmt;
   AM.IndexReg = NewSRL;
   return false;
 }
 
+} // end anonymous namespace
+
 bool X86DAGToDAGISel::matchAddressRecursively(SDValue N, X86ISelAddressMode &AM,
                                               unsigned Depth) {
   SDLoc dl(N);
   DEBUG({
       dbgs() << "MatchAddress: ";
       AM.dump();
     });
   // Limit recursion.
bool X86DAGToDAGISel::matchAddressBase(SDValue N, X86ISelAddressMode &AM) {
   AM.BaseType = X86ISelAddressMode::RegBase;
   AM.Base_Reg = N;
   return false;
 }
 
 bool X86DAGToDAGISel::selectVectorAddr(SDNode *Parent, SDValue N, SDValue &Base,
                                       SDValue &Scale, SDValue &Index,
                                       SDValue &Disp, SDValue &Segment) {
-
   MaskedGatherScatterSDNode *Mgs = dyn_cast<MaskedGatherScatterSDNode>(Parent);
   if (!Mgs)
     return false;
   X86ISelAddressMode AM;
   unsigned AddrSpace = Mgs->getPointerInfo().getAddrSpace();
   // AddrSpace 256 -> GS, 257 -> FS.
   if (AddrSpace == 256)
     AM.Segment = CurDAG->getRegister(X86::GS, MVT::i16);
if (N.getOpcode() == X86ISD::VZEXT_MOVL && N.getNode()->hasOneUse() &&
     if (!selectAddr(LD, LD->getBasePtr(), Base, Scale, Index, Disp, Segment))
       return false;
     PatternNodeWithChain = SDValue(LD, 0);
     return true;
   }
   return false;
 }
 
-
 bool X86DAGToDAGISel::selectMOV64Imm32(SDValue N, SDValue &Imm) {
   if (const ConstantSDNode *CN = dyn_cast<ConstantSDNode>(N)) {
     uint64_t ImmVal = CN->getZExtValue();
     if ((uint32_t)ImmVal != (uint64_t)ImmVal)
       return false;
 
     Imm = CurDAG->getTargetConstant(ImmVal, SDLoc(N), MVT::i64);
     return true;
bool X86DAGToDAGISel::selectTLSADDRAddr(SDValue N, SDValue &Base,
   } else {
     AM.IndexReg = CurDAG->getRegister(0, MVT::i64);
   }
 
   getAddressOperands(AM, SDLoc(N), Base, Scale, Index, Disp, Segment);
   return true;
 }
 
-
 bool X86DAGToDAGISel::tryFoldLoad(SDNode *P, SDValue N,
                                   SDValue &Base, SDValue &Scale,
                                   SDValue &Index, SDValue &Disp,
                                   SDValue &Segment) {
   if (!ISD::isNON_EXTLoad(N.getNode()) ||
       !IsProfitableToFold(N, P, P) ||
       !IsLegalToFold(N, P, P, OptLevel))
     return false;
 
   return selectAddr(N.getNode(),
                     N.getOperand(1), Base, Scale, Index, Disp, Segment);
 }
 
 /// Return an SDNode that returns the value of the global base register.
 /// Output instructions required to initialize the global base register,
 /// if necessary.
 SDNode *X86DAGToDAGISel::getGlobalBaseReg() {
   unsigned GlobalBaseReg = getInstrInfo()->getGlobalBaseReg(MF);
   auto &DL = MF->getDataLayout();
   return CurDAG->getRegister(GlobalBaseReg, TLI->getPointerTy(DL)).getNode();
 }
 
+namespace {
+
 /// Test whether the given X86ISD::CMP node has any uses which require the SF
 /// or OF bits to be accurate.
-static bool hasNoSignedComparisonUses(SDNode *N) {
+bool hasNoSignedComparisonUses(SDNode *N) {
   // Examine each user of the node.
   for (SDNode::use_iterator UI = N->use_begin(),
          UE = N->use_end(); UI != UE; ++UI) {
     // Only examine CopyToReg uses.
     if (UI->getOpcode() != ISD::CopyToReg)
       return false;
     // Only examine CopyToReg uses that copy to EFLAGS.
     if (cast<RegisterSDNode>(UI->getOperand(1))->getReg() !=
for (SDNode::use_iterator FlagUI = UI->use_begin(),
       }
     }
   }
   return true;
 }
 
 /// Check whether or not the chain ending in StoreNode is suitable for doing
 /// the {load; increment or decrement; store} to modify transformation.
-static bool isLoadIncOrDecStore(StoreSDNode *StoreNode, unsigned Opc,
-                                SDValue StoredVal, SelectionDAG *CurDAG,
-                                LoadSDNode* &LoadNode, SDValue &InputChain) {
-
+bool isLoadIncOrDecStore(StoreSDNode *StoreNode, unsigned Opc,
   // is the value stored the result of a DEC or INC?
   if (!(Opc == X86ISD::DEC || Opc == X86ISD::INC)) return false;
 
   // is the stored value result 0 of the load?
   if (StoredVal.getResNo() != 0) return false;
 
   // are there other uses of the loaded value than the inc or dec?
   if (!StoredVal.getNode()->hasNUsesOfValue(1, 0)) return false;
bool isLoadIncOrDecStore(StoreSDNode *StoreNode, unsigned Opc,
   if (!ChainCheck)
     return false;
 
   return true;
 }
 
 /// Get the appropriate X86 opcode for an in-memory increment or decrement.
 /// Opc should be X86ISD::DEC or X86ISD::INC.
-static unsigned getFusedLdStOpcode(EVT &LdVT, unsigned Opc) {
+unsigned getFusedLdStOpcode(EVT &LdVT, unsigned Opc) {
   if (Opc == X86ISD::DEC) {
     if (LdVT == MVT::i64) return X86::DEC64m;
     if (LdVT == MVT::i32) return X86::DEC32m;
     if (LdVT == MVT::i16) return X86::DEC16m;
     if (LdVT == MVT::i8)  return X86::DEC8m;
   } else {
     assert(Opc == X86ISD::INC && "unrecognized opcode");
     if (LdVT == MVT::i64) return X86::INC64m;
     if (LdVT == MVT::i32) return X86::INC32m;
     if (LdVT == MVT::i16) return X86::INC16m;
     if (LdVT == MVT::i8)  return X86::INC8m;
   }
   llvm_unreachable("unrecognized size for LdVT");
 }
 
+} // end anonymous namespace
+
 /// Customized ISel for GATHER operations.
 SDNode *X86DAGToDAGISel::selectGather(SDNode *Node, unsigned Opc) {
   // Operands of Gather: VSrc, Base, VIdx, VMask, Scale
   SDValue Chain = Node->getOperand(0);
   SDValue VSrc = Node->getOperand(2);
   SDValue Base = Node->getOperand(3);
   SDValue VIdx = Node->getOperand(4);
   SDValue VMask = Node->getOperand(5);

llvm/trunk/tools/llvm-c-test/echo.cpp

 //
 // This command uses the C API to read a module and output an exact copy of it
 // as output. It is used to check that the resulting module matches the input
 // to validate that the C API can read and write modules properly.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-c-test.h"
+#include "llvm-c/Core.h"
+#include "llvm-c/ErrorHandling.h"
 #include "llvm-c/Target.h"
+#include "llvm-c/Types.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ErrorHandling.h"
 
-#include <stdio.h>
-#include <stdlib.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 
 using namespace llvm;
 
 // Provide DenseMapInfo for C API opaque types.
 template<typename T>
 struct CAPIDenseMap {};
 
 // The default DenseMapInfo require to know about pointer alignement.
 // Because the C API uses opaques pointer types, their alignement is unknown.
 // As a result, we need to roll out our own implementation.
 template<typename T>
 struct CAPIDenseMap<T*> {
   struct CAPIDenseMapInfo {
     static inline T* getEmptyKey() {
       uintptr_t Val = static_cast<uintptr_t>(-1);
       return reinterpret_cast<T*>(Val);
     }
+
     static inline T* getTombstoneKey() {
       uintptr_t Val = static_cast<uintptr_t>(-2);
       return reinterpret_cast<T*>(Val);
     }
+
     static unsigned getHashValue(const T *PtrVal) {
       return hash_value(PtrVal);
     }
+
     static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   };
 
   typedef DenseMap<T*, T*, CAPIDenseMapInfo> Map;
 };
 
 typedef CAPIDenseMap<LLVMValueRef>::Map ValueMap;
 typedef CAPIDenseMap<LLVMBasicBlockRef>::Map BasicBlockMap;
switch (Kind) {
         break;
     }
 
     fprintf(stderr, "%d is not a supported typekind\n", Kind);
     exit(-1);
   }
 };
 
-static ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
+namespace {
+
+ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
   unsigned Count = LLVMCountParams(Src);
   if (Count != LLVMCountParams(Dst))
     report_fatal_error("Parameter count mismatch");
 
   ValueMap VMap;
   if (Count == 0)
     return VMap;
 
ValueMap clone_params(LLVMValueRef Src, LLVMValueRef Dst) {
   }
 
   if (Count != 0)
     report_fatal_error("Parameter count does not match iteration");
 
   return VMap;
 }
 
+} // end anonymous namespace
+
 LLVMValueRef clone_constant(LLVMValueRef Cst, LLVMModuleRef M) {
   if (!LLVMIsAConstant(Cst))
     report_fatal_error("Expected a constant");
 
   // Maybe it is a symbol
   if (LLVMIsAGlobalValue(Cst)) {
     const char *Name = LLVMGetValueName(Cst);
 
while(true) {
       Cur = Next;
     }
 
     if (Count != 0)
       report_fatal_error("Basic block count does not match iterration");
   }
 };
 
-static void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
+namespace {
+
+void declare_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
   LLVMValueRef End = LLVMGetLastGlobal(Src);
 
   LLVMValueRef Cur = Begin;
   LLVMValueRef Next = nullptr;
   if (!Begin) {
     if (End != nullptr)
       report_fatal_error("Range has an end but no begining");
while (true) {
     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
     if (Prev != Cur)
       report_fatal_error("Next.Previous function is not Current");
 
     Cur = Next;
   }
 }
 
-static void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
+void clone_symbols(LLVMModuleRef Src, LLVMModuleRef M) {
   LLVMValueRef Begin = LLVMGetFirstGlobal(Src);
   LLVMValueRef End = LLVMGetLastGlobal(Src);
 
   LLVMValueRef Cur = Begin;
   LLVMValueRef Next = nullptr;
   if (!Begin) {
     if (End != nullptr)
       report_fatal_error("Range has an end but no begining");
while (true) {
     LLVMValueRef Prev = LLVMGetPreviousFunction(Next);
     if (Prev != Cur)
       report_fatal_error("Next.Previous function is not Current");
 
     Cur = Next;
   }
 }
 
+} // end anonymous namespace
+
 int llvm_echo(void) {
   LLVMEnablePrettyStackTrace();
 
   LLVMModuleRef Src = llvm_load_module(false, true);
   size_t Len;
   const char *ModuleName = LLVMGetModuleIdentifier(Src, &Len);
   LLVMContextRef Ctx = LLVMContextCreate();
   LLVMModuleRef M = LLVMModuleCreateWithNameInContext(ModuleName, Ctx);

llvm/trunk/tools/llvm-c-test/llvm-c-test.h

 /*===-- llvm-c-test.h - tool for testing libLLVM and llvm-c API -----------===*\
 |*                                                                            *|
 |*                     The LLVM Compiler Infrastructure                       *|
 |*                                                                            *|
 |* This file is distributed under the University of Illinois Open Source      *|
 |* License. See LICENSE.TXT for details.                                      *|
 |*                                                                            *|
 |*===----------------------------------------------------------------------===*|
 |*                                                                            *|
 |* Header file for llvm-c-test                                                *|
 |*                                                                            *|
 \*===----------------------------------------------------------------------===*/
+
 #ifndef LLVM_C_TEST_H
 #define LLVM_C_TEST_H
 
+#ifdef __cplusplus
+#include <cstdbool>
+#else
 #include <stdbool.h>
+#endif
 #include "llvm-c/Core.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // helpers.c
 void llvm_tokenize_stdin(void (*cb)(char **tokens, int ntokens));

 // targets.c
 int llvm_targets_list(void);
 
 // echo.c
 int llvm_echo(void);
 
 #ifdef __cplusplus
 }
-#endif /* !defined(__cplusplus) */
-
 #endif
+
+#endif // LLVM_C_TEST_H

llvm/trunk/tools/llvm-readobj/COFFDumper.cpp

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/Win64EH.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
-#include <cstring>
+#include <cassert>
+#include <cstdint>
+#include <ctime>
+#include <memory>
+#include <string>
+#include <tuple>
 #include <system_error>
-#include <time.h>
+#include <vector>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::codeview;
 using namespace llvm::support;
 using namespace llvm::Win64EH;
 
 namespace {
public:
   void printDynamicSymbols() override;
   void printUnwindInfo() override;
   void printCOFFImports() override;
   void printCOFFExports() override;
   void printCOFFDirectives() override;
   void printCOFFBaseReloc() override;
   void printCodeViewDebugInfo() override;
   void printStackMap() const override;
+
 private:
   void printSymbol(const SymbolRef &Sym);
   void printRelocation(const SectionRef &Section, const RelocationRef &Reloc,
                        uint64_t Bias = 0);
   void printDataDirectory(uint32_t Index, const std::string &FieldName);
 
   void printDOSHeader(const dos_header *DH);
   template <class PEHeader> void printPEHeader(const PEHeader *Hdr);
private:
   /// All user defined type records in .debug$T live in here. Type indices
   /// greater than 0x1000 are user defined. Subtract 0x1000 from the index to
   /// index into this vector.
   SmallVector<StringRef, 10> CVUDTNames;
 
   StringSet<> TypeNames;
 };
 
-} // namespace
-
+} // end anonymous namespace
 
 namespace llvm {
 
 std::error_code createCOFFDumper(const object::ObjectFile *Obj,
                                  StreamWriter &Writer,
                                  std::unique_ptr<ObjDumper> &Result) {
   const COFFObjectFile *COFFObj = dyn_cast<COFFObjectFile>(Obj);
   if (!COFFObj)
     return readobj_error::unsupported_obj_file_format;
 
   Result.reset(new COFFDumper(COFFObj, Writer));
   return readobj_error::success;
 }
 
-} // namespace llvm
+} // end namespace llvm
 
 // Given a a section and an offset into this section the function returns the
 // symbol used for the relocation at the offset.
 std::error_code COFFDumper::resolveSymbol(const coff_section *Section,
                                           uint64_t Offset, SymbolRef &Sym) {
   cacheRelocations();
   const auto &Relocations = RelocMap[Section];
   for (const auto &Relocation : Relocations) {
void COFFDumper::printBinaryBlockWithRelocs(StringRef Label,
   const auto &Relocations = RelocMap[Section];
   for (const auto &Relocation : Relocations) {
     uint64_t RelocationOffset = Relocation.getOffset();
     if (OffsetStart <= RelocationOffset && RelocationOffset < OffsetEnd)
       printRelocation(Sec, Relocation, OffsetStart);
   }
 }
 
-static const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
+namespace {
+
+const EnumEntry<COFF::MachineTypes> ImageFileMachineType[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_UNKNOWN  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AM33     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_AMD64    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARM      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_ARMNT    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_EBC      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_I386     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_IA64     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_M32R     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPS16   ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_MIPSFPU16),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPC  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_POWERPCFP),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_R4000    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH3DSP   ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH4      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_SH5      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_THUMB    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_MACHINE_WCEMIPSV2)
 };
 
-static const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = {
+const EnumEntry<COFF::Characteristics> ImageFileCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_RELOCS_STRIPPED        ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_EXECUTABLE_IMAGE       ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LINE_NUMS_STRIPPED     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LOCAL_SYMS_STRIPPED    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_AGGRESSIVE_WS_TRIM     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_LARGE_ADDRESS_AWARE    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_LO      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_32BIT_MACHINE          ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DEBUG_STRIPPED         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_NET_RUN_FROM_SWAP      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_SYSTEM                 ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_DLL                    ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_UP_SYSTEM_ONLY         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_FILE_BYTES_REVERSED_HI      )
 };
 
-static const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
+const EnumEntry<COFF::WindowsSubsystem> PEWindowsSubsystem[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_UNKNOWN                ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_NATIVE                 ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_GUI            ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CUI            ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_POSIX_CUI              ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_WINDOWS_CE_GUI         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_APPLICATION        ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER     ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_EFI_ROM                ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SUBSYSTEM_XBOX                   ),
 };
 
-static const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
+const EnumEntry<COFF::DLLCharacteristics> PEDLLCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_HIGH_ENTROPY_VA      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_DYNAMIC_BASE         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_FORCE_INTEGRITY      ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NX_COMPAT            ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_ISOLATION         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_SEH               ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_NO_BIND              ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_APPCONTAINER         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_WDM_DRIVER           ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_GUARD_CF             ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_DLL_CHARACTERISTICS_TERMINAL_SERVER_AWARE),
 };
 
-static const EnumEntry<COFF::SectionCharacteristics>
+const EnumEntry<COFF::SectionCharacteristics>
 ImageSectionCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NOLOAD           ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_TYPE_NO_PAD           ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_CODE              ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_INITIALIZED_DATA  ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_CNT_UNINITIALIZED_DATA),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_OTHER             ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_LNK_INFO              ),
ImageSectionCharacteristics[] = {
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_CACHED        ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_NOT_PAGED         ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_SHARED            ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_EXECUTE           ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_READ              ),
   LLVM_READOBJ_ENUM_ENT(COFF, IMAGE_SCN_MEM_WRITE             )
 };
 
-static const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
+const EnumEntry<COFF::SymbolBaseType> ImageSymType[] = {
   { "Null"  , COFF::IMAGE_SYM_TYPE_NULL   },
   { "Void"  , COFF::IMAGE_SYM_TYPE_VOID   },
   { "Char"  , COFF::IMAGE_SYM_TYPE_CHAR   },
   { "Short" , COFF::IMAGE_SYM_TYPE_SHORT  },
   { "Int"   , COFF::IMAGE_SYM_TYPE_INT    },
   { "Long"  , COFF::IMAGE_SYM_TYPE_LONG   },
   { "Float" , COFF::IMAGE_SYM_TYPE_FLOAT  },
   { "Double", COFF::IMAGE_SYM_TYPE_DOUBLE },
   { "Struct", COFF::IMAGE_SYM_TYPE_STRUCT },
   { "Union" , COFF::IMAGE_SYM_TYPE_UNION  },
   { "Enum"  , COFF::IMAGE_SYM_TYPE_ENUM   },
   { "MOE"   , COFF::IMAGE_SYM_TYPE_MOE    },
   { "Byte"  , COFF::IMAGE_SYM_TYPE_BYTE   },
   { "Word"  , COFF::IMAGE_SYM_TYPE_WORD   },
   { "UInt"  , COFF::IMAGE_SYM_TYPE_UINT   },
   { "DWord" , COFF::IMAGE_SYM_TYPE_DWORD  }
 };
 
-static const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = {
+const EnumEntry<COFF::SymbolComplexType> ImageSymDType[] = {
   { "Null"    , COFF::IMAGE_SYM_DTYPE_NULL     },
   { "Pointer" , COFF::IMAGE_SYM_DTYPE_POINTER  },
   { "Function", COFF::IMAGE_SYM_DTYPE_FUNCTION },
   { "Array"   , COFF::IMAGE_SYM_DTYPE_ARRAY    }
 };
 
-static const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
+const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
   { "EndOfFunction"  , COFF::IMAGE_SYM_CLASS_END_OF_FUNCTION  },
   { "Null"           , COFF::IMAGE_SYM_CLASS_NULL             },
   { "Automatic"      , COFF::IMAGE_SYM_CLASS_AUTOMATIC        },
   { "External"       , COFF::IMAGE_SYM_CLASS_EXTERNAL         },
   { "Static"         , COFF::IMAGE_SYM_CLASS_STATIC           },
   { "Register"       , COFF::IMAGE_SYM_CLASS_REGISTER         },
   { "ExternalDef"    , COFF::IMAGE_SYM_CLASS_EXTERNAL_DEF     },
   { "Label"          , COFF::IMAGE_SYM_CLASS_LABEL            },
const EnumEntry<COFF::SymbolStorageClass> ImageSymClass[] = {
   { "Function"       , COFF::IMAGE_SYM_CLASS_FUNCTION         },
   { "EndOfStruct"    , COFF::IMAGE_SYM_CLASS_END_OF_STRUCT    },
   { "File"           , COFF::IMAGE_SYM_CLASS_FILE             },
   { "Section"        , COFF::IMAGE_SYM_CLASS_SECTION          },
   { "WeakExternal"   , COFF::IMAGE_SYM_CLASS_WEAK_EXTERNAL    },
   { "CLRToken"       , COFF::IMAGE_SYM_CLASS_CLR_TOKEN        }
 };
 
-static const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
+const EnumEntry<COFF::COMDATType> ImageCOMDATSelect[] = {
   { "NoDuplicates", COFF::IMAGE_COMDAT_SELECT_NODUPLICATES },
   { "Any"         , COFF::IMAGE_COMDAT_SELECT_ANY          },
   { "SameSize"    , COFF::IMAGE_COMDAT_SELECT_SAME_SIZE    },
   { "ExactMatch"  , COFF::IMAGE_COMDAT_SELECT_EXACT_MATCH  },
   { "Associative" , COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE  },
   { "Largest"     , COFF::IMAGE_COMDAT_SELECT_LARGEST      },
   { "Newest"      , COFF::IMAGE_COMDAT_SELECT_NEWEST       }
 };
 
-static const EnumEntry<COFF::WeakExternalCharacteristics>
+const EnumEntry<COFF::WeakExternalCharacteristics>
 WeakExternalCharacteristics[] = {
   { "NoLibrary", COFF::IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY },
   { "Library"  , COFF::IMAGE_WEAK_EXTERN_SEARCH_LIBRARY   },
   { "Alias"    , COFF::IMAGE_WEAK_EXTERN_SEARCH_ALIAS     }
 };
 
-static const EnumEntry<CompileSym3::Flags> CompileSym3Flags[] = {
+const EnumEntry<CompileSym3::Flags> CompileSym3Flags[] = {
     LLVM_READOBJ_ENUM_ENT(CompileSym3, EC),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, NoDbgInfo),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, LTCG),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, NoDataAlign),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, ManagedPresent),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, SecurityChecks),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, HotPatch),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, CVTCIL),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, MSILModule),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, Sdl),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, PGO),
     LLVM_READOBJ_ENUM_ENT(CompileSym3, Exp),
 };
 
-static const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
+const EnumEntry<codeview::SourceLanguage> SourceLanguages[] = {
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, C),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cpp),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Fortran),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Masm),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Pascal),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Basic),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cobol),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Link),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cvtres),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Cvtpgd),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, CSharp),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, VB),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, ILAsm),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, Java),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, JScript),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, MSIL),
     LLVM_READOBJ_ENUM_ENT(SourceLanguage, HLSL),
 };
 
-static const EnumEntry<uint32_t> SubSectionTypes[] = {
+const EnumEntry<uint32_t> SubSectionTypes[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Symbols),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, Lines),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, StringTable),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FileChecksums),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FrameData),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, InlineeLines),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeImports),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CrossScopeExports),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, ILLines),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, FuncMDTokenMap),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, TypeMDTokenMap),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, MergedAssemblyInput),
   LLVM_READOBJ_ENUM_CLASS_ENT(ModuleSubstreamKind, CoffSymbolRVA),
 };
 
-static const EnumEntry<unsigned> CPUTypeNames[] = {
+const EnumEntry<unsigned> CPUTypeNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel8080),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel8086),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80286),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80386),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Intel80486),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Pentium),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, PentiumPro),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Pentium3),
const EnumEntry<unsigned> CPUTypeNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, TriCore),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, X64),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, EBC),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, Thumb),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, ARMNT),
   LLVM_READOBJ_ENUM_CLASS_ENT(CPUType, D3D11_Shader),
 };
 
-static const EnumEntry<uint8_t> ProcSymFlags[] = {
+const EnumEntry<uint8_t> ProcSymFlags[] = {
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasFP),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasIRET),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasFRET),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, IsNoReturn),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, IsUnreachable),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasCustomCallingConv),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, IsNoInline),
     LLVM_READOBJ_ENUM_ENT(ProcFlags, HasOptimizedDebugInfo),
 };
 
-static const EnumEntry<uint32_t> FrameProcSymFlags[] = {
+const EnumEntry<uint32_t> FrameProcSymFlags[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasAlloca),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasSetJmp),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasLongJmp),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasInlineAssembly),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, HasExceptionHandling),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, MarkedInline),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions,
                                 HasStructuredExceptionHandling),
const EnumEntry<uint32_t> FrameProcSymFlags[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions,
                                 ProfileGuidedOptimization),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, ValidProfileCounts),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, OptimizedForSpeed),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfg),
     LLVM_READOBJ_ENUM_CLASS_ENT(FrameProcedureOptions, GuardCfw),
 };
 
-static const EnumEntry<uint32_t> FrameDataFlags[] = {
+const EnumEntry<uint32_t> FrameDataFlags[] = {
     LLVM_READOBJ_ENUM_ENT(FrameData, HasSEH),
     LLVM_READOBJ_ENUM_ENT(FrameData, HasEH),
     LLVM_READOBJ_ENUM_ENT(FrameData, IsFunctionStart),
 };
 
-static const EnumEntry<uint16_t> LocalFlags[] = {
+const EnumEntry<uint16_t> LocalFlags[] = {
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsParameter),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsAddressTaken),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsCompilerGenerated),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsAggregate),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsAggregated),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsAliased),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsAlias),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsReturnValue),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsOptimizedOut),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsEnregisteredGlobal),
     LLVM_READOBJ_ENUM_ENT(LocalSym, IsEnregisteredStatic),
 };
 
-static const EnumEntry<uint16_t> FrameCookieKinds[] = {
+const EnumEntry<uint16_t> FrameCookieKinds[] = {
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, Copy),
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorStackPointer),
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorFramePointer),
     LLVM_READOBJ_ENUM_ENT(FrameCookieSym, XorR13),
 };
 
-static const EnumEntry<uint16_t> ClassOptionNames[] = {
+const EnumEntry<uint16_t> ClassOptionNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Packed),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasConstructorOrDestructor),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasOverloadedOperator),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Nested),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, ContainsNestedClass),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasOverloadedAssignmentOperator),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasConversionOperator),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, ForwardReference),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Scoped),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, HasUniqueName),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Sealed),
   LLVM_READOBJ_ENUM_CLASS_ENT(ClassOptions, Intrinsic),
 };
 
-static const EnumEntry<uint8_t> MemberAccessNames[] = {
+const EnumEntry<uint8_t> MemberAccessNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, None),
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Private),
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Protected),
     LLVM_READOBJ_ENUM_CLASS_ENT(MemberAccess, Public),
 };
 
-static const EnumEntry<uint16_t> MethodOptionNames[] = {
+const EnumEntry<uint16_t> MethodOptionNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, Pseudo),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, NoInherit),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, NoConstruct),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, CompilerGenerated),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodOptions, Sealed),
 };
 
-static const EnumEntry<uint16_t> MemberKindNames[] = {
+const EnumEntry<uint16_t> MemberKindNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Vanilla),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Virtual),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Static),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, Friend),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, IntroducingVirtual),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, PureVirtual),
     LLVM_READOBJ_ENUM_CLASS_ENT(MethodKind, PureIntroducingVirtual),
 };
 
 /// The names here all end in "*". If the simple type is a pointer type, we
 /// return the whole name. Otherwise we lop off the last character in our
 /// StringRef.
-static const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = {
+const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = {
     {"void*", SimpleTypeKind::Void},
     {"<not translated>*", SimpleTypeKind::NotTranslated},
     {"HRESULT*", SimpleTypeKind::HResult},
     {"signed char*", SimpleTypeKind::SignedCharacter},
     {"unsigned char*", SimpleTypeKind::UnsignedCharacter},
     {"char*", SimpleTypeKind::NarrowCharacter},
     {"wchar_t*", SimpleTypeKind::WideCharacter},
     {"__int8*", SimpleTypeKind::SByte},
const EnumEntry<SimpleTypeKind> SimpleTypeNames[] = {
     {"_Complex long double*", SimpleTypeKind::Complex80},
     {"_Complex __float128*", SimpleTypeKind::Complex128},
     {"bool*", SimpleTypeKind::Boolean8},
     {"__bool16*", SimpleTypeKind::Boolean16},
     {"__bool32*", SimpleTypeKind::Boolean32},
     {"__bool64*", SimpleTypeKind::Boolean64},
 };
 
-static const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
+const EnumEntry<TypeLeafKind> LeafTypeNames[] = {
 #define LEAF_TYPE(name, val) LLVM_READOBJ_ENUM_ENT(TypeLeafKind, name),
 #include "llvm/DebugInfo/CodeView/CVLeafTypes.def"
 };
 
-static const EnumEntry<uint8_t> PtrKindNames[] = {
+const EnumEntry<uint8_t> PtrKindNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near16),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Far16),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Huge16),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSegment),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnValue),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSegmentValue),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnAddress),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSegmentAddress),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnType),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, BasedOnSelf),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near32),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Far32),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerKind, Near64),
 };
 
-static const EnumEntry<uint8_t> PtrModeNames[] = {
+const EnumEntry<uint8_t> PtrModeNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, Pointer),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, LValueReference),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, PointerToDataMember),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, PointerToMemberFunction),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerMode, RValueReference),
 };
 
-static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
+const EnumEntry<uint16_t> PtrMemberRepNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, Unknown),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 SingleInheritanceData),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 MultipleInheritanceData),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 VirtualInheritanceData),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralData),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 SingleInheritanceFunction),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 MultipleInheritanceFunction),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation,
                                 VirtualInheritanceFunction),
     LLVM_READOBJ_ENUM_CLASS_ENT(PointerToMemberRepresentation, GeneralFunction),
 };
 
-static const EnumEntry<uint16_t> TypeModifierNames[] = {
+const EnumEntry<uint16_t> TypeModifierNames[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Const),
     LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Volatile),
     LLVM_READOBJ_ENUM_CLASS_ENT(ModifierOptions, Unaligned),
 };
 
-static const EnumEntry<uint8_t> CallingConventions[] = {
+const EnumEntry<uint8_t> CallingConventions[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearC),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarC),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearPascal),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarPascal),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearFast),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarFast),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearStdCall),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, FarStdCall),
const EnumEntry<uint8_t> CallingConventions[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, TriCall),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, SH5Call),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, M32RCall),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, ClrCall),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, Inline),
     LLVM_READOBJ_ENUM_CLASS_ENT(CallingConvention, NearVector),
 };
 
-static const EnumEntry<uint8_t> FunctionOptionEnum[] = {
+const EnumEntry<uint8_t> FunctionOptionEnum[] = {
     LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, CxxReturnUdt),
     LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, Constructor),
     LLVM_READOBJ_ENUM_CLASS_ENT(FunctionOptions, ConstructorWithVirtualBases),
 };
 
-static const EnumEntry<uint8_t> FileChecksumKindNames[] = {
+const EnumEntry<uint8_t> FileChecksumKindNames[] = {
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, None),
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, MD5),
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA1),
   LLVM_READOBJ_ENUM_CLASS_ENT(FileChecksumKind, SHA256),
 };
 
 template <typename T>
-static std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
+std::error_code getSymbolAuxData(const COFFObjectFile *Obj,
                                         COFFSymbolRef Symbol,
                                         uint8_t AuxSymbolIdx, const T *&Aux) {
   ArrayRef<uint8_t> AuxData = Obj->getSymbolAuxData(Symbol);
   AuxData = AuxData.slice(AuxSymbolIdx * Obj->getSymbolTableEntrySize());
   Aux = reinterpret_cast<const T*>(AuxData.data());
   return readobj_error::success;
 }
 
+} // end anonymous namespace
+
 void COFFDumper::cacheRelocations() {
   if (RelocCached)
     return;
   RelocCached = true;
 
   for (const SectionRef &S : Obj->sections()) {
     const coff_section *Section = Obj->getCOFFSection(S);
 
void COFFDumper::printCodeViewDebugInfo() {
   for (const SectionRef &S : Obj->sections()) {
     StringRef SectionName;
     error(S.getName(SectionName));
     if (SectionName == ".debug$S")
       printCodeViewSymbolSection(SectionName, S);
   }
 }
 
+namespace {
+
 /// Consumes sizeof(T) bytes from the given byte sequence. Returns an error if
 /// there are not enough bytes remaining. Reinterprets the consumed bytes as a
 /// T object and points 'Res' at them.
 template <typename T>
-static std::error_code consumeObject(StringRef &Data, const T *&Res) {
+std::error_code consumeObject(StringRef &Data, const T *&Res) {
   if (Data.size() < sizeof(*Res))
     return object_error::parse_failed;
   Res = reinterpret_cast<const T *>(Data.data());
   Data = Data.drop_front(sizeof(*Res));
   return std::error_code();
 }
 
-static std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
+std::error_code consumeUInt32(StringRef &Data, uint32_t &Res) {
   const ulittle32_t *IntPtr;
   if (auto EC = consumeObject(Data, IntPtr))
     return EC;
   Res = *IntPtr;
   return std::error_code();
 }
 
+} // end anonymous namespace
+
 void COFFDumper::initializeFileAndStringTables(StringRef Data) {
   while (!Data.empty() && (CVFileChecksumTable.data() == nullptr ||
                            CVStringTable.data() == nullptr)) {
     // The section consists of a number of subsection in the following format:
     // |SubSectionType|SubSectionSize|Contents...|
     uint32_t SubType, SubSectionSize;
     error(consumeUInt32(Data, SubType));
     error(consumeUInt32(Data, SubSectionSize));
while (DE.isValidOffset(Offset)) {
              LineIdx != NumLines && DE.isValidOffset(Offset); ++LineIdx) {
           DE.getU32(&Offset);
         }
       }
     }
   }
 }
 
-static std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
+namespace {
+
+std::error_code decodeNumerictLeaf(StringRef &Data, APSInt &Num) {
   // Used to avoid overload ambiguity on APInt construtor.
   bool FalseVal = false;
   if (Data.size() < 2)
     return object_error::parse_failed;
   uint16_t Short = *reinterpret_cast<const ulittle16_t *>(Data.data());
   Data = Data.drop_front(2);
   if (Short < LF_NUMERIC) {
     Num = APSInt(APInt(/*numBits=*/16, Short, /*isSigned=*/false),
Num = APSInt(APInt(/*numBits=*/64,
                        /*isSigned=*/false),
                  /*isUnsigned=*/true);
     Data = Data.drop_front(8);
     return std::error_code();
   }
   return object_error::parse_failed;
 }
 
+} // end anonymous namespace
+
 /// Decode an unsigned integer numeric leaf value.
 std::error_code decodeUIntLeaf(StringRef &Data, uint64_t &Num) {
   APSInt N;
   if (std::error_code err = decodeNumerictLeaf(Data, N))
     return err;
   if (N.isSigned() || !N.isIntN(64))
     return object_error::parse_failed;
   Num = N.getLimitedValue();
case S_LPROC32_DPC_ID: {
                           &LinkageName);
       W.printHex("Segment", Proc->Segment);
       W.printFlags("Flags", Proc->Flags, makeArrayRef(ProcSymFlags));
       W.printString("DisplayName", DisplayName);
       W.printString("LinkageName", LinkageName);
       break;
     }
 
-    case S_PROC_ID_END: {
+    case S_PROC_ID_END:
       W.startLine() << "ProcEnd\n";
       InFunctionScope = false;
       break;
-    }
 
     case S_BLOCK32: {
       DictScope S(W, "BlockStart");
       const BlockSym *Block;
       error(consumeObject(SymData, Block));
 
       StringRef BlockName = SymData.split('\0').first;
       StringRef LinkageName;
       W.printHex("PtrParent", Block->PtrParent);
       W.printHex("PtrEnd", Block->PtrEnd);
       W.printHex("CodeSize", Block->CodeSize);
       printRelocatedField("CodeOffset", Sec, SectionContents,
                           &Block->CodeOffset, &LinkageName);
       W.printHex("Segment", Block->Segment);
       W.printString("BlockName", BlockName);
       W.printString("LinkageName", LinkageName);
       break;
     }
 
-    case S_END: {
+    case S_END:
       W.startLine() << "BlockEnd\n";
       InFunctionScope = false;
       break;
-    }
 
     case S_LABEL32: {
       DictScope S(W, "Label");
       const LabelSym *Label;
       error(consumeObject(SymData, Label));
 
       StringRef DisplayName = SymData.split('\0').first;
       StringRef LinkageName;
case S_DEFRANGE: {
       error(consumeObject(SymData, DefRange));
       W.printString(
           "Program",
           CVStringTable.drop_front(DefRange->Program).split('\0').first);
       printLocalVariableAddrRange(DefRange->Range, Sec, SectionContents);
       printLocalVariableAddrGap(SymData);
       break;
     }
+
     case S_DEFRANGE_SUBFIELD: {
       DictScope S(W, "DefRangeSubfield");
       const DefRangeSubfieldSym *DefRangeSubfield;
       error(consumeObject(SymData, DefRangeSubfield));
       W.printString("Program",
                     CVStringTable.drop_front(DefRangeSubfield->Program)
                         .split('\0')
                         .first);
       W.printNumber("OffsetInParent", DefRangeSubfield->OffsetInParent);
       printLocalVariableAddrRange(DefRangeSubfield->Range, Sec,
                                   SectionContents);
       printLocalVariableAddrGap(SymData);
       break;
     }
+
     case S_DEFRANGE_REGISTER: {
       DictScope S(W, "DefRangeRegister");
       const DefRangeRegisterSym *DefRangeRegister;
       error(consumeObject(SymData, DefRangeRegister));
       W.printNumber("Register", DefRangeRegister->Register);
       W.printNumber("MayHaveNoName", DefRangeRegister->MayHaveNoName);
       printLocalVariableAddrRange(DefRangeRegister->Range, Sec,
                                   SectionContents);
       printLocalVariableAddrGap(SymData);
       break;
     }
+
     case S_DEFRANGE_SUBFIELD_REGISTER: {
       DictScope S(W, "DefRangeSubfieldRegister");
       const DefRangeSubfieldRegisterSym *DefRangeSubfieldRegisterSym;
       error(consumeObject(SymData, DefRangeSubfieldRegisterSym));
       W.printNumber("Register", DefRangeSubfieldRegisterSym->Register);
       W.printNumber("MayHaveNoName",
                     DefRangeSubfieldRegisterSym->MayHaveNoName);
       W.printNumber("OffsetInParent",
                     DefRangeSubfieldRegisterSym->OffsetInParent);
       printLocalVariableAddrRange(DefRangeSubfieldRegisterSym->Range, Sec,
                                   SectionContents);
       printLocalVariableAddrGap(SymData);
       break;
     }
+
     case S_DEFRANGE_FRAMEPOINTER_REL: {
       DictScope S(W, "DefRangeFramePointerRel");
       const DefRangeFramePointerRelSym *DefRangeFramePointerRel;
       error(consumeObject(SymData, DefRangeFramePointerRel));
       W.printNumber("Offset", DefRangeFramePointerRel->Offset);
       printLocalVariableAddrRange(DefRangeFramePointerRel->Range, Sec,
                                   SectionContents);
       printLocalVariableAddrGap(SymData);
       break;
     }
+
     case S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: {
       DictScope S(W, "DefRangeFramePointerRelFullScope");
       const DefRangeFramePointerRelFullScopeSym
           *DefRangeFramePointerRelFullScope;
       error(consumeObject(SymData, DefRangeFramePointerRelFullScope));
       W.printNumber("Offset", DefRangeFramePointerRelFullScope->Offset);
       break;
     }
+
     case S_DEFRANGE_REGISTER_REL: {
       DictScope S(W, "DefRangeRegisterRel");
       const DefRangeRegisterRelSym *DefRangeRegisterRel;
       error(consumeObject(SymData, DefRangeRegisterRel));
       W.printNumber("BaseRegister", DefRangeRegisterRel->BaseRegister);
       W.printBoolean("HasSpilledUDTMember",
                      DefRangeRegisterRel->hasSpilledUDTMember());
       W.printNumber("OffsetInParent", DefRangeRegisterRel->offsetInParent());
StringRef COFFDumper::getFileNameForFileOffset(uint32_t FileOffset) {
   // Return the null-terminated string.
   return CVStringTable.drop_front(StringOffset).split('\0').first;
 }
 
 void COFFDumper::printFileNameForOffset(StringRef Label, uint32_t FileOffset) {
   W.printHex(Label, getFileNameForFileOffset(FileOffset), FileOffset);
 }
 
-static StringRef getLeafTypeName(TypeLeafKind LT) {
+namespace {
+
+StringRef getLeafTypeName(TypeLeafKind LT) {
   switch (LT) {
   case LF_STRING_ID: return "StringId";
   case LF_FIELDLIST: return "FieldList";
   case LF_ARGLIST:
   case LF_SUBSTR_LIST: return "ArgList";
   case LF_CLASS:
   case LF_STRUCTURE:
   case LF_INTERFACE: return "ClassType";
StringRef getLeafTypeName(TypeLeafKind LT) {
   case LF_VTSHAPE: return "VTableShape";
   case LF_UDT_SRC_LINE: return "UDTSrcLine";
   case LF_BUILDINFO: return "BuildInfo";
   default: break;
   }
   return "UnknownLeaf";
 }
 
+} // end anonymous namespace
+
 void COFFDumper::printCodeViewTypeSection(StringRef SectionName,
                                           const SectionRef &Section) {
   ListScope D(W, "CodeViewTypes");
   W.printNumber("Section", SectionName, Obj->getSectionID(Section));
   StringRef Data;
   error(Section.getContents(Data));
   W.printBinaryBlock("Data", Data);
 
case LF_MFUNCTION: {
       TypeName.push_back(' ');
       TypeName.append(ClassTypeName);
       TypeName.append("::");
       TypeName.append(ArgListTypeName);
       Name = TypeNames.insert(TypeName).first->getKey();
       break;
     }
 
-    case LF_METHODLIST: {
+    case LF_METHODLIST:
       while (!LeafData.empty()) {
         const MethodListEntry *Method;
         error(consumeObject(LeafData, Method));
         ListScope S(W, "Method");
         printMemberAttributes(Method->Attrs);
         printTypeIndex("Type", Method->Type);
         if (Method->isIntroducedVirtual()) {
           const little32_t *VFTOffsetPtr;
           error(consumeObject(LeafData, VFTOffsetPtr));
           W.printHex("VFTableOffset", *VFTOffsetPtr);
         }
       }
       break;
-    }
 
     case LF_FUNC_ID: {
       const FuncId *Func;
       error(consumeObject(LeafData, Func));
       printTypeIndex("ParentScope", Func->ParentScope);
       printTypeIndex("FunctionType", Func->FunctionType);
       StringRef Null;
       std::tie(Name, Null) = LeafData.split('\0');
while (!Data.empty()) {
 
     Data = RemainingData;
     // FIXME: The stream contains LF_PAD bytes that we need to ignore, but those
     // are typically included in LeafData. We may need to call skipPadding() if
     // we ever find a record that doesn't count those bytes.
   }
 }
 
-static StringRef skipPadding(StringRef Data) {
+namespace {
+
+StringRef skipPadding(StringRef Data) {
   if (Data.empty())
     return Data;
   uint8_t Leaf = Data.front();
   if (Leaf < LF_PAD0)
     return Data;
   // Leaf is greater than 0xf0. We should advance by the number of bytes in the
   // low 4 bits.
   return Data.drop_front(Leaf & 0x0F);
 }
 
+} // end anonymous namespace
+
 void COFFDumper::printMemberAttributes(MemberAttributes Attrs) {
   W.printEnum("AccessSpecifier", uint8_t(Attrs.getAccess()),
               makeArrayRef(MemberAccessNames));
   auto MK = Attrs.getMethodKind();
   // Data members will be vanilla. Don't try to print a method kind for them.
   if (MK != MethodKind::Vanilla)
     W.printEnum("MethodKind", unsigned(MK), makeArrayRef(MemberKindNames));
   if (Attrs.getFlags() != MethodOptions::None) {
void COFFDumper::printSymbols() {
   ListScope Group(W, "Symbols");
 
   for (const SymbolRef &Symbol : Obj->symbols())
     printSymbol(Symbol);
 }
 
 void COFFDumper::printDynamicSymbols() { ListScope Group(W, "DynamicSymbols"); }
 
-static ErrorOr<StringRef>
+namespace {
+
+ErrorOr<StringRef>
 getSectionName(const llvm::object::COFFObjectFile *Obj, int32_t SectionNumber,
                const coff_section *Section) {
   if (Section) {
     StringRef SectionName;
     if (std::error_code EC = Obj->getSectionName(Section, SectionName))
       return EC;
     return SectionName;
   }
   if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
     return StringRef("IMAGE_SYM_DEBUG");
   if (SectionNumber == llvm::COFF::IMAGE_SYM_ABSOLUTE)
     return StringRef("IMAGE_SYM_ABSOLUTE");
   if (SectionNumber == llvm::COFF::IMAGE_SYM_UNDEFINED)
     return StringRef("IMAGE_SYM_UNDEFINED");
   return StringRef("");
 }
 
+} // end anonymous namespace
+
 void COFFDumper::printSymbol(const SymbolRef &Sym) {
   DictScope D(W, "Symbol");
 
   COFFSymbolRef Symbol = Obj->getCOFFSymbol(Sym);
   const coff_section *Section;
   if (std::error_code EC = Obj->getSection(Symbol.getSectionNumber(), Section)) {
     W.startLine() << "Invalid section number: " << EC.message() << "\n";
     W.flush();
if (Name != ".drectve")
       continue;
 
     error(Section.getContents(Contents));
 
     W.printString("Directive(s)", Contents);
   }
 }
 
-static StringRef getBaseRelocTypeName(uint8_t Type) {
+namespace {
+
+StringRef getBaseRelocTypeName(uint8_t Type) {
   switch (Type) {
   case COFF::IMAGE_REL_BASED_ABSOLUTE: return "ABSOLUTE";
   case COFF::IMAGE_REL_BASED_HIGH: return "HIGH";
   case COFF::IMAGE_REL_BASED_LOW: return "LOW";
   case COFF::IMAGE_REL_BASED_HIGHLOW: return "HIGHLOW";
   case COFF::IMAGE_REL_BASED_HIGHADJ: return "HIGHADJ";
   case COFF::IMAGE_REL_BASED_ARM_MOV32T: return "ARM_MOV32(T)";
   case COFF::IMAGE_REL_BASED_DIR64: return "DIR64";
   default: return "unknown (" + llvm::utostr(Type) + ")";
   }
 }
 
+} // end anonymous namespace
+
 void COFFDumper::printCOFFBaseReloc() {
   ListScope D(W, "BaseReloc");
   for (const BaseRelocRef &I : Obj->base_relocs()) {
     uint8_t Type;
     uint32_t RVA;
     error(I.getRVA(RVA));
     error(I.getType(Type));
     DictScope Import(W, "Entry");

llvm/trunk/tools/sancov/sancov.cc

-//===-- sancov.cc --------------------------------------------===//
+//===-- sancov.cc ---------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a command-line tool for reading and analyzing sanitizer
 // coverage.
 //===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Triple.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrAnalysis.h"

 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SpecialCaseList.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <algorithm>
+#include <cstdint>
+#include <cstdlib>
+#include <map>
+#include <memory>
 #include <set>
-#include <stdio.h>
 #include <string>
+#include <tuple>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
 namespace {
 
 // --------- COMMAND LINE FLAGS ---------
cl::values(clEnumValN(PrintAction, "print", "Print coverage addresses"),
                clEnumValN(NotCoveredFunctionsAction, "not-covered-functions",
                           "Print all not covered funcions."),
                clEnumValN(HtmlReportAction, "html-report",
                           "Print HTML coverage report."),
                clEnumValN(StatsAction, "print-coverage-stats",
                           "Print coverage statistics."),
                clEnumValEnd));
 
-static cl::list<std::string>
+cl::list<std::string>
     ClInputFiles(cl::Positional, cl::OneOrMore,
                  cl::desc("(<binary file>|<.sancov file>)..."));
 
-static cl::opt<bool> ClDemangle("demangle", cl::init(true),
-                                cl::desc("Print demangled function name."));
+cl::opt<bool> ClDemangle("demangle", cl::init(true),
 
-static cl::opt<std::string> ClStripPathPrefix(
+cl::opt<std::string> ClStripPathPrefix(
     "strip_path_prefix", cl::init(""),
     cl::desc("Strip this prefix from file paths in reports."));
 
-static cl::opt<std::string>
+cl::opt<std::string>
     ClBlacklist("blacklist", cl::init(""),
                 cl::desc("Blacklist file (sanitizer blacklist format)."));
 
-static cl::opt<bool> ClUseDefaultBlacklist(
+cl::opt<bool> ClUseDefaultBlacklist(
     "use_default_blacklist", cl::init(true), cl::Hidden,
     cl::desc("Controls if default blacklist should be used."));
 
-static const char *const DefaultBlacklistStr = "fun:__sanitizer_.*\n"
-                                               "src:/usr/include/.*\n"
-                                               "src:.*/libc\\+\\+/.*\n";
+const char *const DefaultBlacklistStr = "fun:__sanitizer_.*\n"
 
 // --------- FORMAT SPECIFICATION ---------
 
 struct FileHeader {
   uint32_t Bitness;
   uint32_t Magic;
 };
 
-static const uint32_t BinCoverageMagic = 0xC0BFFFFF;
-static const uint32_t Bitness32 = 0xFFFFFF32;
-static const uint32_t Bitness64 = 0xFFFFFF64;
+const uint32_t BinCoverageMagic = 0xC0BFFFFF;
+const uint32_t Bitness32 = 0xFFFFFF32;
+const uint32_t Bitness64 = 0xFFFFFF64;
 
 // --------- ERROR HANDLING ---------
 
-static void Fail(const llvm::Twine &E) {
+void Fail(const llvm::Twine &E) {
   errs() << "Error: " << E << "\n";
   exit(1);
 }
 
-static void FailIfError(std::error_code Error) {
+void FailIfError(std::error_code Error) {
   if (!Error)
     return;
   errs() << "Error: " << Error.message() << "(" << Error.value() << ")\n";
   exit(1);
 }
 
-template <typename T> static void FailIfError(const ErrorOr<T> &E) {
+template <typename T>
+void FailIfError(const ErrorOr<T> &E) {
   FailIfError(E.getError());
 }
 
-static void FailIfNotEmpty(const llvm::Twine &E) {
+void FailIfNotEmpty(const llvm::Twine &E) {
   if (E.str().empty())
     return;
   Fail(E);
 }
 
 template <typename T>
-static void FailIfEmpty(const std::unique_ptr<T> &Ptr,
-                        const std::string &Message) {
+void FailIfEmpty(const std::unique_ptr<T> &Ptr, const std::string &Message) {
   if (Ptr.get())
     return;
   Fail(Message);
 }
 
 // ---------
 
 // Produces std::map<K, std::vector<E>> grouping input
 // elements by FuncTy result.
 template <class RangeTy, class FuncTy>
-static inline auto group_by(const RangeTy &R, FuncTy F)
+inline auto group_by(const RangeTy &R, FuncTy F)
     -> std::map<typename std::decay<decltype(F(*R.begin()))>::type,
                 std::vector<typename std::decay<decltype(*R.begin())>::type>> {
   std::map<typename std::decay<decltype(F(*R.begin()))>::type,
            std::vector<typename std::decay<decltype(*R.begin())>::type>>
       Result;
   for (const auto &E : R) {
     Result[F(E)].push_back(E);
   }
   return Result;
 }
 
 template <typename T>
-static void readInts(const char *Start, const char *End,
-                     std::set<uint64_t> *Ints) {
+void readInts(const char *Start, const char *End, std::set<uint64_t> *Ints) {
   const T *S = reinterpret_cast<const T *>(Start);
   const T *E = reinterpret_cast<const T *>(End);
   std::copy(S, E, std::inserter(*Ints, Ints->end()));
 }
 
 struct FileLoc {
   bool operator<(const FileLoc &RHS) const {
     return std::tie(FileName, Line) < std::tie(RHS.FileName, RHS.Line);
std::string stripPathPrefix(std::string Path) {
   if (ClStripPathPrefix.empty())
     return Path;
   size_t Pos = Path.find(ClStripPathPrefix);
   if (Pos == std::string::npos)
     return Path;
   return Path.substr(Pos + ClStripPathPrefix.size());
 }
 
-static std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
+std::unique_ptr<symbolize::LLVMSymbolizer> createSymbolizer() {
   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
   return std::unique_ptr<symbolize::LLVMSymbolizer>(
       new symbolize::LLVMSymbolizer(SymbolizerOptions));
 }
 
 // A DILineInfo with address.
static std::unique_ptr<SpecialCaseList> createUserBlacklist() {
 
     return SpecialCaseList::createOrDie({{ClBlacklist}});
   }
   std::unique_ptr<SpecialCaseList> DefaultBlacklist;
   std::unique_ptr<SpecialCaseList> UserBlacklist;
 };
 
 // Collect all debug info for given addresses.
-static std::vector<AddrInfo> getAddrInfo(std::string ObjectFile,
-                                         const std::set<uint64_t> &Addrs,
-                                         bool InlinedCode) {
+std::vector<AddrInfo> getAddrInfo(std::string ObjectFile,
   std::vector<AddrInfo> Result;
   auto Symbolizer(createSymbolizer());
   Blacklists B;
 
   for (auto Addr : Addrs) {
     auto LineInfo = Symbolizer->symbolizeCode(ObjectFile, Addr);
     FailIfError(LineInfo);
     if (B.isBlacklisted(*LineInfo))
for (auto Addr : Addrs) {
     }
   }
 
   return Result;
 }
 
 // Locate __sanitizer_cov* function addresses that are used for coverage
 // reporting.
-static std::set<uint64_t>
+std::set<uint64_t>
 findSanitizerCovFunctions(const object::ObjectFile &O) {
   std::set<uint64_t> Result;
 
   for (const object::SymbolRef &Symbol : O.symbols()) {
     ErrorOr<uint64_t> AddressOrErr = Symbol.getAddress();
     FailIfError(AddressOrErr);
 
     ErrorOr<StringRef> NameOrErr = Symbol.getName();
     FailIfError(NameOrErr);
     StringRef Name = NameOrErr.get();
 
     if (Name == "__sanitizer_cov" || Name == "__sanitizer_cov_with_check" ||
         Name == "__sanitizer_cov_trace_func_enter") {
       if (!(Symbol.getFlags() & object::BasicSymbolRef::SF_Undefined))
         Result.insert(AddressOrErr.get());
     }
   }
 
   return Result;
 }
 
 // Locate addresses of all coverage points in a file. Coverage point
 // is defined as the 'address of instruction following __sanitizer_cov
 // call - 1'.
-static void getObjectCoveragePoints(const object::ObjectFile &O,
-                                    std::set<uint64_t> *Addrs) {
+void getObjectCoveragePoints(const object::ObjectFile &O,
   Triple TheTriple("unknown-unknown-unknown");
   TheTriple.setArch(Triple::ArchType(O.getArch()));
   auto TripleName = TheTriple.getTriple();
 
   std::string Error;
   const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
   FailIfNotEmpty(Error);
 
for (uint64_t Index = 0, Size = 0; Index < Section.getSize();
       if (MIA->isCall(Inst) &&
           MIA->evaluateBranch(Inst, SectionAddr + Index, Size, Target) &&
           SanCovAddrs.find(Target) != SanCovAddrs.end())
         Addrs->insert(CovPoint);
     }
   }
 }
 
-static void
+void
 visitObjectFiles(const object::Archive &A,
                  std::function<void(const object::ObjectFile &)> Fn) {
   for (auto &ErrorOrChild : A.children()) {
     FailIfError(ErrorOrChild);
     const object::Archive::Child &C = *ErrorOrChild;
     ErrorOr<std::unique_ptr<object::Binary>> ChildOrErr = C.getAsBinary();
     FailIfError(ChildOrErr);
     if (auto *O = dyn_cast<object::ObjectFile>(&*ChildOrErr.get()))
       Fn(*O);
     else
       FailIfError(object::object_error::invalid_file_type);
   }
 }
 
-static void
+void
 visitObjectFiles(std::string FileName,
                  std::function<void(const object::ObjectFile &)> Fn) {
   ErrorOr<object::OwningBinary<object::Binary>> BinaryOrErr =
       object::createBinary(FileName);
   FailIfError(BinaryOrErr);
 
   object::Binary &Binary = *BinaryOrErr.get().getBinary();
   if (object::Archive *A = dyn_cast<object::Archive>(&Binary))

 std::set<uint64_t> getCoveragePoints(std::string FileName) {
   std::set<uint64_t> Result;
   visitObjectFiles(FileName, [&](const object::ObjectFile &O) {
     getObjectCoveragePoints(O, &Result);
   });
   return Result;
 }
 
-static void printCovPoints(std::string ObjFile, raw_ostream &OS) {
+void printCovPoints(std::string ObjFile, raw_ostream &OS) {
   for (uint64_t Addr : getCoveragePoints(ObjFile)) {
     OS << "0x";
     OS.write_hex(Addr);
     OS << "\n";
   }
 }
 
-static std::string escapeHtml(const std::string &S) {
+std::string escapeHtml(const std::string &S) {
   std::string Result;
   Result.reserve(S.size());
   for (char Ch : S) {
     switch (Ch) {
     case '&':
       Result.append("&amp;");
       break;
     case '\'':
default:
       break;
     }
   }
   return Result;
 }
 
 // Adds leading zeroes wrapped in 'lz' style.
 // Leading zeroes help locate 000% coverage.
-static std::string formatHtmlPct(size_t Pct) {
+std::string formatHtmlPct(size_t Pct) {
   Pct = std::max(std::size_t{0}, std::min(std::size_t{100}, Pct));
 
   std::string Num = std::to_string(Pct);
   std::string Zeroes(3 - Num.size(), '0');
   if (!Zeroes.empty())
     Zeroes = "<span class='lz'>" + Zeroes + "</span>";
 
   return Zeroes + Num;
 }
 
-static std::string anchorName(std::string Anchor) {
+std::string anchorName(std::string Anchor) {
   llvm::MD5 Hasher;
   llvm::MD5::MD5Result Hash;
   Hasher.update(Anchor);
   Hasher.final(Hash);
 
   SmallString<32> HexString;
   llvm::MD5::stringifyResult(Hash, HexString);
   return HexString.str().str();
 }
 
-static ErrorOr<bool> isCoverageFile(std::string FileName) {
+ErrorOr<bool> isCoverageFile(std::string FileName) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
       MemoryBuffer::getFile(FileName);
   if (!BufOrErr) {
     errs() << "Warning: " << BufOrErr.getError().message() << "("
            << BufOrErr.getError().value()
            << "), filename: " << llvm::sys::path::filename(FileName) << "\n";
     return BufOrErr.getError();
   }
struct CoverageStats {
   CoverageStats() : AllPoints(0), CovPoints(0), AllFns(0), CovFns(0) {}
 
   size_t AllPoints;
   size_t CovPoints;
   size_t AllFns;
   size_t CovFns;
 };
 
-static raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
+raw_ostream &operator<<(raw_ostream &OS, const CoverageStats &Stats) {
   OS << "all-edges: " << Stats.AllPoints << "\n";
   OS << "cov-edges: " << Stats.CovPoints << "\n";
   OS << "all-functions: " << Stats.AllFns << "\n";
   OS << "cov-functions: " << Stats.CovFns << "\n";
   return OS;
 }
 
 class CoverageData {

 
 private:
   const std::set<uint64_t> AllCovPoints;
 
   std::vector<AddrInfo> AllAddrInfo;
   std::vector<AddrInfo> CovAddrInfo;
 };
 
-static void printFunctionLocs(const SourceCoverageData::FunctionLocs &FnLocs,
-                              raw_ostream &OS) {
+void printFunctionLocs(const SourceCoverageData::FunctionLocs &FnLocs,
   for (const auto &Fns : FnLocs) {
     for (const auto &Fn : Fns.second) {
       OS << stripPathPrefix(Fns.first.FileName) << ":" << Fns.first.Line << " "
          << Fn << "\n";
     }
   }
 }
 
explicit CoverageDataSet(
     Data->swap(this->Coverage);
   }
 
   const std::string MainObjFile;
   std::vector<std::unique_ptr<CoverageDataWithObjectFile>> Coverage;
   const std::set<std::string> CoverageFiles;
 };
 
-} // namespace
+} // end anonymous namespace
 
 int main(int argc, char **argv) {
   // Print stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   llvm::InitializeAllTargetInfos();

llvm/trunk/tools/sanstats/sanstats.cpp

 //===- sanstats.cpp - Sanitizer statistics dumper -------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This tool dumps statistics information from files in the format produced
 // by clang's -fsanitize-stats feature.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
-#include <stdint.h>
+#include <cassert>
+#include <cstdint>
+#include <memory>
+#include <string>
 
 using namespace llvm;
 
-static cl::opt<std::string> ClInputFile(cl::Positional, cl::Required,
-                                        cl::desc("<filename>"));
+namespace {
+
+cl::opt<std::string> ClInputFile(cl::Positional, cl::Required,
 
-static cl::opt<bool> ClDemangle("demangle", cl::init(false),
-                                cl::desc("Print demangled function name."));
+cl::opt<bool> ClDemangle("demangle", cl::init(false),
 
 inline uint64_t KindFromData(uint64_t Data, char SizeofPtr) {
   return Data >> (SizeofPtr * 8 - kSanitizerStatKindBits);
 }
 
 inline uint64_t CountFromData(uint64_t Data, char SizeofPtr) {
   return Data & ((1ull << (SizeofPtr * 8 - kSanitizerStatKindBits)) - 1);
 }
const char *ReadModule(char SizeofPtr, const char *Begin, const char *End) {
   if (Begin == End)
     return nullptr;
 
   symbolize::LLVMSymbolizer::Options SymbolizerOptions;
   SymbolizerOptions.Demangle = ClDemangle;
   SymbolizerOptions.UseSymbolTable = true;
   symbolize::LLVMSymbolizer Symbolizer(SymbolizerOptions);
 
-  while (1) {
+  while (true) {
     uint64_t Addr = ReadLE(SizeofPtr, Begin, End);
     Begin += SizeofPtr;
     uint64_t Data = ReadLE(SizeofPtr, Begin, End);
     Begin += SizeofPtr;
 
     if (Begin > End)
       return nullptr;
     if (Addr == 0 && Data == 0)
default:
       llvm::outs() << "<unknown>";
       break;
     }
 
     llvm::outs() << " " << CountFromData(Data, SizeofPtr) << '\n';
   }
 }
 
+} // end anonymous namespace
+
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv,
                               "Sanitizer Statistics Processing Tool");
 
   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
       MemoryBuffer::getFile(ClInputFile, -1, false);
   if (!MBOrErr) {
     errs() << argv[0] << ": " << ClInputFile << ": "

llvm/trunk/unittests/ADT/SCCIteratorTest.cpp

 //===----- llvm/unittest/ADT/SCCIteratorTest.cpp - SCCIterator tests ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SCCIterator.h"
 #include "llvm/ADT/GraphTraits.h"
 #include "gtest/gtest.h"
-#include <limits.h>
+#include <cassert>
+#include <climits>
+#include <utility>
+#include <vector>
 
 using namespace llvm;
 
 namespace llvm {
 
 /// Graph<N> - A graph with N nodes.  Note that N can be at most 8.
 template <unsigned N>
 class Graph {
 private:
   // Disable copying.
   Graph(const Graph&);
   Graph& operator=(const Graph&);
 
   static void ValidateIndex(unsigned Idx) {
     assert(Idx < N && "Invalid node index!");
   }
-public:
 
+public:
   /// NodeSubset - A subset of the graph's nodes.
   class NodeSubset {
     typedef unsigned char BitVector; // Where the limitation N <= 8 comes from.
     BitVector Elements;
     NodeSubset(BitVector e) : Elements(e) {}
+
   public:
     /// NodeSubset - Default constructor, creates an empty subset.
     NodeSubset() : Elements(0) {
       assert(N <= sizeof(BitVector)*CHAR_BIT && "Graph too big!");
     }
 
     /// Comparison operators.
     bool operator==(const NodeSubset &other) const {
public:
   };
 
   /// NodeType - Node index and set of children of the node.
   typedef std::pair<unsigned, NodeSubset> NodeType;
 
 private:
   /// Nodes - The list of nodes for this graph.
   NodeType Nodes[N];
-public:
 
+public:
   /// Graph - Default constructor.  Creates an empty graph.
   Graph() {
     // Let each node know which node it is.  This allows us to find the start of
     // the Nodes array given a pointer to any element of it.
     for (unsigned i = 0; i != N; ++i)
       Nodes[i].first = i;
   }
 
class ChildIterator {
 
     /// FirstNode - Pointer to first node in the graph's Nodes array.
     NodeType *FirstNode;
     /// Children - Set of nodes which are children of this one and that haven't
     /// yet been visited.
     NodeSubset Children;
 
     ChildIterator(); // Disable default constructor.
+
   protected:
     ChildIterator(NodeType *F, NodeSubset C) : FirstNode(F), Children(C) {}
 
   public:
     /// ChildIterator - Copy constructor.
     ChildIterator(const ChildIterator& other) : FirstNode(other.FirstNode),
       Children(other.Children) {}
 
for (unsigned GraphDescriptor = 0; GraphDescriptor < (1U << NUM_GRAPHS);
     }
 
     // Finally, check that the nodes in some SCC are exactly those that are
     // reachable from the initial node.
     EXPECT_EQ(NodesInSomeSCC, G.NodesReachableFrom(0));
   }
 }
 
-}
+} // end namespace llvm

llvm/trunk/unittests/ADT/SmallStringTest.cpp

 //===- llvm/unittest/ADT/SmallStringTest.cpp ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // SmallString unit tests.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringRef.h"
 #include "gtest/gtest.h"
-#include <climits>
-#include <cstring>
-#include <stdarg.h>
 
 using namespace llvm;
 
 namespace {
 
 // Test fixture class
 class SmallStringTest : public testing::Test {
 protected:
TEST(StringRefTest, Comparisons) {
   EXPECT_EQ( 1, SmallString<10>("V16").compare_numeric("V1_q0"));
   EXPECT_EQ(-1, SmallString<10>("V1_q0").compare_numeric("V16"));
   EXPECT_EQ(-1, SmallString<10>("V8_q0").compare_numeric("V16"));
   EXPECT_EQ( 1, SmallString<10>("V16").compare_numeric("V8_q0"));
   EXPECT_EQ(-1, SmallString<10>("V1_q0").compare_numeric("V8_q0"));
   EXPECT_EQ( 1, SmallString<10>("V8_q0").compare_numeric("V1_q0"));
 }
 
-}
+} // end anonymous namespace

llvm/trunk/unittests/ADT/SmallVectorTest.cpp

 // SmallVector unit tests.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Compiler.h"
 #include "gtest/gtest.h"
+#include <cstdarg>
+#include <cstdlib>
 #include <list>
-#include <stdarg.h>
+#include <utility>
 
 using namespace llvm;
 
 namespace {
 
 /// A helper class that counts the total number of constructor and
 /// destructor calls.
 class Constructable {

 int Constructable::numCopyConstructorCalls;
 int Constructable::numMoveConstructorCalls;
 int Constructable::numDestructorCalls;
 int Constructable::numAssignmentCalls;
 int Constructable::numCopyAssignmentCalls;
 int Constructable::numMoveAssignmentCalls;
 
 struct NonCopyable {
-  NonCopyable() {}
-  NonCopyable(NonCopyable &&) {}
+  NonCopyable() = default;
+  NonCopyable(NonCopyable &&) = default;
   NonCopyable &operator=(NonCopyable &&) { return *this; }
+
 private:
   NonCopyable(const NonCopyable &) = delete;
   NonCopyable &operator=(const NonCopyable &) = delete;
 };
 
 LLVM_ATTRIBUTE_USED void CompileTest() {
   SmallVector<NonCopyable, 0> V;
   V.resize(42);

 // Test fixture class
 template <typename VectorT>
 class SmallVectorTest : public SmallVectorTestBase {
 protected:
   VectorT theVector;
   VectorT otherVector;
 };
 
-
 typedef ::testing::Types<SmallVector<Constructable, 0>,
                          SmallVector<Constructable, 1>,
                          SmallVector<Constructable, 2>,
                          SmallVector<Constructable, 4>,
                          SmallVector<Constructable, 5>
                          > SmallVectorTestTypes;
 TYPED_TEST_CASE(SmallVectorTest, SmallVectorTestTypes);
 
TYPED_TEST(SmallVectorTest, InsertRepeatedTest) {
   // Copy construct the two new elements from the parameter.
   EXPECT_EQ(2, Constructable::getNumCopyAssignmentCalls());
   // All without any copy construction.
   EXPECT_EQ(0, Constructable::getNumCopyConstructorCalls());
   EXPECT_EQ(this->theVector.begin() + 1, I);
   this->assertValuesInOrder(this->theVector, 6u, 1, 16, 16, 2, 3, 4);
 }
 
-
 TYPED_TEST(SmallVectorTest, InsertRepeatedAtEndTest) {
   SCOPED_TRACE("InsertRepeatedTest");
 
   this->makeSequence(this->theVector, 1, 4);
   Constructable::reset();
   auto I = this->theVector.insert(this->theVector.end(), 2, Constructable(16));
   // Just copy construct them into newly allocated space
   EXPECT_EQ(2, Constructable::getNumCopyConstructorCalls());
TYPED_TEST(SmallVectorTest, InsertRangeTest) {
   // Copy assign the lower 2 new elements into existing space.
   EXPECT_EQ(2, Constructable::getNumCopyAssignmentCalls());
   // Copy construct the third element into newly allocated space.
   EXPECT_EQ(1, Constructable::getNumCopyConstructorCalls());
   EXPECT_EQ(this->theVector.begin() + 1, I);
   this->assertValuesInOrder(this->theVector, 6u, 1, 77, 77, 77, 2, 3);
 }
 
-
 TYPED_TEST(SmallVectorTest, InsertRangeAtEndTest) {
   SCOPED_TRACE("InsertRangeTest");
 
   Constructable Arr[3] =
     { Constructable(77), Constructable(77), Constructable(77) };
 
   this->makeSequence(this->theVector, 1, 3);
 
TEST(SmallVectorCustomTest, NoAssignTest) {
   SmallVector<notassignable, 2> vec;
   vec.push_back(notassignable(x));
   x = 42;
   EXPECT_EQ(42, vec.pop_back_val().x);
 }
 
 struct MovedFrom {
   bool hasValue;
+
   MovedFrom() : hasValue(true) {
   }
+
   MovedFrom(MovedFrom&& m) : hasValue(m.hasValue) {
     m.hasValue = false;
   }
+
   MovedFrom &operator=(MovedFrom&& m) {
     hasValue = m.hasValue;
     m.hasValue = false;
     return *this;
   }
 };
 
 TEST(SmallVectorTest, MidInsert) {
   SmallVector<MovedFrom, 3> v;
   v.push_back(MovedFrom());
   v.insert(v.begin(), MovedFrom());
   for (MovedFrom &m : v)
     EXPECT_TRUE(m.hasValue);
 }
 
 enum EmplaceableArgState {
   EAS_Defaulted,
   EAS_Arg,
   EAS_LValue,
   EAS_RValue,
   EAS_Failure
 };
+
 template <int I> struct EmplaceableArg {
   EmplaceableArgState State;
   EmplaceableArg() : State(EAS_Defaulted) {}
   EmplaceableArg(EmplaceableArg &&X)
       : State(X.State == EAS_Arg ? EAS_RValue : EAS_Failure) {}
   EmplaceableArg(EmplaceableArg &X)
       : State(X.State == EAS_Arg ? EAS_LValue : EAS_Failure) {}
 
TEST(SmallVectorTest, InitializerList) {
   V2.assign({4});
   EXPECT_TRUE(makeArrayRef(V2).equals({4}));
   V2.append({3, 2});
   EXPECT_TRUE(makeArrayRef(V2).equals({4, 3, 2}));
   V2.insert(V2.begin() + 1, 5);
   EXPECT_TRUE(makeArrayRef(V2).equals({4, 5, 3, 2}));
 }
 
-} // end namespace
+} // end anonymous namespace

llvm/trunk/unittests/ExecutionEngine/Orc/OrcCAPITest.cpp

 //===--------------- OrcCAPITest.cpp - Unit tests Orc C API ---------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "OrcTestCommon.h"
 #include "gtest/gtest.h"
 #include "llvm-c/Core.h"
 #include "llvm-c/OrcBindings.h"
 #include "llvm-c/Target.h"
 #include "llvm-c/TargetMachine.h"
+#include "llvm/ADT/Triple.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include <cstring>
+#include <memory>
 
 namespace llvm {
 
 DEFINE_SIMPLE_CONVERSION_FUNCTIONS(TargetMachine, LLVMTargetMachineRef)
 
 class OrcCAPIExecutionTest : public testing::Test, public OrcExecutionTest {
 protected:
   std::unique_ptr<Module> createTestModule(const Triple &TT) {
EXPECT_FALSE(C.Compiled)
     << "Direct-callback JIT'd code was JIT'd twice";
 
   LLVMOrcRemoveModule(JIT, C.H);
 
   LLVMOrcDisposeMangledSymbol(testFuncName);
   LLVMOrcDisposeInstance(JIT);
 }
 
-} // namespace llvm
+} // end namespace llvm

llvm/trunk/unittests/Support/CommandLineTest.cpp

 //===- llvm/unittest/Support/CommandLineTest.cpp - CommandLine tests ------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Config/config.h"
+#include "llvm/Support/Allocator.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/StringSaver.h"
 #include "gtest/gtest.h"
-#include <stdlib.h>
+#include <cstdlib>
 #include <string>
 
 using namespace llvm;
 
 namespace {
 
 class TempEnvVar {
- public:
   TempEnvVar(const char *name, const char *value)
       : name(name) {
     const char *old_value = getenv(name);
     EXPECT_EQ(nullptr, old_value) << old_value;
 #if HAVE_SETENV
     setenv(name, value, true);
 #else
 #   define SKIP_ENVIRONMENT_TESTS
 #endif
   }
 
   ~TempEnvVar() {
 #if HAVE_SETENV
     // Assume setenv and unsetenv come together.
     unsetenv(name);
 #else
     (void)name; // Suppress -Wunused-private-field.
 #endif
   }
 
- private:
   const char *const name;
 };
 
 template <typename T>
 class StackOption : public cl::opt<T> {
   typedef cl::opt<T> Base;
+
 public:
   // One option...
   template<class M0t>
   explicit StackOption(const M0t &M0) : Base(M0) {}
 
   // Two options...
   template<class M0t, class M1t>
   StackOption(const M0t &M0, const M1t &M1) : Base(M0, M1) {}
 
   // Three options...
   template<class M0t, class M1t, class M2t>
   StackOption(const M0t &M0, const M1t &M1, const M2t &M2) : Base(M0, M1, M2) {}
 
   // Four options...
   template<class M0t, class M1t, class M2t, class M3t>
   StackOption(const M0t &M0, const M1t &M1, const M2t &M2, const M3t &M3)
     : Base(M0, M1, M2, M3) {}
 
   ~StackOption() override { this->removeArgument(); }
 };
 
-
 cl::OptionCategory TestCategory("Test Options", "Description");
 TEST(CommandLineTest, ModifyExisitingOption) {
   StackOption<int> TestOption("test-option", cl::desc("old description"));
 
   const char Description[] = "New description";
   const char ArgString[] = "new-test-option";
   const char ValueString[] = "Integer";
 
TEST(CommandLineTest, HideUnrelatedOptionsMulti) {
   ASSERT_EQ(cl::NotHidden, TestOption3.getOptionHiddenFlag())
       << "Hid extra option that should be visable.";
 
   StringMap<cl::Option *> &Map = cl::getRegisteredOptions();
   ASSERT_EQ(cl::NotHidden, Map["help"]->getOptionHiddenFlag())
       << "Hid default option that should be visable.";
 }
 
-}  // anonymous namespace
+} // end anonymous namespace

llvm/trunk/unittests/Support/ProgramTest.cpp

 //===- unittest/Support/ProgramTest.cpp -----------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Program.h"
+#include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
-#include <stdlib.h>
+#include <cstdlib>
+#include <cstring>
+#include <string>
+#include <vector>
 #if defined(__APPLE__)
 # include <crt_externs.h>
 #elif !defined(_MSC_VER)
 // Forward declare environ in case it's not provided by stdlib.h.
 extern char **environ;
 #endif
 
 #if defined(LLVM_ON_UNIX)
if (std::error_code ASSERT_NO_ERROR_ec = x) {                                \
     SmallString<128> MessageStorage;                                           \
     raw_svector_ostream Message(MessageStorage);                               \
     Message << #x ": did not return errc::success.\n"                          \
             << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n"          \
             << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n";      \
     GTEST_FATAL_FAILURE_(MessageStorage.c_str());                              \
   } else {                                                                     \
   }
+
 // From TestMain.cpp.
 extern const char *TestMainArgv0;
 
 namespace {
 
 using namespace llvm;
 using namespace sys;
 
-static cl::opt<std::string>
+cl::opt<std::string>
 ProgramTestStringArg1("program-test-string-arg1");
-static cl::opt<std::string>
+cl::opt<std::string>
 ProgramTestStringArg2("program-test-string-arg2");
 
 class ProgramEnvTest : public testing::Test {
   std::vector<const char *> EnvTable;
   std::vector<std::string> EnvStorage;
 
 protected:
   void SetUp() override {
const char *argv[] = { Executable.c_str(), nullptr };
     bool ExecutionFailed;
     ProcessInfo PI = ExecuteNoWait(Executable, argv, nullptr, nullptr, 0,
                                    &Error, &ExecutionFailed);
     ASSERT_EQ(PI.Pid, ProcessInfo::InvalidPid)
         << "On error ExecuteNoWait should return an invalid ProcessInfo";
     ASSERT_TRUE(ExecutionFailed);
     ASSERT_FALSE(Error.empty());
   }
-
 }
 
 #ifdef LLVM_ON_WIN32
 const char utf16le_text[] =
     "\x6c\x00\x69\x00\x6e\x00\x67\x00\xfc\x00\x69\x00\xe7\x00\x61\x00";
 const char utf16be_text[] =
     "\x00\x6c\x00\x69\x00\x6e\x00\x67\x00\xfc\x00\x69\x00\xe7\x00\x61";
 #endif

llvm/trunk/unittests/Support/StreamingMemoryObjectTest.cpp

 //===- unittests/Support/StreamingMemoryObjectTest.cpp --------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/StreamingMemoryObject.h"
 #include "gtest/gtest.h"
-#include <string.h>
+#include <cstring>
 
 using namespace llvm;
 
 namespace {
 
 class NullDataStreamer : public DataStreamer {
   size_t GetBytes(unsigned char *Buffer, size_t Length) override {
     memset(Buffer, 0, Length);
StreamingMemoryObject O(make_unique<BufferStreamer>(StringRef(
       reinterpret_cast<const char *>(InputBuffer), sizeof(InputBuffer))));
 
   EXPECT_TRUE(std::equal(InputBuffer + 1, InputBuffer + 2, O.getPointer(1, 2)));
   EXPECT_TRUE(std::equal(InputBuffer + 3, InputBuffer + 7, O.getPointer(3, 4)));
   EXPECT_TRUE(std::equal(InputBuffer + 4, InputBuffer + 8, O.getPointer(4, 5)));
   EXPECT_TRUE(std::equal(InputBuffer, InputBuffer + 8, O.getPointer(0, 20)));
 }
 
-} // end namespace
+} // end anonymous namespace

llvm/trunk/unittests/Support/TimeValueTest.cpp

 //===- llvm/unittest/Support/TimeValueTest.cpp - Time Value tests ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "gtest/gtest.h"
 #include "llvm/Support/TimeValue.h"
-#include <time.h>
+#include <cstdint>
+#include <cstdlib>
+#include <ctime>
 
 using namespace llvm;
+
 namespace {
 
 TEST(TimeValue, time_t) {
   sys::TimeValue now = sys::TimeValue::now();
   time_t now_t = time(nullptr);
   EXPECT_TRUE(std::abs(static_cast<long>(now_t - now.toEpochTime())) < 2);
 }
 
TEST(TimeValue, Win32FILETIME) {
   // The "seconds" part in Posix time may be expected as zero.
   EXPECT_EQ(0u, epoch.toEpochTime());
   EXPECT_EQ(ns, static_cast<uint32_t>(epoch.nanoseconds()));
 
   // Confirm it reversible.
   EXPECT_EQ(ft1970, epoch.toWin32Time());
 }
 
-}
+} // end anonymous namespace

llvm/trunk/unittests/Support/TimerTest.cpp

 //===- unittests/TimerTest.cpp - Timer tests ------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Timer.h"
 #include "gtest/gtest.h"
 
 #if LLVM_ON_WIN32
 #include <windows.h>
 #else
-#include <time.h>
+#include <ctime>
 #endif
 
 using namespace llvm;
 
 namespace {
 
 // FIXME: Put this somewhere in Support, it's also used in LockFileManager.
 void SleepMS() {
TEST(Timer, CheckIfTriggered) {
   EXPECT_TRUE(T1.hasTriggered());
   T1.stopTimer();
   EXPECT_TRUE(T1.hasTriggered());
 
   T1.clear();
   EXPECT_FALSE(T1.hasTriggered());
 }
 
-} // end anon namespace
+} // end anonymous namespace