protected:
const BucketT *Ptr, *End;
public:
- DenseMapIterator(void) : Ptr(0), End(0) {}
+ DenseMapIterator() : Ptr(0), End(0) {}
DenseMapIterator(const BucketT *Pos, const BucketT *E) : Ptr(Pos), End(E) {
AdvancePastEmptyBuckets();
template<typename KeyT, typename ValueT, typename KeyInfoT, typename ValueInfoT>
class DenseMapConstIterator : public DenseMapIterator<KeyT, ValueT, KeyInfoT> {
public:
- DenseMapConstIterator(void) : DenseMapIterator<KeyT, ValueT, KeyInfoT>() {}
+ DenseMapConstIterator() : DenseMapIterator<KeyT, ValueT, KeyInfoT>() {}
DenseMapConstIterator(const std::pair<KeyT, ValueT> *Pos,
const std::pair<KeyT, ValueT> *E)
: DenseMapIterator<KeyT, ValueT, KeyInfoT>(Pos, E) {
/// setMemoryWritable - When code generation is in progress,
/// the code pages may need permissions changed.
- virtual void setMemoryWritable(void) = 0;
+ virtual void setMemoryWritable() = 0;
/// setMemoryExecutable - When code generation is done and we're ready to
/// start execution, the code pages may need permissions changed.
- virtual void setMemoryExecutable(void) = 0;
+ virtual void setMemoryExecutable() = 0;
/// setPoisonMemory - Setting this flag to true makes the memory manager
/// garbage values over freed memory. This is useful for testing and
/// Restores default error handling behaviour.
/// This must not be called between llvm_start_multithreaded() and
/// llvm_stop_multithreaded().
- void llvm_remove_error_handler(void);
+ void llvm_remove_error_handler();
/// Reports a serious error, calling any installed error handler.
/// If no error handler is installed the default is to print the message to
void error_detected() { Error = true; }
typedef char * iterator;
- iterator begin(void) { return OutBufStart; }
- iterator end(void) { return OutBufCur; }
+ iterator begin() { return OutBufStart; }
+ iterator end() { return OutBufCur; }
//===--------------------------------------------------------------------===//
// Private Interface
// important to make the is_class<T>::value idiom zero cost. it
// evaluates to a constant 1 or 0 depending on whether the
// parameter T is a class or not (respectively).
- template<typename T> char is_class_helper(void(T::*)(void));
+ template<typename T> char is_class_helper(void(T::*)());
template<typename T> double is_class_helper(...);
}
/// This function returns true, if there is possible to use some external
/// disassembler library. False otherwise.
-bool hasDisassembler(void);
+bool hasDisassembler();
/// This function provides some "glue" code to call external disassembler
/// libraries.
static std::map<std::string, ExFunc> FuncNames;
#ifdef USE_LIBFFI
-typedef void (*RawFunc)(void);
+typedef void (*RawFunc)();
static ManagedStatic<std::map<const Function *, RawFunc> > RawFunctions;
#endif
}
// jit_atexit - Used to intercept the "atexit" library call.
-static int jit_atexit(void (*Fn)(void)) {
+static int jit_atexit(void (*Fn)()) {
AtExitHandlers.push_back(Fn); // Take note of atexit handler...
return 0; // Always successful
}
if (DwarfExceptionHandling) DE->setModuleInfo(Info);
}
- void setMemoryExecutable(void) {
+ void setMemoryExecutable() {
MemMgr->setMemoryExecutable();
}
- JITMemoryManager *getMemMgr(void) const { return MemMgr; }
+ JITMemoryManager *getMemMgr() const { return MemMgr; }
private:
void *getPointerToGlobal(GlobalValue *GV, void *Reference, bool NoNeedStub);
/// setMemoryWritable - When code generation is in progress,
/// the code pages may need permissions changed.
- void setMemoryWritable(void)
+ void setMemoryWritable()
{
for (unsigned i = 0, e = CodeSlabs.size(); i != e; ++i)
sys::Memory::setWritable(CodeSlabs[i]);
}
/// setMemoryExecutable - When code generation is done and we're ready to
/// start execution, the code pages may need permissions changed.
- void setMemoryExecutable(void)
+ void setMemoryExecutable()
{
for (unsigned i = 0, e = CodeSlabs.size(); i != e; ++i)
sys::Memory::setExecutable(CodeSlabs[i]);
ErrorHandlerUserData = user_data;
}
-void llvm_remove_error_handler(void) {
+void llvm_remove_error_handler() {
ErrorHandler = 0;
}
using namespace llvm;
-bool llvm::sys::hasDisassembler(void)
+bool llvm::sys::hasDisassembler()
{
#if defined (__i386__) || defined (__amd64__) || defined (__x86_64__)
// We have option to enable udis86 library.
// control over register saving and restoring.
extern "C" {
#if defined(__arm__)
- void ARMCompilationCallback(void);
+ void ARMCompilationCallback();
asm(
".text\n"
".align 2\n"
void printSavedRegsBitmask(MachineFunction &MF);
void printHex32(unsigned int Value);
- const char *emitCurrentABIString(void);
+ const char *emitCurrentABIString();
void emitFunctionStart(MachineFunction &MF);
void emitFunctionEnd(MachineFunction &MF);
void emitFrameDirective(MachineFunction &MF);
return 0; // Not reached
}
-unsigned MipsRegisterInfo::getPICCallReg(void) { return Mips::T9; }
+unsigned MipsRegisterInfo::getPICCallReg() { return Mips::T9; }
//===----------------------------------------------------------------------===//
// Callee Saved Registers methods
static unsigned getRegisterNumbering(unsigned RegEnum);
/// Get PIC indirect call register
- static unsigned getPICCallReg(void);
+ static unsigned getPICCallReg();
/// Adjust the Mips stack frame.
void adjustMipsStackFrame(MachineFunction &MF) const;
/// printLibcallDecls - print the extern declarations for compiler
/// intrinsics.
///
-void PIC16AsmPrinter::printLibcallDecls(void) {
+void PIC16AsmPrinter::printLibcallDecls() {
// If no libcalls used, return.
if (LibcallDecls.empty()) return;
void EmitRemainingAutos ();
void EmitRomData (Module &M);
void EmitFunctionFrame(MachineFunction &MF);
- void printLibcallDecls(void);
+ void printLibcallDecls();
protected:
bool doInitialization(Module &M);
bool doFinalization(Module &M);
using namespace llvm;
-XCoreInstrInfo::XCoreInstrInfo(void)
+XCoreInstrInfo::XCoreInstrInfo()
: TargetInstrInfoImpl(XCoreInsts, array_lengthof(XCoreInsts)),
RI(*this) {
}
class XCoreInstrInfo : public TargetInstrInfoImpl {
const XCoreRegisterInfo RI;
public:
- XCoreInstrInfo(void);
+ XCoreInstrInfo();
/// getRegisterInfo - TargetInstrInfo is a superset of MRegister info. As
/// such, whenever a client has an instance of instruction info, it should
// Returns the platform specific directory separator via #ifdefs.
// FIXME: This currently work on linux and windows only. It does not
// work on other unices.
-static std::string GetDirSeparator(void) {
+static std::string GetDirSeparator() {
#ifdef __linux__
return "/";
#else
namespace hooks {
// Get the dir where c16 executables reside.
-std::string GetBinDir (void) {
+std::string GetBinDir() {
// Construct a Path object from the program name.
void *P = (void*) (intptr_t) GetBinDir;
sys::Path ProgramFullPath
}
// Get the Top-level Installation dir for c16.
-std::string GetInstallDir (void) {
+std::string GetInstallDir() {
sys::Path BinDirPath = sys::Path(GetBinDir());
// Go one more level up to get the install dir.
}
// Get the dir where the c16 header files reside.
-std::string GetStdHeadersDir (void) {
+std::string GetStdHeadersDir() {
return GetInstallDir() + "include";
}
// Get the dir where the assembler header files reside.
-std::string GetStdAsmHeadersDir (void) {
+std::string GetStdAsmHeadersDir() {
return GetInstallDir() + "inc";
}
// Get the dir where the linker scripts reside.
-std::string GetStdLinkerScriptsDir (void) {
+std::string GetStdLinkerScriptsDir() {
return GetInstallDir() + "lkr";
}
// Get the dir where startup code, intrinsics and lib reside.
-std::string GetStdLibsDir (void) {
+std::string GetStdLibsDir() {
return GetInstallDir() + "lib";
}
}
// Clone - Clone this operator, replacing arguments with the new list
virtual OpInit *clone(std::vector<Init *> &Operands) = 0;
- virtual int getNumOperands(void) const = 0;
+ virtual int getNumOperands() const = 0;
virtual Init *getOperand(int i) = 0;
// Fold - If possible, fold this to a simpler init. Return this if not
return new UnOpInit(getOpcode(), *Operands.begin(), getType());
}
- int getNumOperands(void) const { return 1; }
+ int getNumOperands() const { return 1; }
Init *getOperand(int i) {
assert(i == 0 && "Invalid operand id for unary operator");
return getOperand();
return new BinOpInit(getOpcode(), Operands[0], Operands[1], getType());
}
- int getNumOperands(void) const { return 2; }
+ int getNumOperands() const { return 2; }
Init *getOperand(int i) {
assert((i == 0 || i == 1) && "Invalid operand id for binary operator");
if (i == 0) {
getType());
}
- int getNumOperands(void) const { return 3; }
+ int getNumOperands() const { return 3; }
Init *getOperand(int i) {
assert((i == 0 || i == 1 || i == 2) &&
"Invalid operand id for ternary operator");
///
/// OperatorType ::= '<' Type '>'
///
-RecTy *TGParser::ParseOperatorType(void) {
+RecTy *TGParser::ParseOperatorType() {
RecTy *Type = 0;
if (Lex.getCode() != tgtok::less) {
OSDN Git Service
