6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-10-31 08:16:47 +00:00
Code Issues Projects Releases Wiki Activity

Support: Remove Alarm. It is unused (via local grep and google code search).

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@121160 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Michael J. Spencer
2010-12-07 18:41:59 +00:00
parent 12ccf67457
commit c20beb9cc5
5 changed files with 0 additions and 202 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
include/llvm/Support/Alarm.h
View File

@@ -1,51 +0,0 @@
//===- llvm/Support/Alarm.h - Alarm Generation 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 provides an operating system independent interface to alarm(2)
// type functionality. The Alarm class allows a one-shot alarm to be set up
// at some number of seconds in the future. When the alarm triggers, a method
// is called to process the event
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_SYSTEM_ALARM_H
#define LLVM_SYSTEM_ALARM_H
namespace llvm {
namespace sys {
/// This function registers an alarm to trigger some number of \p seconds in
/// the future. When that time arrives, the AlarmStatus function will begin
/// to return 1 instead of 0. The user must poll the status of the alarm by
/// making occasional calls to AlarmStatus. If the user sends an interrupt
/// signal, AlarmStatus will begin returning -1, even if the alarm event
/// occurred.
/// @returns nothing
void SetupAlarm(
unsigned seconds ///< Number of seconds in future when alarm arrives
);
/// This function terminates the alarm previously set up
/// @returns nothing
void TerminateAlarm();
/// This function acquires the status of the alarm.
/// @returns -1=cancelled, 0=untriggered, 1=triggered
int AlarmStatus();
/// Sleep for n seconds. Warning: mixing calls to Sleep() and other *Alarm
/// calls may be a bad idea on some platforms (source: Linux man page).
/// @returns nothing.
void Sleep(unsigned n);
} // End sys namespace
} // End llvm namespace
#endif

33
lib/Support/Alarm.cpp
View File

@@ -1,33 +0,0 @@
//===- Alarm.cpp - Alarm Generation 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 Alarm functionality
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/Alarm.h"
#include "llvm/Config/config.h"
namespace llvm {
using namespace sys;
//===----------------------------------------------------------------------===//
//=== WARNING: Implementation here must contain only TRULY operating system
//=== independent code.
//===----------------------------------------------------------------------===//
}
// Include the platform-specific parts of this class.
#ifdef LLVM_ON_UNIX
#include "Unix/Alarm.inc"
#endif
#ifdef LLVM_ON_WIN32
#include "Windows/Alarm.inc"
#endif

3
lib/Support/CMakeLists.txt
View File

@@ -54,7 +54,6 @@ add_llvm_library(LLVMSupport
regstrlcpy.c
# System
Alarm.cpp
Atomic.cpp
Disassembler.cpp
DynamicLibrary.cpp
@@ -75,7 +74,6 @@ add_llvm_library(LLVMSupport
Threading.cpp
TimeValue.cpp
Valgrind.cpp
Unix/Alarm.inc
Unix/Host.inc
Unix/Memory.inc
Unix/Mutex.inc
@@ -88,7 +86,6 @@ add_llvm_library(LLVMSupport
Unix/system_error.inc
Unix/ThreadLocal.inc
Unix/TimeValue.inc
Windows/Alarm.inc
Windows/DynamicLibrary.inc
Windows/Host.inc
Windows/Memory.inc

72
lib/Support/Unix/Alarm.inc
View File

@@ -1,72 +0,0 @@
//===-- Alarm.inc - Implement Unix Alarm 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 UNIX Alarm support.
//
//===----------------------------------------------------------------------===//
#include <signal.h>
#include <unistd.h>
#include <cassert>
using namespace llvm;
/// AlarmCancelled - This flag is set by the SIGINT signal handler if the
/// user presses CTRL-C.
static volatile bool AlarmCancelled = false;
/// AlarmTriggered - This flag is set by the SIGALRM signal handler if the
/// alarm was triggered.
static volatile bool AlarmTriggered = false;
/// NestedSOI - Sanity check. Alarms cannot be nested or run in parallel.
/// This ensures that they never do.
static bool NestedSOI = false;
static RETSIGTYPE SigIntHandler(int Sig) {
AlarmCancelled = true;
signal(SIGINT, SigIntHandler);
}
static RETSIGTYPE SigAlarmHandler(int Sig) {
AlarmTriggered = true;
}
static void (*OldSigIntHandler) (int);
void sys::SetupAlarm(unsigned seconds) {
assert(!NestedSOI && "sys::SetupAlarm calls cannot be nested!");
NestedSOI = true;
AlarmCancelled = false;
AlarmTriggered = false;
::signal(SIGALRM, SigAlarmHandler);
OldSigIntHandler = ::signal(SIGINT, SigIntHandler);
::alarm(seconds);
}
void sys::TerminateAlarm() {
assert(NestedSOI && "sys::TerminateAlarm called without sys::SetupAlarm!");
::alarm(0);
::signal(SIGALRM, SIG_DFL);
::signal(SIGINT, OldSigIntHandler);
AlarmCancelled = false;
AlarmTriggered = false;
NestedSOI = false;
}
int sys::AlarmStatus() {
if (AlarmCancelled)
return -1;
if (AlarmTriggered)
return 1;
return 0;
}
void sys::Sleep(unsigned n) {
::sleep(n);
}

43
lib/Support/Windows/Alarm.inc
View File

@@ -1,43 +0,0 @@
//===-- Alarm.inc - Implement Win32 Alarm 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 Win32 Alarm support.
//
//===----------------------------------------------------------------------===//
#include <cassert>
using namespace llvm;
/// NestedSOI - Sanity check. Alarms cannot be nested or run in parallel.
/// This ensures that they never do.
static bool NestedSOI = false;
void sys::SetupAlarm(unsigned seconds) {
assert(!NestedSOI && "sys::SetupAlarm calls cannot be nested!");
NestedSOI = true;
// FIXME: Implement for Win32
}
void sys::TerminateAlarm() {
assert(NestedSOI && "sys::TerminateAlarm called without sys::SetupAlarm!");
// FIXME: Implement for Win32
NestedSOI = false;
}
int sys::AlarmStatus() {
// FIXME: Implement for Win32
return 0;
}
// Don't pull in all of the Windows headers.
extern "C" void __stdcall Sleep(unsigned long);
void sys::Sleep(unsigned n) {
::Sleep(n*1000);
}