Add LLVM_ATTRIBUTE_USED to fix problems which could be exposed by aggressive global pointer variable removal

[MaskRay]

Summary

Note to BuryPointer.cpp:GraveYard. 'unused' cannot prevent (1) dead store
elimination and (2) removal of the global pointer variable (D69428) but 'used' can.

Discovered when comparing link maps between HEAD+D69428 and HEAD.

[lattner]

Looks great, thank you for catching this!

llvm/lib/Support/BuryPointer.cpp

 
 void BuryPointer(const void *Ptr) {
   // This function may be called only a small fixed amount of times per each
   // invocation, otherwise we do actually have a leak which we want to report.
   // If this function is called more than kGraveYardMaxSize times, the pointers
   // will not be properly buried and a leak detector will report a leak, which
   // is what we want in such case.
   static const size_t kGraveYardMaxSize = 16;
-  LLVM_ATTRIBUTE_UNUSED static const void *GraveYard[kGraveYardMaxSize];
+  LLVM_ATTRIBUTE_USED static const void *GraveYard[kGraveYardMaxSize];
   static std::atomic<unsigned> GraveYardSize;
   unsigned Idx = GraveYardSize++;
   if (Idx >= kGraveYardMaxSize)
     return;
   GraveYard[Idx] = Ptr;
 }
 
 } // namespace llvm

llvm/lib/Support/Unix/Signals.inc

 
 using namespace llvm;
 
 static RETSIGTYPE SignalHandler(int Sig);  // defined below.
 static RETSIGTYPE InfoSignalHandler(int Sig);  // defined below.
 
 using SignalHandlerFunctionType = void (*)();
 /// The function to call if ctrl-c is pressed.
 static std::atomic<SignalHandlerFunctionType> InterruptFunction =
     ATOMIC_VAR_INIT(nullptr);
 static std::atomic<SignalHandlerFunctionType> InfoSignalFunction =
     ATOMIC_VAR_INIT(nullptr);
 /// The function to call on SIGPIPE (one-time use only).
 static std::atomic<SignalHandlerFunctionType> OneShotPipeSignalFunction =
     ATOMIC_VAR_INIT(nullptr);
 
 namespace {
 /// Signal-safe removal of files.
 /// Inserting and erasing from the list isn't signal-safe, but removal of files
 /// themselves is signal-safe. Memory is freed when the head is freed, deletion
 /// is therefore not signal-safe either.
 class FileToRemoveList {
   std::atomic<char *> Filename = ATOMIC_VAR_INIT(nullptr);
   std::atomic<FileToRemoveList *> Next = ATOMIC_VAR_INIT(nullptr);
 
   FileToRemoveList() = default;
   // Not signal-safe.
   FileToRemoveList(const std::string &str) : Filename(strdup(str.c_str())) {}
 
 public:
   // Not signal-safe.
   ~FileToRemoveList() {
     if (FileToRemoveList *N = Next.exchange(nullptr))
       delete N;
     if (char *F = Filename.exchange(nullptr))
       free(F);
   }
 
   // Not signal-safe.
   static void insert(std::atomic<FileToRemoveList *> &Head,
                      const std::string &Filename) {
     // Insert the new file at the end of the list.
     FileToRemoveList *NewHead = new FileToRemoveList(Filename);
     std::atomic<FileToRemoveList *> *InsertionPoint = &Head;
     FileToRemoveList *OldHead = nullptr;
     while (!InsertionPoint->compare_exchange_strong(OldHead, NewHead)) {
       InsertionPoint = &OldHead->Next;
       OldHead = nullptr;
     }
   }
 
   // Not signal-safe.
   static void erase(std::atomic<FileToRemoveList *> &Head,
                     const std::string &Filename) {
     // Use a lock to avoid concurrent erase: the comparison would access
     // free'd memory.
     static ManagedStatic<sys::SmartMutex<true>> Lock;
     sys::SmartScopedLock<true> Writer(*Lock);
 
     for (FileToRemoveList *Current = Head.load(); Current;
          Current = Current->Next.load()) {
       if (char *OldFilename = Current->Filename.load()) {
         if (OldFilename != Filename)
           continue;
         // Leave an empty filename.
         OldFilename = Current->Filename.exchange(nullptr);
         // The filename might have become null between the time we
         // compared it and we exchanged it.
         if (OldFilename)
           free(OldFilename);
       }
     }
   }
 
   // Signal-safe.
   static void removeAllFiles(std::atomic<FileToRemoveList *> &Head) {
     // If cleanup were to occur while we're removing files we'd have a bad time.
     // Make sure we're OK by preventing cleanup from doing anything while we're
     // removing files. If cleanup races with us and we win we'll have a leak,
     // but we won't crash.
     FileToRemoveList *OldHead = Head.exchange(nullptr);
 
     for (FileToRemoveList *currentFile = OldHead; currentFile;
          currentFile = currentFile->Next.load()) {
       // If erasing was occuring while we're trying to remove files we'd look
       // at free'd data. Take away the path and put it back when done.
       if (char *path = currentFile->Filename.exchange(nullptr)) {
         // Get the status so we can determine if it's a file or directory. If we
         // can't stat the file, ignore it.
for (FileToRemoveList *currentFile = OldHead; currentFile;
         unlink(path);
 
         // We're done removing the file, erasing can safely proceed.
         currentFile->Filename.exchange(path);
       }
     }
 
     // We're done removing files, cleanup can safely proceed.
     Head.exchange(OldHead);
   }
 };
 static std::atomic<FileToRemoveList *> FilesToRemove = ATOMIC_VAR_INIT(nullptr);
 
 /// Clean up the list in a signal-friendly manner.
 /// Recall that signals can fire during llvm_shutdown. If this occurs we should
 /// either clean something up or nothing at all, but we shouldn't crash!
 struct FilesToRemoveCleanup {
   // Not signal-safe.
   ~FilesToRemoveCleanup() {
     FileToRemoveList *Head = FilesToRemove.exchange(nullptr);

 #endif
 };
 
 static const size_t NumSigs =
     array_lengthof(IntSigs) + array_lengthof(KillSigs) +
     array_lengthof(InfoSigs) + 1 /* SIGPIPE */;
 
 
 static std::atomic<unsigned> NumRegisteredSignals = ATOMIC_VAR_INIT(0);
 static struct {
   struct sigaction SA;
   int SigNo;
 } RegisteredSignalInfo[NumSigs];
 
 #if defined(HAVE_SIGALTSTACK)
 // Hold onto both the old and new alternate signal stack so that it's not
 // reported as a leak. We don't make any attempt to remove our alt signal
 // stack if we remove our signal handlers; that can't be done reliably if
 // someone else is also trying to do the same thing.
 static stack_t OldAltStack;
-static void* NewAltStackPointer;
+LLVM_ATTRIBUTE_USED static void *NewAltStackPointer;
 
 static void CreateSigAltStack() {
   const size_t AltStackSize = MINSIGSTKSZ + 64 * 1024;
 
   // If we're executing on the alternate stack, or we already have an alternate
   // signal stack that we're happy with, there's nothing for us to do. Don't
   // reduce the size, some other part of the process might need a larger stack
   // than we do.

 #else
 static void CreateSigAltStack() {}
 #endif
 
 static void RegisterHandlers() { // Not signal-safe.
   // The mutex prevents other threads from registering handlers while we're
   // doing it. We also have to protect the handlers and their count because
   // a signal handler could fire while we're registeting handlers.
   static ManagedStatic<sys::SmartMutex<true>> SignalHandlerRegistrationMutex;
   sys::SmartScopedLock<true> Guard(*SignalHandlerRegistrationMutex);
 
   // If the handlers are already registered, we're done.
   if (NumRegisteredSignals.load() != 0)
     return;
 
   // Create an alternate stack for signal handling. This is necessary for us to
   // be able to reliably handle signals due to stack overflow.
static void RegisterHandlers() { // Not signal-safe.
   for (auto S : KillSigs)
     registerHandler(S, SignalKind::IsKill);
   if (OneShotPipeSignalFunction)
     registerHandler(SIGPIPE, SignalKind::IsKill);
   for (auto S : InfoSigs)
     registerHandler(S, SignalKind::IsInfo);
 }
 
 void sys::unregisterHandlers() {
   // Restore all of the signal handlers to how they were before we showed up.
   for (unsigned i = 0, e = NumRegisteredSignals.load(); i != e; ++i) {
     sigaction(RegisteredSignalInfo[i].SigNo,
               &RegisteredSignalInfo[i].SA, nullptr);
     --NumRegisteredSignals;
   }
 }
 
 /// Process the FilesToRemove list.
 static void RemoveFilesToRemove() {
   FileToRemoveList::removeAllFiles(FilesToRemove);
 }
 
 void sys::CleanupOnSignal(uintptr_t Context) {
   int Sig = (int)Context;
 
   if (llvm::is_contained(InfoSigs, Sig)) {
     InfoSignalHandler(Sig);
     return;
   }
 
   RemoveFilesToRemove();
 
   if (llvm::is_contained(IntSigs, Sig) || Sig == SIGPIPE)
     return;
 
   llvm::sys::RunSignalHandlers();
 }
 
 // The signal handler that runs.
 static 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.
sigprocmask(SIG_UNBLOCK, &SigMask, nullptr);
 
     if (Sig == SIGPIPE || IsIntSig) {
       raise(Sig); // Execute the default handler.
       return;
     }
   }
 
   // Otherwise if it is a fault (like SEGV) run any handler.
   llvm::sys::RunSignalHandlers();
 
 #ifdef __s390__
   // On S/390, certain signals are delivered with PSW Address pointing to
   // *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
 }
 
 static RETSIGTYPE InfoSignalHandler(int Sig) {
   SaveAndRestore<int> SaveErrnoDuringASignalHandler(errno);
   if (SignalHandlerFunctionType CurrentInfoFunction = InfoSignalFunction)
     CurrentInfoFunction();
 }
 
 void llvm::sys::RunInterruptHandlers() {
   RemoveFilesToRemove();
 }
 
 void llvm::sys::SetInterruptFunction(void (*IF)()) {
   InterruptFunction.exchange(IF);
   RegisterHandlers();
 }
 
 void llvm::sys::SetInfoSignalFunction(void (*Handler)()) {
   InfoSignalFunction.exchange(Handler);
   RegisterHandlers();
 }