// initPacketizerState - perform initialization before packetizing
// an instruction. This function is supposed to be overrided by
// the target dependent packetizer.
- virtual void initPacketizerState(void) { return; }
+ virtual void initPacketizerState() { return; }
// ignorePseudoInstruction - Ignore bundling of pseudo instructions.
virtual bool ignorePseudoInstruction(MachineInstr *I,
/// getCurrentCallSite - Get the call site currently being processed, if any.
/// return zero if none.
- unsigned getCurrentCallSite(void) { return CurCallSite; }
+ unsigned getCurrentCallSite() { return CurCallSite; }
/// getTypeInfos - Return a reference to the C++ typeinfo for the current
/// function.
typedef int (*op_unload_native_code_ptr_t)(op_agent_t, uint64_t);
// Also used for op_minor_version function which has the same signature
- typedef int (*op_major_version_ptr_t)(void);
+ typedef int (*op_major_version_ptr_t)();
// This is not a part of the opagent API, but is useful nonetheless
- typedef bool (*IsOProfileRunningPtrT)(void);
+ typedef bool (*IsOProfileRunningPtrT)();
op_agent_t Agent;
size_t num_entries,
struct debug_line_info const* info);
int op_unload_native_code(uint64_t addr);
- int op_major_version(void);
- int op_minor_version(void);
+ int op_major_version();
+ int op_minor_version();
// Returns true if the oprofiled process is running, the opagent library is
// loaded and a connection to the agent has been established, and false
/// doInitialization - Virtual method overridden by subclasses to do
/// any necessary initialization.
///
- virtual bool doInitialization(void) { return false; }
+ virtual bool doInitialization() { return false; }
/// runOnModule - Virtual method overriden by subclasses to process the module
/// being operated on.
/// doFinalization - Virtual method overriden by subclasses to do any post
/// processing needed after all passes have run.
///
- virtual bool doFinalization(void) { return false; }
+ virtual bool doFinalization() { return false; }
virtual void assignPassManager(PMStack &PMS,
PassManagerType T);
/// flushBuffer - Dump the contents of the buffer to Stream.
///
- void flushBuffer(void) {
+ void flushBuffer() {
if (Filled)
// Write the older portion of the buffer.
TheStream->write(Cur, BufferArray + BufferSize - Cur);
/// flushBufferWithBanner - Force output of the buffer along with
/// a small header.
///
- void flushBufferWithBanner(void);
+ void flushBufferWithBanner();
private:
/// releaseStream - Delete the held stream if needed. Otherwise,
}
-MCSymbol *ARMAsmPrinter::GetARMSJLJEHLabel(void) const {
+MCSymbol *ARMAsmPrinter::GetARMSJLJEHLabel() const {
SmallString<60> Name;
raw_svector_ostream(Name) << MAI->getPrivateGlobalPrefix() << "SJLJEH"
<< getFunctionNumber();
MCOperand GetSymbolRef(const MachineOperand &MO, const MCSymbol *Symbol);
MCSymbol *GetARMJTIPICJumpTableLabel2(unsigned uid, unsigned uid2) const;
- MCSymbol *GetARMSJLJEHLabel(void) const;
+ MCSymbol *GetARMSJLJEHLabel() const;
MCSymbol *GetARMGVSymbol(const GlobalValue *GV);
public:
explicit ARMTargetLowering(TargetMachine &TM);
- virtual unsigned getJumpTableEncoding(void) const;
+ virtual unsigned getJumpTableEncoding() const;
virtual SDValue LowerOperation(SDValue Op, SelectionDAG &DAG) const;
PM.add(createGlobalDCEPass());
}
-LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate(void) {
+LLVMPassManagerBuilderRef LLVMPassManagerBuilderCreate() {
PassManagerBuilder *PMB = new PassManagerBuilder();
return wrap(PMB);
}
next = seed;
}
- int rand(void) {
+ int rand() {
next = next * 1103515245 + 12345;
return (unsigned int)(next / 65536) % 32768;
}
/// doInitialization - Run all of the initializers for the module passes.
///
- bool doInitialization(void);
+ bool doInitialization();
/// doFinalization - Run all of the finalizers for the module passes.
///
- bool doFinalization(void);
+ bool doFinalization();
/// Pass Manager itself does not invalidate any analysis info.
void getAnalysisUsage(AnalysisUsage &Info) const {
/// doInitialization - Run all of the initializers for the module passes.
///
- bool doInitialization(void);
+ bool doInitialization();
/// doFinalization - Run all of the finalizers for the module passes.
///
- bool doFinalization(void);
+ bool doFinalization();
/// Pass Manager itself does not invalidate any analysis info.
void getAnalysisUsage(AnalysisUsage &Info) const {
/// Run all of the initializers for the module passes.
///
-bool MPPassManager::doInitialization(void) {
+bool MPPassManager::doInitialization() {
bool Changed = false;
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
/// Run all of the finalizers for the module passes.
///
-bool MPPassManager::doFinalization(void) {
+bool MPPassManager::doFinalization() {
bool Changed = false;
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index)
//===----------------------------------------------------------------------===//
// PassManagerImpl implementation
-bool PassManagerImpl::doInitialization(void) {
+bool PassManagerImpl::doInitialization() {
bool Changed = false;
for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
return Changed;
}
-bool PassManagerImpl::doFinalization(void) {
+bool PassManagerImpl::doFinalization() {
bool Changed = false;
for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)