// base flags to set. Inidividual flag arrays are terminated by -1.
extern const Flags *compoundFlags[];
-/* namespace Trace */ }
+} // namespace Trace
#endif // __BASE_TRACE_FLAGS_HH__
''')
${{len(data)}},
${{len(marshalled)}});
-/* namespace */ }
+} // anonymous namespace
''')
code.write(str(target[0]))
return 0;
}
-}//namespace AlphaISA
+} // namespace AlphaISA
#endif
UNSERIALIZE_SCALAR(valid);
}
-} //namespace AlphaISA
+} // namespace AlphaISA
translation->finish(translateAtomic(req, tc, mode), req, tc, mode);
}
-/* end namespace AlphaISA */ }
+} // namespace AlphaISA
AlphaISA::TLB *
AlphaTLBParams::create()
return new Reset();
}
-} // ArmISA namespace
+} // namespace ArmISA
#endif // __ARM_FAULTS_HH__
#include "arch/arm/types.hh"
#include "base/types.hh"
-namespace LittleEndianGuest {};
+namespace LittleEndianGuest {}
#define TARGET_ARM
INT_FIQ,
NumInterruptTypes
};
-};
+} // namespace ArmISA
using namespace ArmISA;
{}
};
-} /* end namespace ArmISA::Kernel */
-} /* end namespace ArmISA */
+} // namespace ArmISA::Kernel
+} // namespace ArmISA
#endif // __ARCH_ARM_KERNEL_STATS_HH__
}
}
-} /* namespace Trace */
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
void check(NativeTraceRecord *record);
};
-} /* namespace Trace */
+} // namespace Trace
#endif // __ARCH_ARM_NATIVETRACE_HH__
inline void invalidateMiscReg() { miscRegValid = false; }
};
-/* namespace ArmISA */ }
+} // namespace ArmISA
#endif // __ARCH_ARM_TLB_HH__
void writeDSPControl(uint32_t *dspctl, uint32_t value, uint32_t mask);
uint32_t readDSPControl(uint32_t *dspctl, uint32_t mask);
-} /* namespace MipsISA */
+} // namespace MipsISA
#endif // __ARCH_MIPS_DSP_HH__
StaticInstPtr inst = StaticInst::nullStaticInstPtr);
};
-} // MipsISA namespace
+} // namespace MipsISA
#endif // __MIPS_FAULTS_HH__
#include "base/types.hh"
#include "config/full_system.hh"
-namespace LittleEndianGuest {};
+namespace LittleEndianGuest {}
class StaticInstPtr;
// Memory accesses cannot be unaligned
const bool HasUnalignedMemAcc = false;
-};
+} // namespace MipsISA
#endif // __ARCH_MIPS_ISA_TRAITS_HH__
};
-} /* end namespace MipsISA::Kernel */
-} /* end namespace MipsISA */
+} // namespace MipsISA::Kernel
+} // namespace MipsISA
#endif // __ARCH_MIPS_KERNEL_STATS_HH__
}
};
-/* namespace Linux */ }
+} // namespace Linux
#endif // __ARCH_MIPS_LINUX_LINUX_THREADINFO_HH__
return new MachineCheckFault();
}
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_FAULTS_HH__
std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_BRANCH_HH__
std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_CONDITION_HH__
std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_FLOATING_HH__
std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_INTEGER_HH__
std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_MEM_HH__
std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_MISC_HH__
}
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif //__ARCH_POWER_INSTS_STATICINST_HH__
}
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_ISA_HH__
#include "arch/power/types.hh"
#include "base/types.hh"
-namespace BigEndianGuest {};
+namespace BigEndianGuest {}
class StaticInstPtr;
// Memory accesses can be unaligned
const bool HasUnalignedMemAcc = true;
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_ISA_TRAITS_HH__
return true;
}
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_LOCKED_MEM_HH__
using ::MicrocodeRom;
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_MICROCODE_ROM_HH__
Bitfield<2,1> rn;
EndBitUnion(Fpscr)
-}; // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_MISCREGS_HH__
panic("No implementation for handleIprWrite in POWER\n");
}
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_MMAPED_IPR_HH__
UNSERIALIZE_SCALAR(OffsetMask);
}
-} // PowerISA namespace
+} // namespace PowerISA
void unserialize(Checkpoint *cp, const std::string §ion);
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_PAGETABLE_H__
}
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_PREDECODER_HH__
INTREG_RSV_ADDR
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_REGISTERS_HH__
}
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif /* __ARCH_POWER_REMOTE_GDB_H__ */
return true;
}
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_STACKTRACE_HH__
void regStats();
};
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_TLB_HH__
};
};
-} // __hash_namespace namespace
+} // namespace __hash_namespace
#endif // __ARCH_POWER_TYPES_HH__
}
-} // PowerISA namespace
+} // namespace PowerISA
pc.advance();
}
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_UTILITY_HH__
return (a & PteMask) << PteShift;
}
-} // PowerISA namespace
+} // namespace PowerISA
#endif // __ARCH_POWER_VTOPHYS_HH__
}
-} // SparcISA namespace
+} // namespace SparcISA
#endif // __SPARC_FAULTS_HH__
{}
};
-} /* end namespace AlphaISA::Kernel */
-} /* end namespace AlphaISA */
+} // namespace AlphaISA::Kernel
+} // namespace AlphaISA
#endif // __ARCH_SPARC_KERNEL_STATS_HH__
checkReg("ccr", regVal, realRegVal);
}
-} /* namespace Trace */
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
void check(NativeTraceRecord *record);
};
-} /* namespace Trace */
+} // namespace Trace
#endif // __CPU_NATIVETRACE_HH__
UNSERIALIZE_SCALAR(sfar);
}
-/* end namespace SparcISA */ }
+} // namespace SparcISA
SparcISA::TLB *
SparcTLBParams::create()
return pte.translate(addr);
}
-} /* namespace SparcISA */
+} // namespace SparcISA
}
return true;
}
-} //namespace X86ISA
+} // namespace X86ISA
checkXMM(15, mState.xmm, nState.xmm);
}
-} /* namespace Trace */
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
void check(NativeTraceRecord *record);
};
-} /* namespace Trace */
+} // namespace Trace
#endif // __ARCH_X86_NATIVETRACE_HH__
typedef uint16_t RegIndex;
-}; // namespace X86ISA
+} // namespace X86ISA
#endif // __ARCH_X86_REGFILE_HH__
{
}
-/* end namespace X86ISA */ }
+} // namespace X86ISA
X86ISA::TLB *
X86TLBParams::create()
}
-} //namespace X86_ISA
+} // namespace X86_ISA
stream.precision(saved_precision);
}
-/* end namespace cp */ }
+} // namespace cp
void end_args();
};
-/* end namespace cp */ }
+} // namespace cp
typedef VarArgs::List<cp::Print> CPrintfArgsList;
return (__stl_hash_string(r.first.c_str())) ^ r.second;
}
};
-/* namespace __hash_namespace */ }
+} // namespace __hash_namespace
#endif // __HASHMAP_HH__
}
-/* namespace Net */ }
+} // namespace Net
int hsplit(const EthPacketPtr &ptr);
-/* namespace Net */ }
+} // namespace Net
#endif // __BASE_INET_HH__
}
-/* namespace MySQL */ }
+} // namespace MySQL
}
#endif
-/* namespace MySQL */ }
+} // namespace MySQL
#endif // __BASE_MYSQL_HH__
resetQueue.add(cb);
}
-/* namespace Stats */ }
+} // namespace Stats
std::list<Info *> &statsList();
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATISTICS_HH__
};
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_INFO_HH__
return true;
}
-/* end namespace Stats */ }
+} // namespace Stats
}
#endif
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_MYSQL_HH__
uint16_t run() const { return run_id; }
};
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_MYSQL_RUN_HH__
}
}
-/* namespace Stats */ }
+} // namespace Stats
void
debugDumpStats()
virtual bool valid() const = 0;
};
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_OUTPUT_HH__
return true;
}
-/* namespace Stats */ }
+} // namespace Stats
bool initText(const std::string &filename, bool desc);
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_TEXT_HH__
typedef unsigned int size_type;
typedef unsigned int off_type;
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_TYPES_HH__
Visit::~Visit()
{}
-/* namespace Stats */ }
+} // namespace Stats
virtual void visit(const FormulaInfo &info) = 0;
};
-/* namespace Stats */ }
+} // namespace Stats
#endif // __BASE_STATS_VISIT_HH__
return out;
}
-/* namespace stl_helpers */ }
-/* namespace m5 */ }
+} // namespace stl_helpers
+} // namespace m5
#endif // __BASE_STL_HELPERS_HH__
}
}
-/* namespace Trace */ }
+} // namespace Trace
// add a set of functions that can easily be invoked from gdb
CPRINTF_DECLARATION);
void dump(Tick when, const std::string &name, const void *data, int len);
-/* namespace Trace */ }
+} // namespace Trace
// This silly little class allows us to wrap a string in a functor
// object so that we can give a name() that DPRINTF will like
}
};
-/* end namespace VarArgs */ }
+} // namespace VarArgs
#endif /* __BASE_VARARGS_HH__ */
}
}
-/* namespace Trace */ }
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
}
};
-/* namespace Trace */ }
+} // namespace Trace
#endif // __CPU_EXETRACE_HH__
return new InOrderTraceRecord(ThePipeline::NumStages, true, tc, _pc);
}
-/* namespace Trace */ }
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
const StaticInstPtr macroStaticInst = NULL);
};
-/* namespace Trace */ }
+} // namespace Trace
#endif // __CPU_INORDER_INORDER_TRACE_HH__
outs << endl;
}
-/* namespace Trace */ }
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
}
};
-/* namespace Trace */ }
+} // namespace Trace
#endif // __CPU_INTELTRACE_HH__
} // if not microop
}
-/* namespace Trace */ }
+} // namespace Trace
////////////////////////////////////////////////////////////////////////
//
}
};
-/* namespace Trace */ }
+} // namespace Trace
#endif // __CPU_LEGIONTRACE_HH__
parent->check(this);
}
-} /* namespace Trace */
+} // namespace Trace
check(NativeTraceRecord *record) = 0;
};
-} /* namespace Trace */
+} // namespace Trace
#endif // __CPU_NATIVETRACE_HH__
};
-} //namespace CopyEngineReg
+} // namespace CopyEngineReg
UNSERIALIZE_SCALAR(sw_fw_sync);
}
};
-} // iGbReg namespace
+} // namespace iGbReg
}
-/* namespace Sinic */ }
+} // namespace Sinic
Sinic::Device *
SinicParams::create()
virtual void sendDone() { dev->transferDone(); }
};
-/* namespace Sinic */ }
+} // namespace Sinic
#endif // __DEV_SINIC_HH__
const char *name;
};
-/* namespace Regs */ }
+} // namespace Regs
inline const Regs::Info&
regInfo(Addr daddr)
return true;
}
-/* namespace Sinic */ }
+} // namespace Sinic
#endif // __DEV_SINICREG_HH__
Tick write(PacketPtr pkt);
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_CMOS_HH__
Tick write(PacketPtr pkt);
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_I8042_HH__
void registerLocalApic(int id, Interrupts *localApic);
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_SOUTH_BRIDGE_I8254_HH__
Tick write(PacketPtr pkt);
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_I8237_HH__
}
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_SOUTH_BRIDGE_I8254_HH__
int getVector();
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_I8259_HH__
}
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_INTDEV_HH__
Tick write(PacketPtr pkt);
};
-}; // namespace X86ISA
+} // namespace X86ISA
#endif //__DEV_X86_SPEAKER_HH__
UNSERIALIZE_SCALAR(iplLastTick);
}
-/* end namespace Kernel */ }
+} // namespace Kernel
virtual void unserialize(Checkpoint *cp, const std::string §ion);
};
-/* end namespace Kernel */ }
+} // namespace Kernel
#endif // __KERNEL_STATS_HH__
return (size_t)s.getAddress();
}
};
-/* namespace __hash_namespace */ }
+} // namespace __hash_namespace
namespace std {
template <> struct equal_to<Address>
return s1 == s2;
}
};
-/* namespace std */ }
+} // namespace std
#endif // __MEM_RUBY_COMMON_ADDRESS_HH__
code('{};')
for ns in reversed(namespaces):
- code('/* namespace $ns */ }')
+ code('} // namespace $ns')
def public_value(key, value):
return key.startswith('_') or \
code('namespace $ns {')
code('class $0;', class_path[-1])
for ns in reversed(class_path[:-1]):
- code('/* namespace $ns */ }')
+ code('} // namespace $ns')
code()
for param in params:
code.dedent(2)
code('''
};
-/* namespace Enums */ }
+} // namespace Enums
''')
# Base class for enum types.
std::list<Info *> &statsList();
-/* namespace Stats */ }
+} // namespace Stats
double kHz;
double MHz;
double GHZ;
-/* namespace Float */ }
+} // namespace Float
namespace Int {
Tick s;
Tick us;
Tick ns;
Tick ps;
-/* namespace Float */ }
+} // namespace Float
-/* namespace SimClock */ }
+} // namespace SimClock
void
setClockFrequency(Tick ticksPerSecond)
extern double kHz;
extern double MHz;
extern double GHZ;
-/* namespace Float */ }
+} // namespace Float
namespace Int {
extern Tick s;
extern Tick us;
extern Tick ns;
extern Tick ps;
-/* namespace Int */ }
-/* namespace SimClock */ }
+} // namespace Int
+} // namespace SimClock
void setClockFrequency(Tick ticksPerSecond);
-}; // namespace Trace
+} // namespace Trace
#endif // __INSTRECORD_HH__
exitSimLoop("switchcpu");
}
-/* namespace PseudoInst */ }
+} // namespace PseudoInst
void debugbreak(ThreadContext *tc);
void switchcpu(ThreadContext *tc);
-/* namespace PseudoInst */ }
+} // namespace PseudoInst
mainEventQueue.schedule(event, when);
}
-/* namespace Stats */ }
+} // namespace Stats
void initSimStats();
void StatEvent(bool dump, bool reset, Tick when = curTick, Tick repeat = 0);
-/* namespace Stats */ }
+} // namespace Stats
#endif // __SIM_STAT_CONTROL_HH__
projects / gem5.git / commitdiff