From 5762f66288e918bb4e585bd02dbaa8a37f140c91 Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Mon, 13 Dec 2021 15:20:56 +0800 Subject: [PATCH 001/658] systemc: Add -Wno-free-nonheap-object for building scheduler.cc GCC11 introduces a new warning, free-nonheap-object, which would check if the code potentially calls delete with a nonheap object. The scheduler is a global object, and its events members fall to this case. Here's a simplified example. https://godbolt.org/z/q6GqEfETa We think this is a false positive warning, since we set auto delete to false in the event constructor. To avoid performance penalty, we want to keep current implementation. As the result, we disable the warning in the SConscript. Change-Id: I606ebfdec0af7c78d7bbb336faa1f587caa62855 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54064 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/systemc/core/SConscript | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/systemc/core/SConscript b/src/systemc/core/SConscript index 8805e9b83e..45bad4f352 100644 --- a/src/systemc/core/SConscript +++ b/src/systemc/core/SConscript @@ -39,7 +39,6 @@ if env['USE_SYSTEMC']: Source('object.cc') Source('port.cc') Source('process.cc') - Source('scheduler.cc') Source('sched_event.cc') Source('sensitivity.cc') Source('time.cc') @@ -72,3 +71,11 @@ if env['USE_SYSTEMC']: append['CCFLAGS'] = [flag] break Source('sc_time_python.cc', append=append) + + # Disable the false positive warning for the event members of the scheduler. + with gem5_scons.Configure(main) as conf: + flag = '-Wno-free-nonheap-object' + append = {} + if conf.CheckCxxFlag(flag, autoadd=False): + append['CCFLAGS'] = [flag] + Source('scheduler.cc', append=append) From 2be95c4470741567954103c732bcf957f1959c4f Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 11 Dec 2021 21:13:04 -0800 Subject: [PATCH 002/658] arch,sim-se: Handle syscall retry/suppression in the syscall desc. Rather than make each ISA include boilerplate to ignore a SyscallReturn's value when it's marked as suppressed or needing a retry, put that code into the SyscallDesc::doSyscall method instead. That has two benefits. First, it removes a decent amount of code duplication which is nice from a maintenance perspective. Second, it puts the SyscallDesc in charge of figuring out what to do once a system call implementation finishes. That will let it schedule a retry of the system call for instance, without worrying about what the ISA is doing with the SyscallReturn behind its back. Jira Issue: https://gem5.atlassian.net/browse/GEM5-1123 Change-Id: I3732a98c8e0d0b2b94d61313960aa0782c0b971f Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54023 Maintainer: Gabe Black Tested-by: kokoro Reviewed-by: Giacomo Travaglini --- src/arch/arm/freebsd/se_workload.hh | 3 --- src/arch/arm/linux/se_workload.hh | 3 --- src/arch/mips/se_workload.hh | 3 --- src/arch/power/se_workload.hh | 3 --- src/arch/riscv/se_workload.hh | 3 --- src/arch/sparc/se_workload.hh | 3 --- src/arch/x86/linux/linux.hh | 3 --- src/sim/syscall_desc.cc | 8 +++++--- src/sim/syscall_desc.hh | 2 +- 9 files changed, 6 insertions(+), 25 deletions(-) diff --git a/src/arch/arm/freebsd/se_workload.hh b/src/arch/arm/freebsd/se_workload.hh index 8069bd2563..4ec50907dc 100644 --- a/src/arch/arm/freebsd/se_workload.hh +++ b/src/arch/arm/freebsd/se_workload.hh @@ -82,9 +82,6 @@ struct ResultsetCCReg(ArmISA::CCREG_C, 0); diff --git a/src/arch/arm/linux/se_workload.hh b/src/arch/arm/linux/se_workload.hh index b22688fb8e..f0af647251 100644 --- a/src/arch/arm/linux/se_workload.hh +++ b/src/arch/arm/linux/se_workload.hh @@ -74,9 +74,6 @@ struct ResultsetIntReg(ArmISA::ReturnValueReg, ret.encodedValue()); if (ret.count() > 1) tc->setIntReg(ArmISA::SyscallPseudoReturnReg, ret.value2()); diff --git a/src/arch/mips/se_workload.hh b/src/arch/mips/se_workload.hh index 178093d837..c10ceb031a 100644 --- a/src/arch/mips/se_workload.hh +++ b/src/arch/mips/se_workload.hh @@ -77,9 +77,6 @@ struct Result static void store(ThreadContext *tc, const SyscallReturn &ret) { - if (ret.suppressed() || ret.needsRetry()) - return; - if (ret.successful()) { // no error tc->setIntReg(MipsISA::SyscallSuccessReg, 0); diff --git a/src/arch/power/se_workload.hh b/src/arch/power/se_workload.hh index 2b6279529d..c351d6560d 100644 --- a/src/arch/power/se_workload.hh +++ b/src/arch/power/se_workload.hh @@ -77,9 +77,6 @@ struct Result static void store(ThreadContext *tc, const SyscallReturn &ret) { - if (ret.suppressed() || ret.needsRetry()) - return; - PowerISA::Cr cr = tc->readIntReg(PowerISA::INTREG_CR); if (ret.successful()) { cr.cr0.so = 0; diff --git a/src/arch/riscv/se_workload.hh b/src/arch/riscv/se_workload.hh index 1f8a0677b8..484803e3c7 100644 --- a/src/arch/riscv/se_workload.hh +++ b/src/arch/riscv/se_workload.hh @@ -75,9 +75,6 @@ struct Result static void store(ThreadContext *tc, const SyscallReturn &ret) { - if (ret.suppressed() || ret.needsRetry()) - return; - if (ret.successful()) { // no error tc->setIntReg(RiscvISA::ReturnValueReg, ret.returnValue()); diff --git a/src/arch/sparc/se_workload.hh b/src/arch/sparc/se_workload.hh index 6d034f7ced..18988fe66d 100644 --- a/src/arch/sparc/se_workload.hh +++ b/src/arch/sparc/se_workload.hh @@ -89,9 +89,6 @@ struct ResultsetIntReg(X86ISA::INTREG_RAX, ret.encodedValue()); } }; diff --git a/src/sim/syscall_desc.cc b/src/sim/syscall_desc.cc index 74991020b7..7427f41990 100644 --- a/src/sim/syscall_desc.cc +++ b/src/sim/syscall_desc.cc @@ -44,12 +44,14 @@ SyscallDesc::doSyscall(ThreadContext *tc) SyscallReturn retval = executor(this, tc); - if (retval.needsRetry()) + if (retval.needsRetry()) { DPRINTF_SYSCALL(Base, "Needs retry.\n", name()); - else if (retval.suppressed()) + } else if (retval.suppressed()) { DPRINTF_SYSCALL(Base, "No return value.\n", name()); - else + } else { + returnInto(tc, retval); DPRINTF_SYSCALL(Base, "Returned %d.\n", retval.encodedValue()); + } } } // namespace gem5 diff --git a/src/sim/syscall_desc.hh b/src/sim/syscall_desc.hh index 0740632705..6ded904097 100644 --- a/src/sim/syscall_desc.hh +++ b/src/sim/syscall_desc.hh @@ -141,7 +141,7 @@ class SyscallDescABI : public SyscallDesc // Use invokeSimcall to gather the other arguments based on the // given ABI and pass them to the syscall implementation. - return invokeSimcall(tc, + return invokeSimcall(tc, std::function( partial)); }; From a923674d629270203730e473d5136f37f752e972 Mon Sep 17 00:00:00 2001 From: Giacomo Travaglini Date: Sun, 12 Dec 2021 14:59:27 +0000 Subject: [PATCH 003/658] arch-arm: Do not squash table walks if translation is partial As partial translations have been introduced we cannot just rely on checking if there is a valid translation when looking for translations to squash. The translation has to be complete as well. This is fixing realview-o3-checker regression Change-Id: I1ad42bd6172207a72f53b7a843c323c0eea88f06 Signed-off-by: Giacomo Travaglini Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54043 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro (cherry picked from commit ec891adca9c9430b178562ad498c1699026e5906) Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54103 Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce --- src/arch/arm/table_walker.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/arch/arm/table_walker.cc b/src/arch/arm/table_walker.cc index f94e7652ef..c7b8c3c0c3 100644 --- a/src/arch/arm/table_walker.cc +++ b/src/arch/arm/table_walker.cc @@ -533,7 +533,8 @@ TableWalker::processWalkWrapper() unsigned num_squashed = 0; ThreadContext *tc = currState->tc; while ((num_squashed < numSquashable) && currState && - (currState->transState->squashed() || te)) { + (currState->transState->squashed() || + (te && !te->partial))) { pendingQueue.pop_front(); num_squashed++; stats.squashedBefore++; From 0679fc9c796c35b4f483f17d39b4b206d2ce2f76 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 11 Dec 2021 21:49:09 -0800 Subject: [PATCH 004/658] sim-se: (Re)add support for retrying system calls. The previous incarnation of this support used faults to make the CPU reexecute the system call instruction again and again to prevent emulating/passing through blocking system calls from blocking gem5 as a whole. That support was accidentally removed a while ago. This new version suspends the thread context executing the system call, and periodically wakes it up to retry using a periodically scheduled event. Jira Issue: https://gem5.atlassian.net/browse/GEM5-1123 Change-Id: I4fad23bd119021df23fe6082891fbcd0ee8fb839 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54024 Reviewed-by: Giacomo Travaglini Maintainer: Giacomo Travaglini Tested-by: kokoro --- src/sim/syscall_desc.cc | 55 ++++++++++++++++++++++++++++++++++++++--- src/sim/syscall_desc.hh | 5 ++++ 2 files changed, 56 insertions(+), 4 deletions(-) diff --git a/src/sim/syscall_desc.cc b/src/sim/syscall_desc.cc index 7427f41990..d293167995 100644 --- a/src/sim/syscall_desc.cc +++ b/src/sim/syscall_desc.cc @@ -30,6 +30,7 @@ #include "sim/syscall_desc.hh" #include "base/types.hh" +#include "sim/eventq.hh" #include "sim/syscall_debug_macros.hh" namespace gem5 @@ -45,12 +46,58 @@ SyscallDesc::doSyscall(ThreadContext *tc) SyscallReturn retval = executor(this, tc); if (retval.needsRetry()) { - DPRINTF_SYSCALL(Base, "Needs retry.\n", name()); - } else if (retval.suppressed()) { + // Suspend this ThreadContext while the syscall is pending. + tc->suspend(); + + DPRINTF_SYSCALL(Base, "%s needs retry.\n", name()); + setupRetry(tc); + return; + } + + handleReturn(tc, retval); +} + +void +SyscallDesc::retrySyscall(ThreadContext *tc) +{ + DPRINTF_SYSCALL(Base, "Retrying %s...\n", dumper(name(), tc)); + + SyscallReturn retval = executor(this, tc); + + if (retval.needsRetry()) { + DPRINTF_SYSCALL(Base, "%s still needs retry.\n", name()); + setupRetry(tc); + return; + } + + // We're done retrying, so reactivate this ThreadContext. + tc->activate(); + + handleReturn(tc, retval); +} + +void +SyscallDesc::setupRetry(ThreadContext *tc) +{ + // Create an event which will retry the system call later. + auto retry = [this, tc]() { retrySyscall(tc); }; + auto *event = new EventFunctionWrapper(retry, name(), true); + + // Schedule it in about 100 CPU cycles. That will give other contexts + // a chance to execute a bit of code before trying again. + auto *cpu = tc->getCpuPtr(); + curEventQueue()->schedule(event, + curTick() + cpu->cyclesToTicks(Cycles(100))); +} + +void +SyscallDesc::handleReturn(ThreadContext *tc, const SyscallReturn &ret) +{ + if (ret.suppressed()) { DPRINTF_SYSCALL(Base, "No return value.\n", name()); } else { - returnInto(tc, retval); - DPRINTF_SYSCALL(Base, "Returned %d.\n", retval.encodedValue()); + returnInto(tc, ret); + DPRINTF_SYSCALL(Base, "Returned %d.\n", ret.encodedValue()); } } diff --git a/src/sim/syscall_desc.hh b/src/sim/syscall_desc.hh index 6ded904097..e89cf4902b 100644 --- a/src/sim/syscall_desc.hh +++ b/src/sim/syscall_desc.hh @@ -95,11 +95,16 @@ class SyscallDesc _name(name), _num(num), executor(exec), dumper(dump) {} + void retrySyscall(ThreadContext *tc); + private: /** System call name (e.g., open, mmap, clone, socket, etc.) */ std::string _name; int _num; + void setupRetry(ThreadContext *tc); + void handleReturn(ThreadContext *tc, const SyscallReturn &ret); + /** Mechanism for ISAs to connect to the emul function definitions */ Executor executor; Dumper dumper; From fdf666a2e3b0225aa8877f88fa7f1a968b1f047a Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 11 Dec 2021 05:44:56 -0800 Subject: [PATCH 005/658] python: Add a mechanism for installing pybind modules. pybind provides a mechanism for this already, but it assumes that because it works through static initializers, it must run before the python interpreter has started. That is not true when gem5 is built as a library, since its static intitializers won't run until that library is loaded. Change-Id: I6f36c5f3831dda893039b4923902e9ce46a91808 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54003 Maintainer: Bobby Bruce Tested-by: kokoro Reviewed-by: Bobby Bruce --- src/python/pybind_init.hh | 74 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) create mode 100644 src/python/pybind_init.hh diff --git a/src/python/pybind_init.hh b/src/python/pybind_init.hh new file mode 100644 index 0000000000..102f3f18f7 --- /dev/null +++ b/src/python/pybind_init.hh @@ -0,0 +1,74 @@ +/* + * Copyright 2021 Google, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __PYTHON_PYBIND_INIT_HH__ +#define __PYTHON_PYBIND_INIT_HH__ + +#include + +#include "pybind11/pybind11.h" + +namespace gem5 +{ + +struct PybindModuleInit +{ + PybindModuleInit(const char *name, PyObject *(*func)()) + { + if (Py_IsInitialized()) { + // If python is running, initialize and inject the module. + PyImport_AddModule(name); + PyObject *sys_modules = PyImport_GetModuleDict(); + PyDict_SetItemString(sys_modules, name, func()); + } else { + // If not, tell python how to build importer itself later. + PyImport_AppendInittab(name, func); + } + } +}; + +} // namespace gem5 + +#define GEM5_PYBIND_MODULE_INIT(name, func) \ +namespace { \ + \ +::PyObject * \ +initializer() \ +{ \ + static ::pybind11::module_::module_def mod_def; \ + static auto m = ::pybind11::module_::create_extension_module( \ + #name, nullptr, &mod_def); \ + func(m); \ + m.inc_ref(); \ + return m.ptr(); \ +} \ + \ +::gem5::PybindModuleInit modInit(#name, initializer); \ + \ +} // anonymous namespace + +#endif // __PYTHON_PYBIND_INIT_HH__ From 765636b732f7cc0fac9b6b58ada3b6caebd831a5 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 11 Dec 2021 05:51:11 -0800 Subject: [PATCH 006/658] python: Replace PYBIND11_EMBEDDED_MODULE with GEM5_PYBIND_MODULE_INIT. That will make it possible for gem5's static intializers to run even if the python interpreter has started. Change-Id: Ic3574c32244e5ac475222f6d305ddc70dd6298d6 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54004 Maintainer: Bobby Bruce Tested-by: kokoro Reviewed-by: Bobby Bruce --- src/python/importer.cc | 15 ++++++++++++--- src/sim/init.cc | 6 ++---- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/src/python/importer.cc b/src/python/importer.cc index 2d10e962b4..dde86a8896 100644 --- a/src/python/importer.cc +++ b/src/python/importer.cc @@ -25,15 +25,20 @@ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "pybind11/embed.h" +#include "pybind11/eval.h" #include "pybind11/pybind11.h" -#include "python/m5ImporterCode.hh" #include "python/embedded.hh" +#include "python/m5ImporterCode.hh" +#include "python/pybind_init.hh" namespace py = pybind11; -PYBIND11_EMBEDDED_MODULE(importer, m) +namespace +{ + +void +importerInit(py::module_ &m) { m.def("_init_all_embedded", gem5::EmbeddedPython::initAll); py::str importer_code( @@ -41,3 +46,7 @@ PYBIND11_EMBEDDED_MODULE(importer, m) gem5::Blobs::m5ImporterCode_len); py::exec(std::move(importer_code), m.attr("__dict__")); } + +GEM5_PYBIND_MODULE_INIT(importer, importerInit) + +} // anonymous namespace diff --git a/src/sim/init.cc b/src/sim/init.cc index 8c0d1aa271..d594b08933 100644 --- a/src/sim/init.cc +++ b/src/sim/init.cc @@ -48,6 +48,7 @@ #include "base/cprintf.hh" #include "python/pybind11/pybind.hh" +#include "python/pybind_init.hh" namespace py = pybind11; @@ -126,9 +127,6 @@ EmbeddedPyBind::initAll(py::module_ &_m5) } } -PYBIND11_EMBEDDED_MODULE(_m5, _m5) -{ - EmbeddedPyBind::initAll(_m5); -} +GEM5_PYBIND_MODULE_INIT(_m5, EmbeddedPyBind::initAll) } // namespace gem5 From a36c378b20537803822938878d0026a50318ef37 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 11 Dec 2021 07:04:05 -0800 Subject: [PATCH 007/658] sim: Make the EmbeddedPyBind::initAll method work correctly. This method depended on all of the EmbeddedPyBind objects having all been constructed already so that it would have a complete list. This would only be true if it was called after static intialization was complete, which is not true if python is ready to go as soon as gem5 (in library form) is loaded. This change makes EmbeddedPyBind able to defer initialization of a module more generically than before, so that they can wait for either another module to be initiailized, or the _m5 package itself. Change-Id: I6b636524f969bd9882d8c1a7594dc36eb4e78037 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54005 Maintainer: Bobby Bruce Tested-by: kokoro Reviewed-by: Bobby Bruce --- src/sim/init.cc | 97 ++++++++++++++++++++++++++++--------------------- src/sim/init.hh | 17 +++++++-- 2 files changed, 68 insertions(+), 46 deletions(-) diff --git a/src/sim/init.cc b/src/sim/init.cc index d594b08933..1c3d3aa958 100644 --- a/src/sim/init.cc +++ b/src/sim/init.cc @@ -55,76 +55,89 @@ namespace py = pybind11; namespace gem5 { +pybind11::module_ *EmbeddedPyBind::mod = nullptr; + EmbeddedPyBind::EmbeddedPyBind(const char *_name, void (*init_func)(py::module_ &), - const char *_base) - : initFunc(init_func), registered(false), name(_name), base(_base) + const char *_base) : + initFunc(init_func), name(_name), base(_base) { - getMap()[_name] = this; + init(); } EmbeddedPyBind::EmbeddedPyBind(const char *_name, - void (*init_func)(py::module_ &)) - : initFunc(init_func), registered(false), name(_name), base("") + void (*init_func)(py::module_ &)) : + EmbeddedPyBind(_name, init_func, "") +{} + +void +EmbeddedPyBind::init() { - getMap()[_name] = this; + // If this module is already registered, complain and stop. + if (registered) { + cprintf("Warning: %s already registered.\n", name); + return; + } + + auto &ready = getReady(); + auto &pending = getPending(); + + // If we're not ready for this module yet, defer intialization. + if (!mod || (!base.empty() && ready.find(base) == ready.end())) { + pending.insert({std::string(base), this}); + return; + } + + // We must be ready, so set this module up. + initFunc(*mod); + ready[name] = this; + registered = true; + + // Find any other modules that were waiting for this one and init them. + initPending(name); } void -EmbeddedPyBind::init(py::module_ &m) +EmbeddedPyBind::initPending(const std::string &finished) { - if (!registered) { - initFunc(m); - registered = true; - } else { - cprintf("Warning: %s already registered.\n", name); - } -} + auto &pending = getPending(); -bool -EmbeddedPyBind::depsReady() const -{ - return base.empty() || getMap()[base]->registered; + auto range = pending.equal_range(finished); + std::list> todo( + range.first, range.second); + pending.erase(range.first, range.second); + + for (auto &entry: todo) + entry.second->init(); } std::map & -EmbeddedPyBind::getMap() +EmbeddedPyBind::getReady() { - static std::map objs; - return objs; + static std::map ready; + return ready; +} + +std::multimap & +EmbeddedPyBind::getPending() +{ + static std::multimap pending; + return pending; } void EmbeddedPyBind::initAll(py::module_ &_m5) { - std::list pending; - pybind_init_core(_m5); pybind_init_debug(_m5); pybind_init_event(_m5); pybind_init_stats(_m5); - for (auto &kv : EmbeddedPyBind::getMap()) { - auto &obj = kv.second; - if (obj->base.empty()) { - obj->init(_m5); - } else { - pending.push_back(obj); - } - } + mod = &_m5; - while (!pending.empty()) { - for (auto it = pending.begin(); it != pending.end(); ) { - EmbeddedPyBind &obj = **it; - if (obj.depsReady()) { - obj.init(_m5); - it = pending.erase(it); - } else { - ++it; - } - } - } + // Init all the modules that were waiting on the _m5 module itself. + initPending(""); } GEM5_PYBIND_MODULE_INIT(_m5, EmbeddedPyBind::initAll) diff --git a/src/sim/init.hh b/src/sim/init.hh index 9e7158a63e..3b86f82b29 100644 --- a/src/sim/init.hh +++ b/src/sim/init.hh @@ -43,6 +43,7 @@ #include "pybind11/pybind11.h" +#include #include #include @@ -64,14 +65,22 @@ class EmbeddedPyBind private: void (*initFunc)(pybind11::module_ &); - bool depsReady() const; - void init(pybind11::module_ &m); + void init(); - bool registered; + bool registered = false; const std::string name; const std::string base; - static std::map &getMap(); + // The _m5 module. + static pybind11::module_ *mod; + + // A map from initialized module names to their descriptors. + static std::map &getReady(); + // A map to pending modules from the name of what they're waiting on. + static std::multimap &getPending(); + + // Initialize all modules waiting on "finished". + static void initPending(const std::string &finished); }; } // namespace gem5 From 79e9755c610350e3ed3b0ce8a7624b501dd1b92d Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 11 Dec 2021 08:24:03 -0800 Subject: [PATCH 008/658] ext: Fix compilation of the sst gem5 integration. Replace the old copied version of gem5's main function with an updated copy. This fixes compilation, but there's still a problem running an sst example where there's a segfault inside the python interpreter. Change-Id: I95714a9264636c14e1dda3174bc0d79e3d881727 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54006 Maintainer: Bobby Bruce Tested-by: kokoro Reviewed-by: Bobby Bruce --- ext/sst/gem5.cc | 103 +++++++++--------------------------------------- ext/sst/gem5.hh | 2 - 2 files changed, 18 insertions(+), 87 deletions(-) diff --git a/ext/sst/gem5.cc b/ext/sst/gem5.cc index c93c722cf3..1d90bc5b38 100644 --- a/ext/sst/gem5.cc +++ b/ext/sst/gem5.cc @@ -89,6 +89,9 @@ #include #include +#include +#include + // gem5 Headers #include #include @@ -118,6 +121,8 @@ // More SST Headers #include +namespace py = pybind11; + gem5Component::gem5Component(SST::ComponentId_t id, SST::Params& params): SST::Component(id), threadInitialized(false) { @@ -365,98 +370,26 @@ gem5Component::execPythonCommands(const std::vector& commands) return 0; } -int -gem5Component::startM5(int argc, char **_argv) -{ - // This function should be similar to m5Main() of src/sim/init.cc - -#if HAVE_PROTOBUF - // Verify that the version of the protobuf library that we linked - // against is compatible with the version of the headers we - // compiled against. - GOOGLE_PROTOBUF_VERIFY_VERSION; -#endif - - -#if PY_MAJOR_VERSION >= 3 - typedef std::unique_ptr WArgUPtr; - std::vector v_argv; - std::vector vp_argv; - v_argv.reserve(argc); - vp_argv.reserve(argc); - for (int i = 0; i < argc; i++) { - v_argv.emplace_back(Py_DecodeLocale(_argv[i], NULL), &PyMem_RawFree); - vp_argv.emplace_back(v_argv.back().get()); - } - - wchar_t **argv = vp_argv.data(); -#else - char **argv = _argv; -#endif - - PySys_SetArgv(argc, argv); - - // We have to set things up in the special __main__ module - pythonMain = PyImport_AddModule(PyCC("__main__")); - if (pythonMain == NULL) - panic("Could not import __main__"); - - const std::vector commands = { - "import m5", - "m5.main()" - }; - execPythonCommands(commands); - -#if HAVE_PROTOBUF - google::protobuf::ShutdownProtobufLibrary(); -#endif - - return 0; -} - void gem5Component::initPython(int argc, char *_argv[]) { - // should be similar to main() in src/sim/main.cc - PyObject *mainModule, *mainDict; - - int ret; - - // Initialize m5 special signal handling. + // Initialize gem5 special signal handling. gem5::initSignals(); -#if PY_MAJOR_VERSION >= 3 - std::unique_ptr program( - Py_DecodeLocale(_argv[0], NULL), - &PyMem_RawFree); - Py_SetProgramName(program.get()); -#else - Py_SetProgramName(_argv[0]); -#endif + if (!Py_IsInitialized()) + py::initialize_interpreter(false, argc, _argv); - // Register native modules with Python's init system before - // initializing the interpreter. - if (!Py_IsInitialized()) { - gem5::registerNativeModules(); - // initialize embedded Python interpreter - Py_Initialize(); - } else { - // https://stackoverflow.com/a/28349174 - PyImport_AddModule("_m5"); - PyObject* module = gem5::EmbeddedPyBind::initAll(); - PyObject* sys_modules = PyImport_GetModuleDict(); - PyDict_SetItemString(sys_modules, "_m5", module); - Py_DECREF(module); + auto importer = py::module_::import("importer"); + importer.attr("install")(); + + try { + py::module_::import("m5").attr("main")(); + } catch (py::error_already_set &e) { + if (!e.matches(PyExc_SystemExit)) { + std::cerr << e.what(); + output.output(CALL_INFO, "Calling m5.main(...) failed.\n"); + } } - - - // Initialize the embedded m5 python library - ret = gem5::EmbeddedPython::initAll(); - - if (ret == 0) - startM5(argc, _argv); // start m5 - else - output.output(CALL_INFO, "Not calling m5Main due to ret=%d\n", ret); } void diff --git a/ext/sst/gem5.hh b/ext/sst/gem5.hh index 34d8bd616c..27124114b1 100644 --- a/ext/sst/gem5.hh +++ b/ext/sst/gem5.hh @@ -101,8 +101,6 @@ class gem5Component: public SST::Component void finish(); bool clockTick(SST::Cycle_t current_cycle); - int startM5(int argc, char **_argv); - // stuff needed for gem5 sim public: From 46957f4337589829c1b94c213c9574191b22515e Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Tue, 14 Dec 2021 11:17:41 +0800 Subject: [PATCH 009/658] base: Correct checkBpLen naming with checkBpKind In gdb document*1, the second parameter of checkpoint command(Z0, Z1) is named after kind. Although underlying implementation probably considers it as length*2, it's still good to follow the name described in gdb document for avoiding any confusion. Refs: 1. https://sourceware.org/gdb/onlinedocs/gdb/Packets.html 2. https://github.com/bminor/binutils-gdb/blob/master/gdb/arch-utils.h#L41 Change-Id: Ib4b585613b8018970b16355f96cdff2ce9d5bae6 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54123 Reviewed-by: Daniel Carvalho Maintainer: Daniel Carvalho Tested-by: kokoro Reviewed-by: Giacomo Travaglini --- src/arch/arm/remote_gdb.cc | 4 +-- src/arch/arm/remote_gdb.hh | 2 +- src/arch/riscv/remote_gdb.hh | 2 +- src/arch/x86/remote_gdb.hh | 2 +- src/base/remote_gdb.cc | 50 ++++++++++++++++++------------------ src/base/remote_gdb.hh | 14 +++++----- 6 files changed, 38 insertions(+), 36 deletions(-) diff --git a/src/arch/arm/remote_gdb.cc b/src/arch/arm/remote_gdb.cc index 2efa82fa33..215c532ea6 100644 --- a/src/arch/arm/remote_gdb.cc +++ b/src/arch/arm/remote_gdb.cc @@ -362,10 +362,10 @@ RemoteGDB::gdbRegs() } bool -RemoteGDB::checkBpLen(size_t len) +RemoteGDB::checkBpKind(size_t kind) { // 2 for Thumb ISA, 4 for ARM ISA. - return len == 2 || len == 4; + return kind == 2 || kind == 4; } } // namespace gem5 diff --git a/src/arch/arm/remote_gdb.hh b/src/arch/arm/remote_gdb.hh index cff6d4a9c2..8e512a452f 100644 --- a/src/arch/arm/remote_gdb.hh +++ b/src/arch/arm/remote_gdb.hh @@ -120,7 +120,7 @@ class RemoteGDB : public BaseRemoteGDB public: RemoteGDB(System *_system, int _port); BaseGdbRegCache *gdbRegs() override; - bool checkBpLen(size_t len) override; + bool checkBpKind(size_t kind) override; std::vector availableFeatures() const override { diff --git a/src/arch/riscv/remote_gdb.hh b/src/arch/riscv/remote_gdb.hh index 40fe821ca3..753859fe77 100644 --- a/src/arch/riscv/remote_gdb.hh +++ b/src/arch/riscv/remote_gdb.hh @@ -56,7 +56,7 @@ class RemoteGDB : public BaseRemoteGDB bool acc(Addr addr, size_t len) override; // A breakpoint will be 2 bytes if it is compressed and 4 if not - bool checkBpLen(size_t len) override { return len == 2 || len == 4; } + bool checkBpKind(size_t kind) override { return kind == 2 || kind == 4; } class RiscvGdbRegCache : public BaseGdbRegCache { diff --git a/src/arch/x86/remote_gdb.hh b/src/arch/x86/remote_gdb.hh index 62176a55aa..dfa9177f1e 100644 --- a/src/arch/x86/remote_gdb.hh +++ b/src/arch/x86/remote_gdb.hh @@ -58,7 +58,7 @@ class RemoteGDB : public BaseRemoteGDB { protected: bool acc(Addr addr, size_t len); - bool checkBpLen(size_t len) { return len == 1; } + bool checkBpKind(size_t kind) { return kind == 1; } class X86GdbRegCache : public BaseGdbRegCache { using BaseGdbRegCache::BaseGdbRegCache; diff --git a/src/base/remote_gdb.cc b/src/base/remote_gdb.cc index 1437b75040..798d09f535 100644 --- a/src/base/remote_gdb.cc +++ b/src/base/remote_gdb.cc @@ -784,28 +784,28 @@ BaseRemoteGDB::setSingleStep() } void -BaseRemoteGDB::insertSoftBreak(Addr addr, size_t len) +BaseRemoteGDB::insertSoftBreak(Addr addr, size_t kind) { - if (!checkBpLen(len)) - throw BadClient("Invalid breakpoint length\n"); + if (!checkBpKind(kind)) + throw BadClient("Invalid breakpoint kind.\n"); - return insertHardBreak(addr, len); + return insertHardBreak(addr, kind); } void -BaseRemoteGDB::removeSoftBreak(Addr addr, size_t len) +BaseRemoteGDB::removeSoftBreak(Addr addr, size_t kind) { - if (!checkBpLen(len)) - throw BadClient("Invalid breakpoint length.\n"); + if (!checkBpKind(kind)) + throw BadClient("Invalid breakpoint kind.\n"); - return removeHardBreak(addr, len); + return removeHardBreak(addr, kind); } void -BaseRemoteGDB::insertHardBreak(Addr addr, size_t len) +BaseRemoteGDB::insertHardBreak(Addr addr, size_t kind) { - if (!checkBpLen(len)) - throw BadClient("Invalid breakpoint length\n"); + if (!checkBpKind(kind)) + throw BadClient("Invalid breakpoint kind.\n"); DPRINTF(GDBMisc, "Inserting hardware breakpoint at %#x\n", addr); @@ -817,10 +817,10 @@ BaseRemoteGDB::insertHardBreak(Addr addr, size_t len) } void -BaseRemoteGDB::removeHardBreak(Addr addr, size_t len) +BaseRemoteGDB::removeHardBreak(Addr addr, size_t kind) { - if (!checkBpLen(len)) - throw BadClient("Invalid breakpoint length\n"); + if (!checkBpKind(kind)) + throw BadClient("Invalid breakpoint kind.\n"); DPRINTF(GDBMisc, "Removing hardware breakpoint at %#x\n", addr); @@ -917,7 +917,7 @@ std::map BaseRemoteGDB::commandMap = { }; bool -BaseRemoteGDB::checkBpLen(size_t len) +BaseRemoteGDB::checkBpKind(size_t kind) { return true; } @@ -1302,17 +1302,17 @@ BaseRemoteGDB::cmdClrHwBkpt(GdbCommand::Context &ctx) Addr addr = hex2i(&p); if (*p++ != ',') throw CmdError("E0D"); - size_t len = hex2i(&p); + size_t kind = hex2i(&p); - DPRINTF(GDBMisc, "clear %s, addr=%#x, len=%d\n", - breakType(sub_cmd), addr, len); + DPRINTF(GDBMisc, "clear %s, addr=%#x, kind=%d\n", + breakType(sub_cmd), addr, kind); switch (sub_cmd) { case GdbSoftBp: - removeSoftBreak(addr, len); + removeSoftBreak(addr, kind); break; case GdbHardBp: - removeHardBreak(addr, len); + removeHardBreak(addr, kind); break; case GdbWriteWp: case GdbReadWp: @@ -1335,17 +1335,17 @@ BaseRemoteGDB::cmdSetHwBkpt(GdbCommand::Context &ctx) Addr addr = hex2i(&p); if (*p++ != ',') throw CmdError("E0D"); - size_t len = hex2i(&p); + size_t kind = hex2i(&p); - DPRINTF(GDBMisc, "set %s, addr=%#x, len=%d\n", - breakType(sub_cmd), addr, len); + DPRINTF(GDBMisc, "set %s, addr=%#x, kind=%d\n", + breakType(sub_cmd), addr, kind); switch (sub_cmd) { case GdbSoftBp: - insertSoftBreak(addr, len); + insertSoftBreak(addr, kind); break; case GdbHardBp: - insertHardBreak(addr, len); + insertHardBreak(addr, kind); break; case GdbWriteWp: case GdbReadWp: diff --git a/src/base/remote_gdb.hh b/src/base/remote_gdb.hh index 59bccc564e..b297e0877f 100644 --- a/src/base/remote_gdb.hh +++ b/src/base/remote_gdb.hh @@ -313,10 +313,10 @@ class BaseRemoteGDB void descheduleInstCommitEvent(Event *ev); // Breakpoints. - void insertSoftBreak(Addr addr, size_t len); - void removeSoftBreak(Addr addr, size_t len); - void insertHardBreak(Addr addr, size_t len); - void removeHardBreak(Addr addr, size_t len); + void insertSoftBreak(Addr addr, size_t kind); + void removeSoftBreak(Addr addr, size_t kind); + void insertHardBreak(Addr addr, size_t kind); + void removeHardBreak(Addr addr, size_t kind); /* * GDB commands. @@ -401,8 +401,10 @@ class BaseRemoteGDB void encodeXferResponse(const std::string &unencoded, std::string &encoded, size_t offset, size_t unencoded_length) const; - // To be implemented by subclasses. - virtual bool checkBpLen(size_t len); + // checkBpKind checks if a kind of breakpoint is legal. This function should + // be implemented by subclasses by arch. The "kind" is considered to be + // breakpoint size in some arch. + virtual bool checkBpKind(size_t kind); virtual BaseGdbRegCache *gdbRegs() = 0; From 110e22439faf1e1a6a39c01787d2d280768fb024 Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Tue, 14 Dec 2021 11:18:54 +0800 Subject: [PATCH 010/658] arch-arm: gdb support Thumb-2 ISA From the document*1, we should allow 2,3,4 in kind check function for supporting all kinds of ARM breakpoint. 1. https://sourceware.org/gdb/current/onlinedocs/gdb/ARM-Breakpoint-Kinds.html Change-Id: I82bcb88cfe6e80e7f17cd6bb68a26a45ace7b174 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54124 Reviewed-by: Giacomo Travaglini Maintainer: Giacomo Travaglini Tested-by: kokoro --- src/arch/arm/remote_gdb.cc | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) diff --git a/src/arch/arm/remote_gdb.cc b/src/arch/arm/remote_gdb.cc index 215c532ea6..6e8923e8bf 100644 --- a/src/arch/arm/remote_gdb.cc +++ b/src/arch/arm/remote_gdb.cc @@ -168,6 +168,20 @@ namespace gem5 using namespace ArmISA; +namespace +{ + +// https://sourceware.org/gdb/current/onlinedocs/gdb/ARM-Breakpoint-Kinds.html +enum class ArmBpKind +{ + THUMB = 2, + THUMB_2 = 3, + ARM = 4, +}; + +} // namespace + + static bool tryTranslate(ThreadContext *tc, Addr addr) { @@ -364,8 +378,14 @@ RemoteGDB::gdbRegs() bool RemoteGDB::checkBpKind(size_t kind) { - // 2 for Thumb ISA, 4 for ARM ISA. - return kind == 2 || kind == 4; + switch (ArmBpKind(kind)) { + case ArmBpKind::THUMB: + case ArmBpKind::THUMB_2: + case ArmBpKind::ARM: + return true; + default: + return false; + } } } // namespace gem5 From 735f768cc81e8b9cd7e7065e5b4206316a52882c Mon Sep 17 00:00:00 2001 From: Jiasen Huang Date: Tue, 14 Dec 2021 20:42:15 +0800 Subject: [PATCH 011/658] mem-cache: Added stats filtering both useful and spanPage prefetch. Change-Id: I2570ee47f064ac999f2dcc813c9e39174a2ad8af Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54163 Reviewed-by: Daniel Carvalho Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/mem/cache/prefetch/queued.cc | 8 +++++++- src/mem/cache/prefetch/queued.hh | 1 + 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/src/mem/cache/prefetch/queued.cc b/src/mem/cache/prefetch/queued.cc index 597c88a995..da9cbf479e 100644 --- a/src/mem/cache/prefetch/queued.cc +++ b/src/mem/cache/prefetch/queued.cc @@ -210,6 +210,10 @@ Queued::notify(const PacketPtr &pkt, const PrefetchInfo &pfi) if (!samePage(addr_prio.first, pfi.getAddr())) { statsQueued.pfSpanPage += 1; + + if (hasBeenPrefetched(pkt->getAddr(), pkt->isSecure())) { + statsQueued.pfUsefulSpanPage += 1; + } } bool can_cross_page = (tlb != nullptr); @@ -272,7 +276,9 @@ Queued::QueuedStats::QueuedStats(statistics::Group *parent) ADD_STAT(pfRemovedFull, statistics::units::Count::get(), "number of prefetches dropped due to prefetch queue size"), ADD_STAT(pfSpanPage, statistics::units::Count::get(), - "number of prefetches that crossed the page") + "number of prefetches that crossed the page"), + ADD_STAT(pfUsefulSpanPage, statistics::units::Count::get(), + "number of prefetches that is useful and crossed the page") { } diff --git a/src/mem/cache/prefetch/queued.hh b/src/mem/cache/prefetch/queued.hh index 1062630c40..c769b3875a 100644 --- a/src/mem/cache/prefetch/queued.hh +++ b/src/mem/cache/prefetch/queued.hh @@ -185,6 +185,7 @@ class Queued : public Base statistics::Scalar pfRemovedDemand; statistics::Scalar pfRemovedFull; statistics::Scalar pfSpanPage; + statistics::Scalar pfUsefulSpanPage; } statsQueued; public: using AddrPriority = std::pair; From 0d1a40602f918eff84c0e8028bb369e8ead4a496 Mon Sep 17 00:00:00 2001 From: "Daniel R. Carvalho" Date: Sun, 19 Dec 2021 11:43:11 +0100 Subject: [PATCH 012/658] base: Finish deprecating SatCounter SatCounter has been marked as deprecated for at least 2 versions, so it can be removed. Change-Id: Iffb75822cc0d09d8b7d9b86828b26198865ce407 Signed-off-by: Daniel R. Carvalho Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54523 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/base/sat_counter.hh | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/base/sat_counter.hh b/src/base/sat_counter.hh index 6644b05c26..a607c4ca85 100644 --- a/src/base/sat_counter.hh +++ b/src/base/sat_counter.hh @@ -340,9 +340,6 @@ typedef GenericSatCounter SatCounter32; typedef GenericSatCounter SatCounter64; /** @} */ -[[deprecated("Use SatCounter8 (or variants) instead")]] -typedef SatCounter8 SatCounter; - } // namespace gem5 #endif // __BASE_SAT_COUNTER_HH__ From 791092663183bcf01468ca84b6d3c177f0cf7fc7 Mon Sep 17 00:00:00 2001 From: Jiasen Huang Date: Mon, 20 Dec 2021 12:50:39 +0800 Subject: [PATCH 013/658] mem-cache: Set prefetch bit if the blk comes from Prefetch only. Original logic setting prefetch inside serviceMSHRTargets did not exclude the blks that both came from CORE and Prefetch Change-Id: Iab56b9266eb64baf972b160774aca0823faea458 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54364 Reviewed-by: Daniel Carvalho Maintainer: Daniel Carvalho Tested-by: kokoro --- src/mem/cache/cache.cc | 13 +++++++++++-- src/mem/cache/noncoherent_cache.cc | 12 ++++++++++-- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/src/mem/cache/cache.cc b/src/mem/cache/cache.cc index 3c24343bac..466aeec2b4 100644 --- a/src/mem/cache/cache.cc +++ b/src/mem/cache/cache.cc @@ -693,11 +693,16 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) bool is_invalidate = pkt->isInvalidate() && !mshr->wasWholeLineWrite; + bool from_core = false; + bool from_pref = false; + MSHR::TargetList targets = mshr->extractServiceableTargets(pkt); for (auto &target: targets) { Packet *tgt_pkt = target.pkt; switch (target.source) { case MSHR::Target::FromCPU: + from_core = true; + Tick completion_time; // Here we charge on completion_time the delay of the xbar if the // packet comes from it, charged on headerDelay. @@ -852,8 +857,8 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) case MSHR::Target::FromPrefetcher: assert(tgt_pkt->cmd == MemCmd::HardPFReq); - if (blk) - blk->setPrefetched(); + from_pref = true; + delete tgt_pkt; break; @@ -882,6 +887,10 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) } } + if (blk && !from_core && from_pref) { + blk->setPrefetched(); + } + maintainClusivity(targets.hasFromCache, blk); if (blk && blk->isValid()) { diff --git a/src/mem/cache/noncoherent_cache.cc b/src/mem/cache/noncoherent_cache.cc index 314025fee4..9e95a20ada 100644 --- a/src/mem/cache/noncoherent_cache.cc +++ b/src/mem/cache/noncoherent_cache.cc @@ -245,6 +245,9 @@ NoncoherentCache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, // First offset for critical word first calculations const int initial_offset = mshr->getTarget()->pkt->getOffset(blkSize); + bool from_core = false; + bool from_pref = false; + MSHR::TargetList targets = mshr->extractServiceableTargets(pkt); for (auto &target: targets) { Packet *tgt_pkt = target.pkt; @@ -254,6 +257,8 @@ NoncoherentCache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, // handle deferred requests comming from a cache or core // above + from_core = true; + Tick completion_time; // Here we charge on completion_time the delay of the xbar if the // packet comes from it, charged on headerDelay. @@ -292,8 +297,7 @@ NoncoherentCache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, // attached to this cache assert(tgt_pkt->cmd == MemCmd::HardPFReq); - if (blk) - blk->setPrefetched(); + from_pref = true; // We have filled the block and the prefetcher does not // require responses. @@ -307,6 +311,10 @@ NoncoherentCache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, } } + if (blk && !from_core && from_pref) { + blk->setPrefetched(); + } + // Reponses are filling and bring in writable blocks, therefore // there should be no deferred targets and all the non-deferred // targets are now serviced. From 2194aea0530d8af00c6ea005eeaadcc1e9071e50 Mon Sep 17 00:00:00 2001 From: Cui Jin Date: Tue, 21 Dec 2021 23:15:03 +0800 Subject: [PATCH 014/658] arch-riscv: rvc instruction is mistaken as branch Fetch in O3CPU mistakes the normal non-branching compressed instructions, and regards it as a branch. This issue interrupts the consecutive instruction stream, thus affecting performance of cpu front-end. This fix sets the compressed for PCState during decoding. Jira Issue: https://gem5.atlassian.net/browse/GEM5-1137 Change-Id: I7607d563bba8a08869e104877fc3c11c94cbe904 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54644 Reviewed-by: Jin Cui Reviewed-by: Ayaz Akram Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/arch/riscv/decoder.cc | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/arch/riscv/decoder.cc b/src/arch/riscv/decoder.cc index 4fbcc64f65..a02415fae0 100644 --- a/src/arch/riscv/decoder.cc +++ b/src/arch/riscv/decoder.cc @@ -105,8 +105,10 @@ Decoder::decode(PCStateBase &_next_pc) if (compressed(emi)) { next_pc.npc(next_pc.instAddr() + sizeof(machInst) / 2); + next_pc.compressed(true); } else { next_pc.npc(next_pc.instAddr() + sizeof(machInst)); + next_pc.compressed(false); } return decode(emi, next_pc.instAddr()); From 398d4f9d07c6728cc95710b63095a8e798351e05 Mon Sep 17 00:00:00 2001 From: Jiasen Huang Date: Tue, 21 Dec 2021 15:48:01 +0800 Subject: [PATCH 015/658] mem-cache: Init lastTriggerCounter for STeMS Prefetcher Change-Id: I43a0093e6d35a39799d724e7dee15c95dbc26343 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54643 Reviewed-by: Daniel Carvalho Maintainer: Daniel Carvalho Tested-by: kokoro --- src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc index d0f4119dd9..6030096612 100644 --- a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc +++ b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc @@ -55,7 +55,8 @@ STeMS::STeMS(const STeMSPrefetcherParams &p) p.pattern_sequence_table_replacement_policy, ActiveGenerationTableEntry( spatialRegionSize / blkSize)), - rmob(p.region_miss_order_buffer_entries) + rmob(p.region_miss_order_buffer_entries), + lastTriggerCounter(0) { fatal_if(!isPowerOf2(spatialRegionSize), "The spatial region size must be a power of 2."); From 515c89b8604cfbedfa2b5595bf9940e03229dd78 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Mon, 20 Dec 2021 11:45:03 -0800 Subject: [PATCH 016/658] util-docker: Update how rocBLAS is built in gcn-gpu Dockerfile rocBLAS builds for all targets by default, but it requires we set the HCC_AMDGPU_TARGET env variable to all the targets we want to build for. This change explicitly sets all the gfx versions we intend to support in gem5, and removes the extraneous "-a all" from the install command. Additionally, doing this allowed for DNNMark to run on gfx902. Change-Id: Id1a00433beaa23f6935c12073d5bddc38431886b Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54623 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Reviewed-by: Matthew Poremba Tested-by: kokoro --- util/dockerfiles/gcn-gpu/Dockerfile | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/util/dockerfiles/gcn-gpu/Dockerfile b/util/dockerfiles/gcn-gpu/Dockerfile index dee02b095b..8dd1b1b139 100644 --- a/util/dockerfiles/gcn-gpu/Dockerfile +++ b/util/dockerfiles/gcn-gpu/Dockerfile @@ -105,11 +105,11 @@ RUN apt install rocm-cmake RUN git clone -b rocm-4.0.0 \ https://github.com/ROCmSoftwarePlatform/rocBLAS.git && mkdir rocBLAS/build -ENV HCC_AMDGPU_TARGET=gfx801 +ENV HCC_AMDGPU_TARGET=gfx801,gfx803,gfx900,gfx902 WORKDIR rocBLAS -# rocBLAS needs to be built from source otherwise gfx801 gets an error in HIP +# rocBLAS needs to be built from source otherwise certain gfx versions get errors in HIP # about there being no GPU binary available -RUN ./install.sh -d -a all -i +RUN ./install.sh -d -i WORKDIR / # MIOpen dependencies + MIOpen From dda149ecf8c35219461ceb12edbeda8b62b91078 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Tue, 3 Aug 2021 21:48:28 -0700 Subject: [PATCH 017/658] scons: Add a --linker option. There is currently a "--gold-linker" option, which tells SCons to use the gold linker. This puts the gold linker in a special position where it has its own command line option, and makes it impossible to explicitly select any other linker. This change adds a --linker option which can be set to "bfd" (the default gnu linker), "gold" (the gnu gold linker), or "lld" which is the clang linker. If none is specified, SCons will let the compiler fall back to whatever its default is. The --gold-linker option is modified so that it just sets the --linker option for you. Because of how SCons handles adding command line options, there isn't a good way to complain if both it and --linker is used, nor is there a good way to warn that the user is using a deprecated command line option. A warning is in the help text for that option now, though. If the gold linker is selected, this change also sets the --threads option, and sets the --thread-count option. This tells the gold linker to run multi-threaded to speed up linking. Apparently the gold linker must have been built with an option that enables threading for these options to have any effect. If threads and LTO are both enabled, the gold linker segfaults. To avoid that problem, we don't add --threads if LTO has been enabled. This change also enables a new configuration, where lld, the clang linker, can be used with gcc. Unfortunately the format of LTO information gcc/g++ generates is not compatible with lld, and so if you set the linker to lld and enable LTO, you'll probably get errors like not being able to find the symbol "main". This change also allows you to select the default gnu linker ("bfd") when using clang, although it's not clear why you would want to do that. Change-Id: Ib37030431527f5d0bc626e9594b2e1142df889be Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49003 Reviewed-by: Daniel Carvalho Reviewed-by: Giacomo Travaglini Tested-by: kokoro Maintainer: Gabe Black --- SConstruct | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/SConstruct b/SConstruct index ceeb1ba52f..60493ae2c5 100755 --- a/SConstruct +++ b/SConstruct @@ -98,6 +98,8 @@ import SCons.Tool # ######################################################################## +linker_options = ('bfd', 'gold', 'lld') + AddOption('--no-colors', dest='use_colors', action='store_false', help="Don't add color to abbreviated scons output") AddOption('--with-cxx-config', action='store_true', @@ -106,7 +108,10 @@ AddOption('--default', help='Override which build_opts file to use for defaults') AddOption('--ignore-style', action='store_true', help='Disable style checking hooks') -AddOption('--gold-linker', action='store_true', help='Use the gold linker') +AddOption('--linker', action='store', default=None, choices=linker_options, + help=f'Select which linker to use ({", ".join(linker_options)})') +AddOption('--gold-linker', action='store_const', const='gold', dest='linker', + help='Use the gold linker. Deprecated: Use --linker=gold') AddOption('--no-compress-debug', action='store_true', help="Don't compress debug info in build files") AddOption('--with-lto', action='store_true', @@ -345,8 +350,18 @@ if main['GCC'] or main['CLANG']: with gem5_scons.Configure(main) as conf: conf.CheckLinkFlag('-Wl,--as-needed') - if GetOption('gold_linker'): - main.Append(LINKFLAGS='-fuse-ld=gold') + + linker = GetOption('linker') + if linker: + with gem5_scons.Configure(main) as conf: + if not conf.CheckLinkFlag(f'-fuse-ld={linker}'): + error(f'Linker "{linker}" is not supported') + if linker == 'gold' and not GetOption('with_lto'): + # Tell the gold linker to use threads. The gold linker + # segfaults if both threads and LTO are enabled. + conf.CheckLinkFlag('-Wl,--threads') + conf.CheckLinkFlag( + '-Wl,--thread-count=%d' % GetOption('num_jobs')) else: error('\n'.join(( From 5e6a561a3fd76a7d9b67f390df22f2df245461ab Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Mon, 27 Dec 2021 00:14:41 -0800 Subject: [PATCH 018/658] misc: Revert v21.2 specific commits for develop These changes were made to the release staging branch for the v21.2 release. This commit reverts them for the develop branch. Change-Id: I9f02470d00d5034a0797f32d4c1fe0e7055860a6 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54904 Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce Tested-by: kokoro --- SConstruct | 7 +++++++ ext/testlib/configuration.py | 2 +- src/Doxyfile | 2 +- src/base/version.cc | 2 +- src/python/gem5/resources/downloader.py | 2 +- tests/compiler-tests.sh | 2 +- tests/jenkins/presubmit.sh | 4 ++-- tests/nightly.sh | 24 +++++++++++------------ tests/weekly.sh | 26 ++++++++++++++----------- util/dockerfiles/gcn-gpu/Dockerfile | 2 +- 10 files changed, 42 insertions(+), 31 deletions(-) diff --git a/SConstruct b/SConstruct index 60493ae2c5..d7cd56424e 100755 --- a/SConstruct +++ b/SConstruct @@ -363,6 +363,13 @@ if main['GCC'] or main['CLANG']: conf.CheckLinkFlag( '-Wl,--thread-count=%d' % GetOption('num_jobs')) + # Treat warnings as errors but white list some warnings that we + # want to allow (e.g., deprecation warnings). + main.Append(CCFLAGS=['-Werror', + '-Wno-error=deprecated-declarations', + '-Wno-error=deprecated', + ]) + else: error('\n'.join(( "Don't know what compiler options to use for your compiler.", diff --git a/ext/testlib/configuration.py b/ext/testlib/configuration.py index d0fca7451a..95800deb46 100644 --- a/ext/testlib/configuration.py +++ b/ext/testlib/configuration.py @@ -213,7 +213,7 @@ def define_defaults(defaults): os.pardir, os.pardir)) defaults.result_path = os.path.join(os.getcwd(), 'testing-results') - defaults.resource_url = 'http://dist.gem5.org/dist/v21-2' + defaults.resource_url = 'http://dist.gem5.org/dist/develop' defaults.resource_path = os.path.abspath(os.path.join(defaults.base_dir, 'tests', 'gem5', diff --git a/src/Doxyfile b/src/Doxyfile index 8ed8839f9a..f29acbbde4 100644 --- a/src/Doxyfile +++ b/src/Doxyfile @@ -31,7 +31,7 @@ PROJECT_NAME = gem5 # This could be handy for archiving the generated documentation or # if some version control system is used. -PROJECT_NUMBER = v21.2.0.0 +PROJECT_NUMBER = DEVELOP-FOR-V22-0 # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) # base path where the generated documentation will be put. diff --git a/src/base/version.cc b/src/base/version.cc index 0da32c2494..56c982fa28 100644 --- a/src/base/version.cc +++ b/src/base/version.cc @@ -32,6 +32,6 @@ namespace gem5 /** * @ingroup api_base_utils */ -const char *gem5Version = "21.2.0.0"; +const char *gem5Version = "[DEVELOP-FOR-v22.0"; } // namespace gem5 diff --git a/src/python/gem5/resources/downloader.py b/src/python/gem5/resources/downloader.py index 2cb73baef4..5afceeb2dc 100644 --- a/src/python/gem5/resources/downloader.py +++ b/src/python/gem5/resources/downloader.py @@ -45,7 +45,7 @@ def _resources_json_version_required() -> str: """ Specifies the version of resources.json to obtain. """ - return "21.2" + return "develop" def _get_resources_json_uri() -> str: uri = ( diff --git a/tests/compiler-tests.sh b/tests/compiler-tests.sh index 43092dadec..15ffb1673b 100755 --- a/tests/compiler-tests.sh +++ b/tests/compiler-tests.sh @@ -99,7 +99,7 @@ for compiler in ${images[@]}; do # targets for this test build_indices=(${build_permutation[@]:0:$builds_count}) - repo_name="${base_url}/${compiler}:v21-2" + repo_name="${base_url}/${compiler}:latest" # Grab compiler image docker pull $repo_name >/dev/null diff --git a/tests/jenkins/presubmit.sh b/tests/jenkins/presubmit.sh index d15df01193..a5e901331b 100755 --- a/tests/jenkins/presubmit.sh +++ b/tests/jenkins/presubmit.sh @@ -37,8 +37,8 @@ set -e -DOCKER_IMAGE_ALL_DEP=gcr.io/gem5-test/ubuntu-20.04_all-dependencies:v21-2 -DOCKER_IMAGE_CLANG_COMPILE=gcr.io/gem5-test/clang-version-9:v21-2 +DOCKER_IMAGE_ALL_DEP=gcr.io/gem5-test/ubuntu-20.04_all-dependencies:latest +DOCKER_IMAGE_CLANG_COMPILE=gcr.io/gem5-test/clang-version-9:latest PRESUBMIT_STAGE2=tests/jenkins/presubmit-stage2.sh GEM5ART_TESTS=tests/jenkins/gem5art-tests.sh diff --git a/tests/nightly.sh b/tests/nightly.sh index 190c33d1f3..e421d978e7 100755 --- a/tests/nightly.sh +++ b/tests/nightly.sh @@ -66,7 +66,7 @@ build_target () { # compilation: https://gem5.atlassian.net/browse/GEM5-753 docker run -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ "${gem5_root}" --rm \ - gcr.io/gem5-test/ubuntu-20.04_all-dependencies:v21-2 \ + gcr.io/gem5-test/ubuntu-20.04_all-dependencies:latest \ bash -c "scons build/${isa}/gem5.opt -j${compile_threads} \ || (rm -rf build && scons build/${isa}/gem5.opt -j${compile_threads})" } @@ -76,12 +76,12 @@ unit_test () { docker run -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ "${gem5_root}" --rm \ - gcr.io/gem5-test/ubuntu-20.04_all-dependencies:v21-2 \ + gcr.io/gem5-test/ubuntu-20.04_all-dependencies:latest \ scons build/NULL/unittests.${build} -j${compile_threads} } # Ensure we have the latest docker images. -docker pull gcr.io/gem5-test/ubuntu-20.04_all-dependencies:v21-2 +docker pull gcr.io/gem5-test/ubuntu-20.04_all-dependencies:latest # Try to build the ISA targets. build_target NULL @@ -99,18 +99,18 @@ unit_test debug # Run the gem5 long tests. docker run -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ "${gem5_root}"/tests --rm \ - gcr.io/gem5-test/ubuntu-20.04_all-dependencies:v21-2 \ + gcr.io/gem5-test/ubuntu-20.04_all-dependencies:latest \ ./main.py run --length long -j${compile_threads} -t${run_threads} -vv # For the GPU tests we compile and run the GPU ISA inside a gcn-gpu container. -docker pull gcr.io/gem5-test/gcn-gpu:v21-2 +docker pull gcr.io/gem5-test/gcn-gpu:latest docker run --rm -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ - "${gem5_root}" gcr.io/gem5-test/gcn-gpu:v21-2 bash -c \ + "${gem5_root}" gcr.io/gem5-test/gcn-gpu:latest bash -c \ "scons build/${gpu_isa}/gem5.opt -j${compile_threads} \ || (rm -rf build && scons build/${gpu_isa}/gem5.opt -j${compile_threads})" # get square -wget -qN http://dist.gem5.org/dist/v21-2/test-progs/square/square +wget -qN http://dist.gem5.org/dist/develop/test-progs/square/square mkdir -p tests/testing-results @@ -118,18 +118,18 @@ mkdir -p tests/testing-results # Thus, we always want to run this in the nightly regressions to make sure # basic GPU functionality is working. docker run --rm -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ - "${gem5_root}" gcr.io/gem5-test/gcn-gpu:v21-2 build/${gpu_isa}/gem5.opt \ + "${gem5_root}" gcr.io/gem5-test/gcn-gpu:latest build/${gpu_isa}/gem5.opt \ configs/example/apu_se.py --reg-alloc-policy=dynamic -n3 -c square # get HeteroSync -wget -qN http://dist.gem5.org/dist/v21-2/test-progs/heterosync/gcn3/allSyncPrims-1kernel +wget -qN http://dist.gem5.org/dist/develop/test-progs/heterosync/gcn3/allSyncPrims-1kernel # run HeteroSync sleepMutex -- 16 WGs (4 per CU in default config), each doing # 10 Ld/St per thread and 4 iterations of the critical section is a reasonable # moderate contention case for the default 4 CU GPU config and help ensure GPU # atomics are tested. docker run --rm -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ - "${gem5_root}" gcr.io/gem5-test/gcn-gpu:v21-2 build/${gpu_isa}/gem5.opt \ + "${gem5_root}" gcr.io/gem5-test/gcn-gpu:latest build/${gpu_isa}/gem5.opt \ configs/example/apu_se.py --reg-alloc-policy=dynamic -n3 -c \ allSyncPrims-1kernel --options="sleepMutex 10 16 4" @@ -139,7 +139,7 @@ docker run --rm -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ # moderate contention case for the default 4 CU GPU config and help ensure GPU # atomics are tested. docker run --rm -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ - "${gem5_root}" gcr.io/gem5-test/gcn-gpu:v21-2 build/${gpu_isa}/gem5.opt \ + "${gem5_root}" gcr.io/gem5-test/gcn-gpu:latest build/${gpu_isa}/gem5.opt \ configs/example/apu_se.py --reg-alloc-policy=dynamic -n3 -c \ allSyncPrims-1kernel --options="lfTreeBarrUniq 10 16 4" @@ -149,7 +149,7 @@ build_and_run_SST () { variant=$2 docker run -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ - "${gem5_root}" --rm gcr.io/gem5-test/sst-env:v21-2 \ + "${gem5_root}" --rm gcr.io/gem5-test/sst-env:latest \ bash -c "\ scons build/${isa}/libgem5_${variant}.so -j${compile_threads} --without-tcmalloc; \ cd ext/sst; \ diff --git a/tests/weekly.sh b/tests/weekly.sh index b6eda61932..8acb5d79e8 100755 --- a/tests/weekly.sh +++ b/tests/weekly.sh @@ -56,7 +56,7 @@ fi # Run the gem5 very-long tests. docker run -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ "${gem5_root}"/tests --rm \ - gcr.io/gem5-test/ubuntu-20.04_all-dependencies:v21-2 \ + gcr.io/gem5-test/ubuntu-20.04_all-dependencies:latest \ ./main.py run --length very-long -j${threads} -t${threads} -vv mkdir -p tests/testing-results @@ -64,7 +64,7 @@ mkdir -p tests/testing-results # GPU weekly tests start here # before pulling gem5 resources, make sure it doesn't exist already docker run --rm --volume "${gem5_root}":"${gem5_root}" -w \ - "${gem5_root}" gcr.io/gem5-test/gcn-gpu:v21-2 bash -c \ + "${gem5_root}" gcr.io/gem5-test/gcn-gpu:latest bash -c \ "rm -rf ${gem5_root}/gem5-resources" # delete Pannotia datasets and output files in case a failed regression run left # them around @@ -91,13 +91,17 @@ git clone https://gem5.googlesource.com/public/gem5-resources \ # To ensure the v21.2 version of these tests continues to run as future # versions are released, we run this check. If there's been another release, # we checkout the correct version of gem5 resources. +# +# Note: We disable this code on the develop branch and just checkout develop. + cd "${gem5_root}/gem5-resources" -version_tag=$(git tag | grep "v21.2") - -if [[ ${version_tag} != "" ]]; then - git checkout "${version_tag}" -fi - +git checkout develop +#version_tag=$(git tag | grep "v21.2") +# +#if [[ ${version_tag} != "" ]]; then +# git checkout "${version_tag}" +#fi +# cd "${gem5_root}" # For the GPU tests we compile and run the GPU ISA inside a gcn-gpu container. @@ -105,7 +109,7 @@ cd "${gem5_root}" # avoid needing to set all of these, we instead build a docker for it, which # has all these variables pre-set in its Dockerfile # To avoid compiling gem5 multiple times, all GPU benchmarks will use this -docker pull gcr.io/gem5-test/gcn-gpu:v21-2 +docker pull gcr.io/gem5-test/gcn-gpu:latest docker build -t hacc-test-weekly ${gem5_root}/gem5-resources/src/gpu/halo-finder docker run --rm -u $UID:$GID --volume "${gem5_root}":"${gem5_root}" -w \ @@ -225,7 +229,7 @@ docker run --rm -v ${PWD}:${PWD} \ "export GEM5_PATH=${gem5_root} ; make gem5-fusion" # # get input dataset for BC test -wget http://dist.gem5.org/dist/v21-2/datasets/pannotia/bc/1k_128k.gr +wget http://dist.gem5.org/dist/develop/datasets/pannotia/bc/1k_128k.gr # run BC docker run --rm -v ${gem5_root}:${gem5_root} -w ${gem5_root} -u $UID:$GID \ hacc-test-weekly ${gem5_root}/build/${gpu_isa}/gem5.opt \ @@ -297,7 +301,7 @@ docker run --rm -v ${gem5_root}:${gem5_root} -w \ "export GEM5_PATH=${gem5_root} ; make gem5-fusion" # get PageRank input dataset -wget http://dist.gem5.org/dist/v21-2/datasets/pannotia/pagerank/coAuthorsDBLP.graph +wget http://dist.gem5.org/dist/develop/datasets/pannotia/pagerank/coAuthorsDBLP.graph # run PageRank (Default) docker run --rm -v ${gem5_root}:${gem5_root} -w ${gem5_root} -u $UID:$GID \ hacc-test-weekly ${gem5_root}/build/${gpu_isa}/gem5.opt \ diff --git a/util/dockerfiles/gcn-gpu/Dockerfile b/util/dockerfiles/gcn-gpu/Dockerfile index 50d34bd6c6..8dd1b1b139 100644 --- a/util/dockerfiles/gcn-gpu/Dockerfile +++ b/util/dockerfiles/gcn-gpu/Dockerfile @@ -70,7 +70,7 @@ RUN git clone -b rocm-4.0.0 \ WORKDIR /ROCclr # The patch allows us to avoid building blit kernels on-the-fly in gem5 -RUN wget -q -O - dist.gem5.org/dist/v21-2/rocm_patches/ROCclr.patch | git apply -v +RUN wget -q -O - dist.gem5.org/dist/develop/rocm_patches/ROCclr.patch | git apply -v WORKDIR /ROCclr/build RUN cmake -DOPENCL_DIR="/ROCm-OpenCL-Runtime" \ From 6a44472b1c48b9992092bf0b943398ff883dac17 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Mon, 27 Dec 2021 15:33:40 -0800 Subject: [PATCH 019/658] mem: Add 'controller()' function to NVMInterface.py As noted here: https://gem5.atlassian.net/browse/GEM5-1133, NVMInterface.py does not have a `controller()` function, which is used by `configs/common/MemConfig.py` to obtain a memory controller for a specific memory type selected. This patch adds a `controller()` function to `NVNInterface.py` to avoid the reported error. It should be noted that we do not enforce a rule that a memory type must include a `controller()` function. `se.py`, and other scrips that use `configs/common/MemConfigs.py`, should not rely on this false assumption. Change-Id: Ieba62f803d3b9f9c5c3c863d5a8c4ca16c5e5e82 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54923 Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce Tested-by: kokoro --- src/mem/NVMInterface.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/mem/NVMInterface.py b/src/mem/NVMInterface.py index 5c8b27b39f..7c6690128b 100644 --- a/src/mem/NVMInterface.py +++ b/src/mem/NVMInterface.py @@ -35,6 +35,7 @@ from m5.params import * from m5.proxy import * +from m5.objects.MemCtrl import MemCtrl from m5.objects.MemInterface import MemInterface from m5.objects.DRAMInterface import AddrMap @@ -65,6 +66,16 @@ class NVMInterface(MemInterface): two_cycle_rdwr = Param.Bool(False, "Two cycles required to send read and write commands") + + def controller(self): + """ + Instantiate the memory controller and bind it to + the current interface. + """ + controller = MemCtrl() + controller.nvm = self + return controller + # NVM delays and device architecture defined to mimic PCM like memory. # Can be configured with DDR4_2400 sharing the channel class NVM_2400_1x64(NVMInterface): From ee5b65955e06369a202ff2d4afb783415ad68344 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Tue, 28 Dec 2021 16:29:47 -0800 Subject: [PATCH 020/658] python: Fix `get_simstat` func for non-Root SimObject case The `get_simstat` function in `src/python/m5/stats/gem5stats.py` was returning an error when a non-Root Simobject was passed: ``` AttributeError: object 'PyTrafficGen' has no attribute 'name' At: build/NULL_MESI_Two_Level/python/m5/SimObject.py(1430): __getattr__ build/NULL_MESI_Two_Level/python/m5/stats/gem5stats.py(279): get_simstat ``` The issue was an assumption that SimObjects have a field `name`. They do not. To get a SimObject's name the `get_name()` function must be used. This patch fixes this issue. In addition to this fix, the documentation in this function has been improved to state more clearly what can be passed and what shall be returned. Previously it was somewhat unclear. Change-Id: I33538120015280bb6260ccf8eba6b75ff43d280e Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54943 Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce Tested-by: kokoro --- src/python/m5/stats/gem5stats.py | 27 ++++++++++++++++----------- 1 file changed, 16 insertions(+), 11 deletions(-) diff --git a/src/python/m5/stats/gem5stats.py b/src/python/m5/stats/gem5stats.py index 9a2259aab5..3b4bc7eb6c 100644 --- a/src/python/m5/stats/gem5stats.py +++ b/src/python/m5/stats/gem5stats.py @@ -234,17 +234,21 @@ def _prepare_stats(group: _m5.stats.Group): _prepare_stats(child) -def get_simstat(root: Union[Root, List[SimObject]], +def get_simstat(root: Union[SimObject, List[SimObject]], prepare_stats: bool = True) -> SimStat: """ - This function will return the SimStat object for a simulation. From the - SimStat object all stats within the current gem5 simulation are present. + This function will return the SimStat object for a simulation given a + SimObject (typically a Root SimObject), or list of SimObjects. The returned + SimStat object will contain all the stats for all the SimObjects contained + within the "root", inclusive of the "root" SimObject/SimObjects. Parameters ---------- - root: Union[Root, List[Root]] - The root, or a list of Simobjects, of the simulation for translation to - a SimStat object. + root: Union[SimObject, List[SimObject]] + A SimObject, or list of SimObjects, of the simulation for translation + into a SimStat object. Typically this is the simulation's Root + SimObject as this will obtain the entirety of a run's statistics in a + single SimStat object. prepare_stats: bool Dictates whether the stats are to be prepared prior to creating the @@ -269,6 +273,8 @@ def get_simstat(root: Union[Root, List[SimObject]], for r in root: if isinstance(r, Root): + # The Root is a special case, we jump directly into adding its + # constituent Groups. if prepare_stats: _prepare_stats(r) for key in r.getStatGroups(): @@ -276,12 +282,11 @@ def get_simstat(root: Union[Root, List[SimObject]], elif isinstance(r, SimObject): if prepare_stats: _prepare_stats(r) - stats_map[r.name] = get_stats_group(r) + stats_map[r.get_name()] = get_stats_group(r) else: - raise TypeError("Object (" + str(r) + ") passed is neither Root " - "nor SimObject. " + __name__ + " only processes " - "Roots, SimObjects, or a list of Roots and/or " - "SimObjects.") + raise TypeError("Object (" + str(r) + ") passed is not a " + "SimObject. " + __name__ + " only processes " + "SimObjects, or a list of SimObjects.") From ec58d9d7f37663dc32055e4976a110784e3833f3 Mon Sep 17 00:00:00 2001 From: Daecheol You Date: Fri, 17 Dec 2021 10:16:19 +0900 Subject: [PATCH 021/658] mem-ruby: Fix message stall time calculation Three changes below: 1. The m_stall_time was declared as statistics::Average, but statistics::Average uses AvgStor as storage and this works as per-tick average stat. In the case of m_stall_time, Scalar should be used to get the calculation right. 2. The function used to get an enqueue time was changed since the getTime() returns the time when the message was created. 3. Record the stall time only when the message is really dequeued from the buffer (stall time is not evaluated when the message is moved to stall map). Change-Id: I090d19828b5c43f0843a8b735d3f00f312c436e9 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54363 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/mem/ruby/network/MessageBuffer.cc | 38 ++++++++++++++++++++------- src/mem/ruby/network/MessageBuffer.hh | 4 ++- 2 files changed, 32 insertions(+), 10 deletions(-) diff --git a/src/mem/ruby/network/MessageBuffer.cc b/src/mem/ruby/network/MessageBuffer.cc index f4b2bb58da..5c0e11694f 100644 --- a/src/mem/ruby/network/MessageBuffer.cc +++ b/src/mem/ruby/network/MessageBuffer.cc @@ -64,13 +64,23 @@ MessageBuffer::MessageBuffer(const Params &p) m_last_arrival_time(0), m_strict_fifo(p.ordered), m_randomization(p.randomization), m_allow_zero_latency(p.allow_zero_latency), - ADD_STAT(m_not_avail_count, "Number of times this buffer did not have " - "N slots available"), - ADD_STAT(m_buf_msgs, "Average number of messages in buffer"), - ADD_STAT(m_stall_time, "Average number of cycles messages are stalled in " - "this MB"), - ADD_STAT(m_stall_count, "Number of times messages were stalled"), - ADD_STAT(m_occupancy, "Average occupancy of buffer capacity") + ADD_STAT(m_not_avail_count, statistics::units::Count::get(), + "Number of times this buffer did not have N slots available"), + ADD_STAT(m_msg_count, statistics::units::Count::get(), + "Number of messages passed the buffer"), + ADD_STAT(m_buf_msgs, statistics::units::Rate< + statistics::units::Count, statistics::units::Tick>::get(), + "Average number of messages in buffer"), + ADD_STAT(m_stall_time, statistics::units::Tick::get(), + "Total number of ticks messages were stalled in this buffer"), + ADD_STAT(m_stall_count, statistics::units::Count::get(), + "Number of times messages were stalled"), + ADD_STAT(m_avg_stall_time, statistics::units::Rate< + statistics::units::Tick, statistics::units::Count>::get(), + "Average stall ticks per message"), + ADD_STAT(m_occupancy, statistics::units::Rate< + statistics::units::Ratio, statistics::units::Tick>::get(), + "Average occupancy of buffer capacity") { m_msg_counter = 0; m_consumer = NULL; @@ -93,12 +103,18 @@ MessageBuffer::MessageBuffer(const Params &p) m_not_avail_count .flags(statistics::nozero); + m_msg_count + .flags(statistics::nozero); + m_buf_msgs .flags(statistics::nozero); m_stall_count .flags(statistics::nozero); + m_avg_stall_time + .flags(statistics::nozero | statistics::nonan); + m_occupancy .flags(statistics::nozero); @@ -110,6 +126,8 @@ MessageBuffer::MessageBuffer(const Params &p) } else { m_occupancy = 0; } + + m_avg_stall_time = m_stall_time / m_msg_count; } unsigned int @@ -288,8 +306,6 @@ MessageBuffer::dequeue(Tick current_time, bool decrement_messages) message->updateDelayedTicks(current_time); Tick delay = message->getDelayedTicks(); - m_stall_time = curTick() - message->getTime(); - // record previous size and time so the current buffer size isn't // adjusted until schd cycle if (m_time_last_time_pop < current_time) { @@ -301,6 +317,10 @@ MessageBuffer::dequeue(Tick current_time, bool decrement_messages) pop_heap(m_prio_heap.begin(), m_prio_heap.end(), std::greater()); m_prio_heap.pop_back(); if (decrement_messages) { + // Record how much time is passed since the message was enqueued + m_stall_time += curTick() - message->getLastEnqueueTime(); + m_msg_count++; + // If the message will be removed from the queue, decrement the // number of message in the queue. m_buf_msgs--; diff --git a/src/mem/ruby/network/MessageBuffer.hh b/src/mem/ruby/network/MessageBuffer.hh index ff2a4dde1e..7a48a1df7d 100644 --- a/src/mem/ruby/network/MessageBuffer.hh +++ b/src/mem/ruby/network/MessageBuffer.hh @@ -264,9 +264,11 @@ class MessageBuffer : public SimObject // Count the # of times I didn't have N slots available statistics::Scalar m_not_avail_count; + statistics::Scalar m_msg_count; statistics::Average m_buf_msgs; - statistics::Average m_stall_time; + statistics::Scalar m_stall_time; statistics::Scalar m_stall_count; + statistics::Formula m_avg_stall_time; statistics::Formula m_occupancy; }; From 66e6e5966672bc78030a73e78f1dde44a4dab431 Mon Sep 17 00:00:00 2001 From: Jiasen Huang Date: Fri, 31 Dec 2021 15:55:45 +0800 Subject: [PATCH 022/658] mem-cache: pstAddress should be inserted into PST in STeMS Change-Id: Ib2c4c5fb0fec32e63947d3ee8dcb5c3d7e2555ab Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55084 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Reviewed-by: Daniel Carvalho Tested-by: kokoro --- .../cache/prefetch/spatio_temporal_memory_streaming.cc | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc index 6030096612..f610288ae0 100644 --- a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc +++ b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc @@ -74,6 +74,7 @@ STeMS::checkForActiveGenerationsEnd() if (agt_entry.isValid()) { bool generation_ended = false; bool sr_is_secure = agt_entry.isSecure(); + Addr pst_addr = 0; for (auto &seq_entry : agt_entry.sequence) { if (seq_entry.counter > 0) { Addr cache_addr = @@ -81,6 +82,8 @@ STeMS::checkForActiveGenerationsEnd() if (!inCache(cache_addr, sr_is_secure) && !inMissQueue(cache_addr, sr_is_secure)) { generation_ended = true; + pst_addr = (agt_entry.pc << spatialRegionSizeBits) + + seq_entry.offset; break; } } @@ -88,13 +91,13 @@ STeMS::checkForActiveGenerationsEnd() if (generation_ended) { // PST is indexed using the PC (secure bit is unused) ActiveGenerationTableEntry *pst_entry = - patternSequenceTable.findEntry(agt_entry.pc, + patternSequenceTable.findEntry(pst_addr, false /*unused*/); if (pst_entry == nullptr) { // Tipically an entry will not exist - pst_entry = patternSequenceTable.findVictim(agt_entry.pc); + pst_entry = patternSequenceTable.findVictim(pst_addr); assert(pst_entry != nullptr); - patternSequenceTable.insertEntry(agt_entry.pc, + patternSequenceTable.insertEntry(pst_addr, false /*unused*/, pst_entry); } else { patternSequenceTable.accessEntry(pst_entry); From ec32f6c6f03c96bd6d8a1c6e02c0e7938a3d0057 Mon Sep 17 00:00:00 2001 From: Jiasen Huang Date: Fri, 31 Dec 2021 12:40:09 +0800 Subject: [PATCH 023/658] mem-cache: Add switch on/off duplicate entries into RMOB Change-Id: I394d7c852a439be5315c4755b091c8741e671ea3 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55083 Reviewed-by: Daniel Carvalho Maintainer: Daniel Carvalho Tested-by: kokoro --- src/mem/cache/prefetch/Prefetcher.py | 2 ++ .../prefetch/spatio_temporal_memory_streaming.cc | 11 +++++++++++ .../prefetch/spatio_temporal_memory_streaming.hh | 3 +++ 3 files changed, 16 insertions(+) diff --git a/src/mem/cache/prefetch/Prefetcher.py b/src/mem/cache/prefetch/Prefetcher.py index 7d704881b4..024004e57b 100644 --- a/src/mem/cache/prefetch/Prefetcher.py +++ b/src/mem/cache/prefetch/Prefetcher.py @@ -488,6 +488,8 @@ class STeMSPrefetcher(QueuedPrefetcher): region_miss_order_buffer_entries = Param.Unsigned(131072, "Number of entries of the Region Miss Order Buffer") + add_duplicate_entries_to_rmob = Param.Bool(True, + "Add duplicate entries to RMOB") reconstruction_entries = Param.Unsigned(256, "Number of reconstruction entries") diff --git a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc index f610288ae0..3c9b9eb64c 100644 --- a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc +++ b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.cc @@ -56,6 +56,7 @@ STeMS::STeMS(const STeMSPrefetcherParams &p) ActiveGenerationTableEntry( spatialRegionSize / blkSize)), rmob(p.region_miss_order_buffer_entries), + addDuplicateEntriesToRMOB(p.add_duplicate_entries_to_rmob), lastTriggerCounter(0) { fatal_if(!isPowerOf2(spatialRegionSize), @@ -120,6 +121,16 @@ STeMS::addToRMOB(Addr sr_addr, Addr pst_addr, unsigned int delta) rmob_entry.pstAddress = pst_addr; rmob_entry.delta = delta; + if (!addDuplicateEntriesToRMOB) { + for (const auto& entry : rmob) { + if (entry.srAddress == sr_addr && + entry.pstAddress == pst_addr && + entry.delta == delta) { + return; + } + } + } + rmob.push_back(rmob_entry); } diff --git a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.hh b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.hh index e5914b4555..bee746c5c7 100644 --- a/src/mem/cache/prefetch/spatio_temporal_memory_streaming.hh +++ b/src/mem/cache/prefetch/spatio_temporal_memory_streaming.hh @@ -175,6 +175,9 @@ class STeMS : public Queued /** Region Miss Order Buffer (RMOB) */ CircularQueue rmob; + /** Add duplicate entries to RMOB */ + bool addDuplicateEntriesToRMOB; + /** Counter to keep the count of accesses between trigger accesses */ unsigned int lastTriggerCounter; From 1f155ffd9047b5d098d7302e5d32cdf8aa5450d2 Mon Sep 17 00:00:00 2001 From: Luming Wang Date: Thu, 23 Dec 2021 16:05:39 +0800 Subject: [PATCH 024/658] arch-riscv,sim-se: Complements the system calls on RISC-V There are many SE mode system calls that are implemented in src/sim/syscall_emul.cc or src/sim/syscall_emul.hh. And they work well under X86 and ARM platforms. However, they are not supported in se_workload.cc under the RISC-V platform. This patch adds support for all the system calls already implemented in syscall_emul.hh/cc to the RISC-V platform (in arch/riscv/linux/se_workload.cc). Change-Id: Ia47c3c113767b50412b1c8ade3c1047c894376cf Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54803 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro Reviewed-by: Bobby Bruce --- src/arch/riscv/linux/se_workload.cc | 132 ++++++++++++++-------------- 1 file changed, 66 insertions(+), 66 deletions(-) diff --git a/src/arch/riscv/linux/se_workload.cc b/src/arch/riscv/linux/se_workload.cc index 2e2a7d2f2b..815b63b699 100644 --- a/src/arch/riscv/linux/se_workload.cc +++ b/src/arch/riscv/linux/se_workload.cc @@ -157,8 +157,8 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 30, "ioprio_get" }, { 31, "ioprio_set" }, { 32, "flock" }, - { 33, "mknodat" }, - { 34, "mkdirat" }, + { 33, "mknodat", mknodatFunc }, + { 34, "mkdirat", mkdiratFunc }, { 35, "unlinkat", unlinkatFunc }, { 36, "symlinkat" }, { 37, "linkat" }, @@ -173,7 +173,7 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 46, "ftruncate", ftruncate64Func }, { 47, "fallocate", fallocateFunc }, { 48, "faccessat", faccessatFunc }, - { 49, "chdir" }, + { 49, "chdir", chdirFunc }, { 50, "fchdir" }, { 51, "chroot" }, { 52, "fchmod", fchmodFunc }, @@ -183,14 +183,14 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 56, "openat", openatFunc }, { 57, "close", closeFunc }, { 58, "vhangup" }, - { 59, "pipe2" }, + { 59, "pipe2", pipe2Func }, { 60, "quotactl" }, - { 61, "getdents64" }, + { 61, "getdents64", getdents64Func }, { 62, "lseek", lseekFunc }, { 63, "read", readFunc }, { 64, "write", writeFunc }, { 66, "writev", writevFunc }, - { 67, "pread64" }, + { 67, "pread64", pread64Func }, { 68, "pwrite64", pwrite64Func }, { 69, "preadv" }, { 70, "pwritev" }, @@ -246,7 +246,7 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 120, "sched_getscheduler" }, { 121, "sched_getparam" }, { 122, "sched_setaffinity" }, - { 123, "sched_getaffinity" }, + { 123, "sched_getaffinity", schedGetaffinityFunc }, { 124, "sched_yield", ignoreWarnOnceFunc }, { 125, "sched_get_priority_max" }, { 126, "sched_get_priority_min" }, @@ -291,7 +291,7 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 165, "getrusage", getrusageFunc }, { 166, "umask", umaskFunc }, { 167, "prctl" }, - { 168, "getcpu" }, + { 168, "getcpu", getcpuFunc }, { 169, "gettimeofday", gettimeofdayFunc }, { 170, "settimeofday" }, { 171, "adjtimex" }, @@ -321,21 +321,21 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 195, "shmctl" }, { 196, "shmat" }, { 197, "shmdt" }, - { 198, "socket" }, - { 199, "socketpair" }, - { 200, "bind" }, - { 201, "listen" }, - { 202, "accept" }, - { 203, "connect" }, - { 204, "getsockname" }, - { 205, "getpeername" }, + { 198, "socket", socketFunc }, + { 199, "socketpair", socketpairFunc }, + { 200, "bind", bindFunc }, + { 201, "listen", listenFunc }, + { 202, "accept", acceptFunc }, + { 203, "connect", connectFunc }, + { 204, "getsockname", getsocknameFunc }, + { 205, "getpeername", getpeernameFunc }, { 206, "sendo" }, - { 207, "recvfrom" }, - { 208, "setsockopt" }, - { 209, "getsockopt" }, - { 210, "shutdown" }, - { 211, "sendmsg" }, - { 212, "recvmsg" }, + { 207, "recvfrom", recvfromFunc }, + { 208, "setsockopt", setsockoptFunc }, + { 209, "getsockopt", getsockoptFunc }, + { 210, "shutdown", shutdownFunc }, + { 211, "sendmsg", sendmsgFunc }, + { 212, "recvmsg", recvmsgFunc }, { 213, "readahead" }, { 214, "brk", brkFunc }, { 215, "munmap", munmapFunc }, @@ -367,7 +367,7 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 241, "perf_event_open" }, { 242, "accept4" }, { 243, "recvmmsg" }, - { 260, "wait4" }, + { 260, "wait4", wait4Func }, { 261, "prlimit64", prlimitFunc }, { 262, "fanotify_init" }, { 263, "fanotify_mark" }, @@ -396,18 +396,18 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 286, "preadv2" }, { 287, "pwritev2" }, { 1024, "open", openFunc }, - { 1025, "link" }, + { 1025, "link", linkFunc }, { 1026, "unlink", unlinkFunc }, - { 1027, "mknod" }, + { 1027, "mknod", mknodFunc }, { 1028, "chmod", chmodFunc }, { 1029, "chown", chownFunc }, { 1030, "mkdir", mkdirFunc }, - { 1031, "rmdir" }, + { 1031, "rmdir", rmdirFunc }, { 1032, "lchown" }, { 1033, "access", accessFunc }, { 1034, "rename", renameFunc }, { 1035, "readlink", readlinkFunc }, - { 1036, "symlink" }, + { 1036, "symlink", symlinkFunc }, { 1037, "utimes", utimesFunc }, { 1038, "stat", stat64Func }, { 1039, "lstat", lstat64Func }, @@ -415,7 +415,7 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 1041, "dup2", dup2Func }, { 1042, "epoll_create" }, { 1043, "inotifiy_init" }, - { 1044, "eventfd" }, + { 1044, "eventfd", eventfdFunc }, { 1045, "signalfd" }, { 1046, "sendfile" }, { 1047, "ftruncate", ftruncate64Func }, @@ -425,21 +425,21 @@ SyscallDescTable EmuLinux::syscallDescs64 = { { 1051, "fstat", fstat64Func }, { 1052, "fcntl", fcntl64Func }, { 1053, "fadvise64" }, - { 1054, "newfstatat" }, + { 1054, "newfstatat", newfstatatFunc }, { 1055, "fstatfs", fstatfsFunc }, { 1056, "statfs", statfsFunc }, { 1057, "lseek", lseekFunc }, { 1058, "mmap", mmapFunc }, { 1059, "alarm" }, - { 1060, "getpgrp" }, + { 1060, "getpgrp", getpgrpFunc }, { 1061, "pause" }, { 1062, "time", timeFunc }, { 1063, "utime" }, { 1064, "creat" }, - { 1065, "getdents" }, + { 1065, "getdents", getdentsFunc }, { 1066, "futimesat" }, - { 1067, "select" }, - { 1068, "poll" }, + { 1067, "select", selectFunc }, + { 1068, "poll", pollFunc }, { 1069, "epoll_wait" }, { 1070, "ustat" }, { 1071, "vfork" }, @@ -488,8 +488,8 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 30, "ioprio_get" }, { 31, "ioprio_set" }, { 32, "flock" }, - { 33, "mknodat" }, - { 34, "mkdirat" }, + { 33, "mknodat", mknodatFunc }, + { 34, "mkdirat", mkdiratFunc }, { 35, "unlinkat", unlinkatFunc }, { 36, "symlinkat" }, { 37, "linkat" }, @@ -504,7 +504,7 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 46, "ftruncate", ftruncateFunc }, { 47, "fallocate", fallocateFunc }, { 48, "faccessat", faccessatFunc }, - { 49, "chdir" }, + { 49, "chdir", chdirFunc }, { 50, "fchdir" }, { 51, "chroot" }, { 52, "fchmod", fchmodFunc }, @@ -514,14 +514,14 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 56, "openat", openatFunc }, { 57, "close", closeFunc }, { 58, "vhangup" }, - { 59, "pipe2" }, + { 59, "pipe2", pipe2Func }, { 60, "quotactl" }, - { 61, "getdents64" }, + { 61, "getdents64", getdents64Func }, { 62, "lseek", lseekFunc }, { 63, "read", readFunc }, { 64, "write", writeFunc }, { 66, "writev", writevFunc }, - { 67, "pread64" }, + { 67, "pread64", pread64Func }, { 68, "pwrite64", pwrite64Func }, { 69, "preadv" }, { 70, "pwritev" }, @@ -577,7 +577,7 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 120, "sched_getscheduler" }, { 121, "sched_getparam" }, { 122, "sched_setaffinity" }, - { 123, "sched_getaffinity" }, + { 123, "sched_getaffinity", schedGetaffinityFunc }, { 124, "sched_yield", ignoreWarnOnceFunc }, { 125, "sched_get_priority_max" }, { 126, "sched_get_priority_min" }, @@ -622,7 +622,7 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 165, "getrusage", getrusageFunc }, { 166, "umask", umaskFunc }, { 167, "prctl" }, - { 168, "getcpu" }, + { 168, "getcpu", getcpuFunc }, { 169, "gettimeofday", gettimeofdayFunc }, { 170, "settimeofday" }, { 171, "adjtimex" }, @@ -652,21 +652,21 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 195, "shmctl" }, { 196, "shmat" }, { 197, "shmdt" }, - { 198, "socket" }, - { 199, "socketpair" }, - { 200, "bind" }, - { 201, "listen" }, - { 202, "accept" }, - { 203, "connect" }, - { 204, "getsockname" }, - { 205, "getpeername" }, + { 198, "socket", socketFunc }, + { 199, "socketpair", socketpairFunc }, + { 200, "bind", bindFunc }, + { 201, "listen", listenFunc }, + { 202, "accept", acceptFunc }, + { 203, "connect", connectFunc }, + { 204, "getsockname", getsocknameFunc }, + { 205, "getpeername", getpeernameFunc }, { 206, "sendo" }, - { 207, "recvfrom" }, - { 208, "setsockopt" }, - { 209, "getsockopt" }, - { 210, "shutdown" }, - { 211, "sendmsg" }, - { 212, "recvmsg" }, + { 207, "recvfrom", recvfromFunc }, + { 208, "setsockopt", setsockoptFunc }, + { 209, "getsockopt", getsockoptFunc }, + { 210, "shutdown", shutdownFunc }, + { 211, "sendmsg", sendmsgFunc }, + { 212, "recvmsg", recvmsgFunc }, { 213, "readahead" }, { 214, "brk", brkFunc }, { 215, "munmap", munmapFunc }, @@ -698,7 +698,7 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 241, "perf_event_open" }, { 242, "accept4" }, { 243, "recvmmsg" }, - { 260, "wait4" }, + { 260, "wait4", wait4Func }, { 261, "prlimit64", prlimitFunc }, { 262, "fanotify_init" }, { 263, "fanotify_mark" }, @@ -727,18 +727,18 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 286, "preadv2" }, { 287, "pwritev2" }, { 1024, "open", openFunc }, - { 1025, "link" }, + { 1025, "link", linkFunc }, { 1026, "unlink", unlinkFunc }, - { 1027, "mknod" }, + { 1027, "mknod", mknodFunc }, { 1028, "chmod", chmodFunc }, { 1029, "chown", chownFunc }, { 1030, "mkdir", mkdirFunc }, - { 1031, "rmdir" }, + { 1031, "rmdir", rmdirFunc }, { 1032, "lchown" }, { 1033, "access", accessFunc }, { 1034, "rename", renameFunc }, { 1035, "readlink", readlinkFunc }, - { 1036, "symlink" }, + { 1036, "symlink", symlinkFunc }, { 1037, "utimes", utimesFunc }, { 1038, "stat", statFunc }, { 1039, "lstat", lstatFunc }, @@ -746,7 +746,7 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 1041, "dup2", dup2Func }, { 1042, "epoll_create" }, { 1043, "inotifiy_init" }, - { 1044, "eventfd" }, + { 1044, "eventfd", eventfdFunc }, { 1045, "signalfd" }, { 1046, "sendfile" }, { 1047, "ftruncate", ftruncateFunc }, @@ -756,21 +756,21 @@ SyscallDescTable EmuLinux::syscallDescs32 = { { 1051, "fstat", fstatFunc }, { 1052, "fcntl", fcntlFunc }, { 1053, "fadvise64" }, - { 1054, "newfstatat" }, + { 1054, "newfstatat", newfstatatFunc }, { 1055, "fstatfs", fstatfsFunc }, { 1056, "statfs", statfsFunc }, { 1057, "lseek", lseekFunc }, { 1058, "mmap", mmapFunc }, { 1059, "alarm" }, - { 1060, "getpgrp" }, + { 1060, "getpgrp", getpgrpFunc }, { 1061, "pause" }, { 1062, "time", timeFunc }, { 1063, "utime" }, { 1064, "creat" }, - { 1065, "getdents" }, + { 1065, "getdents", getdentsFunc }, { 1066, "futimesat" }, - { 1067, "select" }, - { 1068, "poll" }, + { 1067, "select", selectFunc }, + { 1068, "poll", pollFunc }, { 1069, "epoll_wait" }, { 1070, "ustat" }, { 1071, "vfork" }, From 5ac54aab7e28bf14846bc1c9fc30edbde26d81c7 Mon Sep 17 00:00:00 2001 From: Alex Richardson Date: Wed, 29 Dec 2021 13:16:40 +0000 Subject: [PATCH 025/658] misc: Generate StateMachine debug includes in deterministic order Since 3454a4a36e927f483b36fa66baabe2c85ecf3ddc the order of the debug/ includes is non-deterministic which can result in unnecessary rebuilds. Change-Id: I583d2caf70632e08fa59ac85073786270991edbc Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54983 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/mem/slicc/symbols/StateMachine.py | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/mem/slicc/symbols/StateMachine.py b/src/mem/slicc/symbols/StateMachine.py index 5d315e98bf..a9f7373238 100644 --- a/src/mem/slicc/symbols/StateMachine.py +++ b/src/mem/slicc/symbols/StateMachine.py @@ -105,6 +105,8 @@ class StateMachine(Symbol): self.objects = [] self.TBEType = None self.EntryType = None + # Python's sets are not sorted so we have to be careful when using + # this to generate deterministic output. self.debug_flags = set() self.debug_flags.add('RubyGenerated') self.debug_flags.add('RubySlicc') @@ -516,8 +518,9 @@ void unset_tbe(${{self.TBEType.c_ident}}*& m_tbe_ptr); code(boolvec_include) code(base_include) - - for f in self.debug_flags: + # We have to sort self.debug_flags in order to produce deterministic + # output and avoid unnecessary rebuilds of the generated files. + for f in sorted(self.debug_flags): code('#include "debug/${{f}}.hh"') code(''' #include "mem/ruby/network/Network.hh" @@ -1246,7 +1249,9 @@ $c_ident::functionalReadBuffers(PacketPtr& pkt, WriteMask &mask) #include "base/logging.hh" ''') - for f in self.debug_flags: + # We have to sort self.debug_flags in order to produce deterministic + # output and avoid unnecessary rebuilds of the generated files. + for f in sorted(self.debug_flags): code('#include "debug/${{f}}.hh"') code(''' #include "mem/ruby/protocol/${ident}_Controller.hh" From f894de5486d57e6f0611f0968763515d4f7d8b3a Mon Sep 17 00:00:00 2001 From: Eric Ye Date: Wed, 29 Dec 2021 17:03:38 -0800 Subject: [PATCH 026/658] scons: Try to fix build dependency bug when generating fastmodels Bug: 201084562 Change-Id: I33cc9e09b1ce46f80864d75f088a2534949e55e1 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55043 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/arm/fastmodel/SConscript | 54 +++++++++++++++++++------------ 1 file changed, 33 insertions(+), 21 deletions(-) diff --git a/src/arch/arm/fastmodel/SConscript b/src/arch/arm/fastmodel/SConscript index 63b1b167e6..ccfc6205d0 100644 --- a/src/arch/arm/fastmodel/SConscript +++ b/src/arch/arm/fastmodel/SConscript @@ -250,6 +250,34 @@ license_count = int(env['ARMLMD_LICENSE_COUNT']) arm_licenses = list((Value(object()) for i in range(license_count))) license_cycle = cycle(arm_licenses) +# HACK: Make sure the gic protocol headers are somewhere we can find them. +# These should start out alongside other headers fast model provides which we +# are already able to include, but unfortunately they're in the examples +# directory. +gicv3_comms_headers = ( + 'gicv3_comms_base.h', 'gicv3_comms_if.h', 'gicv3_comms_sockets.h') +examples_common_dir = pvlib_home.Dir('examples/SystemCExport/Common') +gic_protocol_path = 'Protocols/GICv3Comms' +gic_protocol_dest = Dir(env['BUILDDIR']).Dir(gic_protocol_path) +gic_protocol_src = examples_common_dir.Dir(gic_protocol_path) + +for header in gicv3_comms_headers: + Command(gic_protocol_dest.File(header), gic_protocol_src.File(header), + Copy('${TARGET}', '${SOURCE}')) +# Since we are copying the source files to a different directory, Scons's +# dependency scanner does not pick up the dependency between these files. +# Specify them manually. +env.Depends(gic_protocol_dest.File('gicv3_comms_base.h'), + gic_protocol_dest.File('gicv3_comms_if.h')) +env.Depends(gic_protocol_dest.File('gicv3_comms_sockets.h'), + gic_protocol_dest.File('gicv3_comms_if.h')) + +common_headers = ('lisa_protocol_types.h', 'tlm_has_get_protocol_types.h') +for header in common_headers: + header_target = gic_protocol_dest.Dir('include').File(header) + header_src = examples_common_dir.Dir('include').File(header) + Command(header_target, header_src, Copy('${TARGET}', '${SOURCE}')) + class ArmFastModelComponent(object): def __init__(self, project_file, *extra_deps): project_file = File(project_file) @@ -320,6 +348,11 @@ class ArmFastModelComponent(object): sources = [project_file] sources.extend(extra_deps) + # The simgen-generated .lisa files may #include these gicv3 files, but + # SCons does not detect this dependency since they are generated files. + # Add the dependencies manually. + sources.extend([gic_protocol_dest.File('gicv3_comms_sockets.h'), + gic_protocol_dest.File('gicv3_comms_base.h')]) env.Command(lib_nodes + self.headers + [self.log], sources, Action(self.simgen_builder, Transform('SIMGEN'))) # Distribute simgen actions among ARM license slots. All actions which @@ -357,24 +390,3 @@ SimObject('FastModel.py', sim_objects=[ 'AmbaToTlmBridge64', 'AmbaFromTlmBridge64']) Source('amba_to_tlm_bridge.cc') Source('amba_from_tlm_bridge.cc') - -# HACK: Make sure the gic protocol headers are somewhere we can find them. -# These should start out alongside other headers fast model provides which we -# are already able to include, but unfortunately they're in the examples -# directory. -gicv3_comms_headers = ( - 'gicv3_comms_base.h', 'gicv3_comms_if.h', 'gicv3_comms_sockets.h') -examples_common_dir = pvlib_home.Dir('examples/SystemCExport/Common') -gic_protocol_path = 'Protocols/GICv3Comms' -gic_protocol_dest = Dir(env['BUILDDIR']).Dir(gic_protocol_path) -gic_protocol_src = examples_common_dir.Dir(gic_protocol_path) - -for header in gicv3_comms_headers: - Command(gic_protocol_dest.File(header), gic_protocol_src.File(header), - Copy('${TARGET}', '${SOURCE}')) - -common_headers = ('lisa_protocol_types.h', 'tlm_has_get_protocol_types.h') -for header in common_headers: - header_target = gic_protocol_dest.Dir('include').File(header) - header_src = examples_common_dir.Dir('include').File(header) - Command(header_target, header_src, Copy('${TARGET}', '${SOURCE}')) From 5af49d03da4e0c49fc3a7d5b69463060d6ed84a7 Mon Sep 17 00:00:00 2001 From: Alistair Delva Date: Tue, 14 Dec 2021 10:13:57 -0800 Subject: [PATCH 027/658] base: Add support for DT initrd/initramfs Add a new API function, addBootData(), which allows the ports to specify the size and load address of the initrd/initramfs via DeviceTree. This uses the standard chosen nodes for initrd-start/initrd-end. Update the addBootCmdline() to call addBootData() with no initrd/initramfs so as to maintain backwards compatibility. Change-Id: I7b1d5cf2a0b18685eaadf1d881434f3d48c45d8b Signed-off-by: Alistair Delva Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54183 Reviewed-by: Richard Cooper Maintainer: Giacomo Travaglini Tested-by: kokoro --- src/base/loader/dtb_file.cc | 35 +++++++++++++++++++++++++++++++---- src/base/loader/dtb_file.hh | 16 +++++++++++++++- 2 files changed, 46 insertions(+), 5 deletions(-) diff --git a/src/base/loader/dtb_file.cc b/src/base/loader/dtb_file.cc index f89b1ae611..13e0264e92 100644 --- a/src/base/loader/dtb_file.cc +++ b/src/base/loader/dtb_file.cc @@ -63,12 +63,15 @@ DtbFile::~DtbFile() } bool -DtbFile::addBootCmdLine(const char *_args, size_t len) +DtbFile::addBootData(const char *_cmdline, size_t cmdline_len, + off_t initrd_start, size_t initrd_len) { const char *root_path = "/"; const char *node_name = "chosen"; const char *full_path_node_name = "/chosen"; - const char *property_name = "bootargs"; + const char *bootargs_property_name = "bootargs"; + const char *linux_initrd_start_property_name = "linux,initrd-start"; + const char *linux_initrd_end_property_name = "linux,initrd-end"; // Make a new buffer that has extra space to add nodes/properties int newLen = 2 * length; @@ -102,8 +105,8 @@ DtbFile::addBootCmdLine(const char *_args, size_t len) } // Set the bootargs property in the /chosen node - ret = fdt_setprop((void *)fdt_buf_w_space, offset, property_name, - (const void *)_args, len+1); + ret = fdt_setprop((void *)fdt_buf_w_space, offset, bootargs_property_name, + (const void *)_cmdline, cmdline_len+1); if (ret < 0) { warn("Error setting \"bootargs\" property to flattened device tree, " "errno: %d\n", ret); @@ -111,6 +114,30 @@ DtbFile::addBootCmdLine(const char *_args, size_t len) return false; } + if (initrd_len != 0) { + // Set the linux,initrd-start property in the /chosen node + ret = fdt_setprop_u64((void *)fdt_buf_w_space, offset, + linux_initrd_start_property_name, + (uint64_t)initrd_start); + if (ret < 0) { + warn("Error setting \"linux,initrd-start\" property to flattened " + "device tree, errno: %d\n", ret); + delete [] fdt_buf_w_space; + return false; + } + + // Set the computed linux,initrd-end property in the /chosen node + ret = fdt_setprop_u64((void *)fdt_buf_w_space, offset, + linux_initrd_end_property_name, + (uint64_t)initrd_start + initrd_len); + if (ret < 0) { + warn("Error setting \"linux,initrd-len\" property to flattened " + "device tree, errno: %d\n", ret); + delete [] fdt_buf_w_space; + return false; + } + } + // Repack the dtb for kernel use ret = fdt_pack((void *)fdt_buf_w_space); if (ret < 0) { diff --git a/src/base/loader/dtb_file.hh b/src/base/loader/dtb_file.hh index f0a211f6df..c11b19539e 100644 --- a/src/base/loader/dtb_file.hh +++ b/src/base/loader/dtb_file.hh @@ -58,13 +58,27 @@ class DtbFile : public ImageFile DtbFile(const std::string &name); ~DtbFile(); + /** Adds the passed in Command Line options and initrd for the kernel + * to the proper location in the device tree. + * @param _cmdline command line to append + * @param cmdline_len length of the command line string + * @param initrd_addr starting physical address of initrd + * @param initrd_len length of initrd data in memory + * @return returns true on success, false otherwise + */ + bool addBootData(const char* _cmdline, size_t cmdline_len, + off_t initrd_addr, size_t initrd_len); + /** Adds the passed in Command Line options for the kernel * to the proper location in the device tree. * @param _args command line to append * @param len length of the command line string * @return returns true on success, false otherwise */ - bool addBootCmdLine(const char* _args, size_t len); + inline bool + addBootCmdLine(const char* _args, size_t len) { + return addBootData(_args, len, 0, 0); + } /** Parse the DTB file enough to find the provided release * address and return it. From cb7799648b7f3344e05bb171d3e8fa9948e141b0 Mon Sep 17 00:00:00 2001 From: Alistair Delva Date: Tue, 14 Dec 2021 10:22:06 -0800 Subject: [PATCH 028/658] arch-arm: Add support for initrd/initramfs Add initrd_filename and initrd_addr parameters to specify that an initrd/initramfs should be loaded into memory from a file, just like the DTB blob. The user must specify the initrd file, and they can specify the initrd load address as well. However, in practice, it's expected that the dev/machine backend will derive the initrd load address from the dtb load address, which is how a bootloader would typically do it. Change-Id: I6378927c2984b7ccdd1471486dd7803500ef5883 Signed-off-by: Alistair Delva Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54184 Reviewed-by: Richard Cooper Reviewed-by: Giacomo Travaglini Maintainer: Giacomo Travaglini Tested-by: kokoro --- src/arch/arm/ArmFsWorkload.py | 3 +++ src/arch/arm/linux/fs_workload.cc | 19 +++++++++++++++++-- 2 files changed, 20 insertions(+), 2 deletions(-) diff --git a/src/arch/arm/ArmFsWorkload.py b/src/arch/arm/ArmFsWorkload.py index 974600bfdd..43bbd16a06 100644 --- a/src/arch/arm/ArmFsWorkload.py +++ b/src/arch/arm/ArmFsWorkload.py @@ -58,6 +58,9 @@ class ArmFsWorkload(KernelWorkload): dtb_filename = Param.String("", "File that contains the Device Tree Blob. Don't use DTB if empty.") dtb_addr = Param.Addr(0, "DTB or ATAGS address") + initrd_filename = Param.String("", + "File that contains the initial ramdisk. Don't use initrd if empty.") + initrd_addr = Param.Addr(0, "initrd/initramfs address") cpu_release_addr = Param.Addr(0, "cpu-release-addr property") machine_type = Param.ArmMachineType('DTOnly', diff --git a/src/arch/arm/linux/fs_workload.cc b/src/arch/arm/linux/fs_workload.cc index d5120673d7..e724eb1962 100644 --- a/src/arch/arm/linux/fs_workload.cc +++ b/src/arch/arm/linux/fs_workload.cc @@ -91,6 +91,21 @@ FsLinux::initState() bool dtb_file_specified = params().dtb_filename != ""; if (kernel_has_fdt_support && dtb_file_specified) { + bool initrd_file_specified = params().initrd_filename != ""; + size_t initrd_len = 0; + + if (initrd_file_specified) { + inform("Loading initrd file: %s at address %#x\n", + params().initrd_filename, params().initrd_addr); + + loader::ImageFileDataPtr initrd_file_data( + new loader::ImageFileData(params().initrd_filename)); + system->physProxy.writeBlob(params().initrd_addr, + initrd_file_data->data(), + initrd_file_data->len()); + initrd_len = initrd_file_data->len(); + } + // Kernel supports flattened device tree and dtb file specified. // Using Device Tree Blob to describe system configuration. inform("Loading DTB file: %s at address %#x\n", params().dtb_filename, @@ -98,8 +113,8 @@ FsLinux::initState() auto *dtb_file = new loader::DtbFile(params().dtb_filename); - if (!dtb_file->addBootCmdLine( - commandLine.c_str(), commandLine.size())) { + if (!dtb_file->addBootData(commandLine.c_str(), commandLine.size(), + params().initrd_addr, initrd_len)) { warn("couldn't append bootargs to DTB file: %s\n", params().dtb_filename); } From 75cd1ff764f5a27cececee571730d13468a2f68c Mon Sep 17 00:00:00 2001 From: Alistair Delva Date: Tue, 14 Dec 2021 10:26:44 -0800 Subject: [PATCH 029/658] dev-arm: Add RealView support for initrd/initramfs Update the RealView bootloader simulator to set up the initrd_addr. The load address is derived from the dtb_addr plus the maximum allowable DTB blob size. Change-Id: I2eaeb1ade38d24ad8e02230cc99d12873c2f56f9 Signed-off-by: Alistair Delva Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54185 Reviewed-by: Richard Cooper Maintainer: Giacomo Travaglini Tested-by: kokoro --- src/dev/arm/RealView.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/dev/arm/RealView.py b/src/dev/arm/RealView.py index 2b86227380..32299836e4 100644 --- a/src/dev/arm/RealView.py +++ b/src/dev/arm/RealView.py @@ -750,6 +750,8 @@ class RealView(Platform): cur_sys.workload.boot_loader = boot_loader cur_sys.workload.load_addr_offset = load_offset cur_sys.workload.dtb_addr = load_offset + dtb_addr + # Use 0x200000 as this is the maximum size allowed for a DTB + cur_sys.workload.initrd_addr = cur_sys.workload.dtb_addr + 0x200000 cur_sys.workload.cpu_release_addr = cur_sys.workload.dtb_addr - 8 def generateDeviceTree(self, state): From 791da53cf8fc0495897d931cf2f64eb3174ff254 Mon Sep 17 00:00:00 2001 From: Alistair Delva Date: Tue, 14 Dec 2021 10:29:22 -0800 Subject: [PATCH 030/658] configs: Add support for initrd/initramfs Allow the user to specify the path to an initrd/initramfs file which will be loaded in memory after the DTB. The load address for this data will be passed to Linux via DeviceTree. Change-Id: I52e12b9b88ab415fe3b318a6359026651667f3c6 Signed-off-by: Alistair Delva Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54186 Reviewed-by: Giacomo Travaglini Reviewed-by: Richard Cooper Maintainer: Giacomo Travaglini Tested-by: kokoro --- configs/example/arm/starter_fs.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/configs/example/arm/starter_fs.py b/configs/example/arm/starter_fs.py index 40e645b564..a5a013f1af 100644 --- a/configs/example/arm/starter_fs.py +++ b/configs/example/arm/starter_fs.py @@ -148,6 +148,9 @@ def create(args): os.path.join(m5.options.outdir, 'system.dtb') system.generateDtb(system.workload.dtb_filename) + if args.initrd: + system.workload.initrd_filename = args.initrd + # Linux boot command flags kernel_cmd = [ # Tell Linux to use the simulated serial port as a console @@ -196,6 +199,8 @@ def main(): help="DTB file to load") parser.add_argument("--kernel", type=str, default=default_kernel, help="Linux kernel") + parser.add_argument("--initrd", type=str, default=None, + help="initrd/initramfs file to load") parser.add_argument("--disk-image", type=str, default=default_disk, help="Disk to instantiate") From 5e3c64da4ead9f8f3428a0011c2417306891710d Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Thu, 6 Jan 2022 11:42:06 -0800 Subject: [PATCH 031/658] base: Improve ImageFileData's error when file failed to open When a user accidentally specifies the wrong path to a file, the following error is received: ``` build/X86/base/loader/image_file_data.cc:111: panic: panic condition fd < 0 occurred: Failed to open file {path}. ``` For new users to gem5 this is confusing, and does not explicitly state that the root cause of the issue is likely due to the path being incorrect. Due to use of `panic_if`, this error was followed by a long and unhelpful backtrace. This patch expands the error message to state this error is typically triggered when the specified path is incorrect. It also changes the `panic_if` to a `fatal_if`. As noted in `src/base/logging.hh`, a "panic() should be called when something happens that should never ever happen", while a "fatal() should be called when the simulation cannot continue due to some condition that is the user's fault". It is clear a `fatal_if` is more suitable here as it is typically a user error. A backtrace is not printed for `fatal`, only for `panic`. Change-Id: I6e0a9bf4efb27ee00a40d77d74fd0dc99f9be4f8 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55183 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Reviewed-by: Daniel Carvalho Tested-by: kokoro --- src/base/loader/image_file_data.cc | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/base/loader/image_file_data.cc b/src/base/loader/image_file_data.cc index f99c5f36d4..57fb47fd4c 100644 --- a/src/base/loader/image_file_data.cc +++ b/src/base/loader/image_file_data.cc @@ -108,7 +108,9 @@ ImageFileData::ImageFileData(const std::string &fname) // Open the file. int fd = open(fname.c_str(), O_RDONLY); - panic_if(fd < 0, "Failed to open file %s.\n", fname); + fatal_if(fd < 0, "Failed to open file %s.\n" + "This error typically occurs when the file path specified is " + "incorrect.\n", fname); // Decompress GZ files. if (hasGzipMagic(fd)) { From 7c882f7d154cd6e5e116ce3862a39d53cfc9cef9 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Thu, 6 Jan 2022 11:52:15 -0800 Subject: [PATCH 032/658] base: Add missing ']' in version ID Change-Id: I73ac530fde2fff29022aa800f4de925709d9c2f5 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55184 Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce Reviewed-by: Jason Lowe-Power Tested-by: kokoro --- src/base/version.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/base/version.cc b/src/base/version.cc index 56c982fa28..61b2a5e033 100644 --- a/src/base/version.cc +++ b/src/base/version.cc @@ -32,6 +32,6 @@ namespace gem5 /** * @ingroup api_base_utils */ -const char *gem5Version = "[DEVELOP-FOR-v22.0"; +const char *gem5Version = "[DEVELOP-FOR-v22.0]"; } // namespace gem5 From e5187e279a0c29762d3a266c59690f603690e328 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Tue, 23 Nov 2021 04:09:46 -0800 Subject: [PATCH 033/658] tests: Decrease the iterations of the checkpoint test to 3. Currently, the test in realview64-simple-atomic-checkpoint.py runs the default number of checkpoint cycles which is 5. Each of these cycles takes a long time to run (approximately 5 minutes) which makes this test take a long time to run to completion. We would get almost all of the benefit of this test in a fraction of the time if we reduce the number of iterations down to 3. This still has enough iterations to catch bugs which would happen in one, a different class of bugs which happen when checkpointing more than once, and even a third iteration for safety. Because this test is one of the (if not the) most time consuming test in the quick tests, reducing its length will significantly improve turn around time when running all those tests. That is especially valuable when running the tests multiple times to try to iterate on a bug, or when sweeping through a series of changes trying to identify the source of breakages. In cases where we might need to identify failures which don't effect the end product of a series, ie where a problem is introduced and then coincidentally fixed in a later change, this is especially important since every individual change needs to be checked, not just log(n) of the changes like in a binary search. Ideally in the future we will also try to figure out why taking and restoring from checkpoints takes so long so that each iteration of this test is substantially less expensive. If we do that, we could consider increasing the iteration count again. Change-Id: Icfa2a391a4a7457d893f2063fab231d22e572deb Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/53123 Maintainer: Bobby Bruce Tested-by: kokoro Reviewed-by: Giacomo Travaglini Maintainer: Giacomo Travaglini --- tests/gem5/configs/realview64-simple-atomic-checkpoint.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/gem5/configs/realview64-simple-atomic-checkpoint.py b/tests/gem5/configs/realview64-simple-atomic-checkpoint.py index 2a3ee7a554..37dcbc6bbd 100644 --- a/tests/gem5/configs/realview64-simple-atomic-checkpoint.py +++ b/tests/gem5/configs/realview64-simple-atomic-checkpoint.py @@ -43,5 +43,5 @@ root = LinuxArmFSSystemUniprocessor(mem_mode='atomic', mem_class=SimpleMemory, cpu_class=AtomicSimpleCPU).create_root() -run_test = functools.partial(checkpoint.run_test, interval=0.2) - +run_test = functools.partial(checkpoint.run_test, interval=0.2, + max_checkpoints=3) From 614b608a08ae8b22c844e2874b4fb8aed2732a77 Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Mon, 13 Dec 2021 17:54:45 +0800 Subject: [PATCH 034/658] fastmodel: Add an example reset controller for IrisCpu The example reset controller provides a register interface to config RVBAR and ability to reset the core. Change-Id: I088ddde6f44ff9cc5914afb834ec07a8f7f269fa Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54065 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- .../FastModelResetControllerExample.py | 40 ++++++ .../arm/fastmodel/reset_controller/SConscript | 34 +++++ .../arm/fastmodel/reset_controller/example.cc | 136 ++++++++++++++++++ .../arm/fastmodel/reset_controller/example.hh | 88 ++++++++++++ 4 files changed, 298 insertions(+) create mode 100644 src/arch/arm/fastmodel/reset_controller/FastModelResetControllerExample.py create mode 100644 src/arch/arm/fastmodel/reset_controller/SConscript create mode 100644 src/arch/arm/fastmodel/reset_controller/example.cc create mode 100644 src/arch/arm/fastmodel/reset_controller/example.hh diff --git a/src/arch/arm/fastmodel/reset_controller/FastModelResetControllerExample.py b/src/arch/arm/fastmodel/reset_controller/FastModelResetControllerExample.py new file mode 100644 index 0000000000..b9327f4582 --- /dev/null +++ b/src/arch/arm/fastmodel/reset_controller/FastModelResetControllerExample.py @@ -0,0 +1,40 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.params import * +from m5.proxy import * + +from m5.objects.Device import BasicPioDevice +from m5.objects.IntPin import IntSourcePin +from m5.objects.Iris import IrisBaseCPU + +class FastModelResetControllerExample(BasicPioDevice): + type = 'FastModelResetControllerExample' + cxx_class = 'gem5::fastmodel::ResetControllerExample' + cxx_header = 'arch/arm/fastmodel/reset_controller/example.hh' + + cpu = Param.IrisBaseCPU('target cpu') + reset = IntSourcePin('reset pin') + halt = IntSourcePin('halt pin') diff --git a/src/arch/arm/fastmodel/reset_controller/SConscript b/src/arch/arm/fastmodel/reset_controller/SConscript new file mode 100644 index 0000000000..3230e5d306 --- /dev/null +++ b/src/arch/arm/fastmodel/reset_controller/SConscript @@ -0,0 +1,34 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Import('*') + +if not env['USE_ARM_FASTMODEL']: + Return() + +SimObject('FastModelResetControllerExample.py', sim_objects=[ + 'FastModelResetControllerExample']) + +Source('example.cc') diff --git a/src/arch/arm/fastmodel/reset_controller/example.cc b/src/arch/arm/fastmodel/reset_controller/example.cc new file mode 100644 index 0000000000..33769acb30 --- /dev/null +++ b/src/arch/arm/fastmodel/reset_controller/example.cc @@ -0,0 +1,136 @@ +/* + * Copyright 2021 Google, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "arch/arm/fastmodel/reset_controller/example.hh" + +#include + +#include "base/logging.hh" + +namespace gem5 +{ +namespace fastmodel +{ + +ResetControllerExample::CorePins::CorePins(const std::string &module_name) + : reset(module_name + ".reset", 0, this), + halt(module_name + ".halt", 0, this) +{} + +ResetControllerExample::Registers::Registers( + const std::string &module_name, Iris::BaseCPU *c, CorePins *p) + : RegisterBankLE(module_name, 0), cpu(c), pins(p), + nsrvbar(module_name + ".nsrvbar"), + rvbar(module_name + ".rvbar"), + reset(module_name + ".reset"), + halt(module_name + ".halt") +{ + panic_if(cpu == nullptr, "ResetControllerExample needs a target cpu."); + nsrvbar.writer( + [this] (auto ®, auto val) + { + cpu->setResetAddr(val, false); + }); + rvbar.writer( + [this] (auto ®, auto val) + { + cpu->setResetAddr(val, true); + }); + reset.writer( + [this] (auto ®, auto val) + { + panic_if(!pins->reset.isConnected(), + "%s is not connected.", pins->reset.name()); + + if (val) + pins->reset.raise(); + else + pins->reset.lower(); + }); + halt.writer( + [this] (auto ®, auto val) + { + panic_if(!pins->halt.isConnected(), + "%s is not connected.", pins->halt.name()); + + if (val) + pins->halt.raise(); + else + pins->halt.lower(); + }); + + addRegisters({ + nsrvbar, + rvbar, + reset, + halt, + }); +} + +ResetControllerExample::ResetControllerExample(const Params &p) + : BasicPioDevice(p, 0x20), + pins(p.name + ".pins"), + registers(p.name + ".registers", p.cpu, &pins) +{} + +Tick +ResetControllerExample::read(PacketPtr pkt) +{ + pkt->makeResponse(); + auto data = pkt->getPtr(); + auto size = pkt->getSize(); + std::fill(data, data + size, 0); + return pioDelay; +} + +Tick +ResetControllerExample::write(PacketPtr pkt) +{ + pkt->makeResponse(); + size_t size = pkt->getSize(); + if (size != 4 && size != 8) { + pkt->setBadAddress(); + } else { + auto addr = pkt->getAddr() - pioAddr; + registers.write(addr, pkt->getPtr(), size); + } + return pioDelay; +} + +Port & +ResetControllerExample::getPort(const std::string &if_name, PortID idx) +{ + if (if_name == "reset") + return pins.reset; + else if (if_name == "halt") + return pins.halt; + + return BasicPioDevice::getPort(if_name, idx); +} + +} // namespace fastmodel +} // namespace gem5 diff --git a/src/arch/arm/fastmodel/reset_controller/example.hh b/src/arch/arm/fastmodel/reset_controller/example.hh new file mode 100644 index 0000000000..2805d6f077 --- /dev/null +++ b/src/arch/arm/fastmodel/reset_controller/example.hh @@ -0,0 +1,88 @@ +/* + * Copyright 2021 Google, Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __ARCH_ARM_FASTMODEL_RESET_CONTROLLER_EXAMPLE_HH__ +#define __ARCH_ARM_FASTMODEL_RESET_CONTROLLER_EXAMPLE_HH__ + +#include + +#include "arch/arm/fastmodel/iris/cpu.hh" +#include "dev/intpin.hh" +#include "dev/io_device.hh" +#include "dev/reg_bank.hh" +#include "mem/packet_access.hh" +#include "params/FastModelResetControllerExample.hh" + +namespace gem5 +{ + +namespace fastmodel +{ + +class ResetControllerExample : public BasicPioDevice +{ + private: + struct CorePins + { + using CoreInt = IntSourcePin; + CoreInt reset; + CoreInt halt; + + explicit CorePins(const std::string &); + }; + + class Registers : public RegisterBankLE + { + private: + Iris::BaseCPU *cpu; + CorePins *pins; + + Register64 nsrvbar; + Register64 rvbar; + Register32 reset; + Register32 halt; + + public: + Registers(const std::string &, Iris::BaseCPU *, CorePins *); + }; + + CorePins pins; + Registers registers; + + public: + using Params = FastModelResetControllerExampleParams; + explicit ResetControllerExample(const Params &); + + Tick read(PacketPtr pkt) override; + Tick write(PacketPtr pkt) override; + Port &getPort(const std::string &, PortID = InvalidPortID) override; +}; + +} // namespace fastmodel +} // namespace gem5 + +#endif // __ARCH_ARM_FASTMODEL_RESET_CONTROLLER_EXAMPLE_HH__ From dc48de5e62a5671871dc94399211f21ae1fa39f8 Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Mon, 10 Jan 2022 13:36:20 +0800 Subject: [PATCH 035/658] configs: Fix parameters change when WalkCache is removed Change-Id: I3e8d2ae60e64d18462f6782484be500c5c514003 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55303 Reviewed-by: Giacomo Travaglini Maintainer: Giacomo Travaglini Tested-by: kokoro --- configs/example/arm/devices.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/configs/example/arm/devices.py b/configs/example/arm/devices.py index 9122e7ce3e..a488ab3755 100644 --- a/configs/example/arm/devices.py +++ b/configs/example/arm/devices.py @@ -176,7 +176,7 @@ class CpuCluster(SubSystem): class AtomicCluster(CpuCluster): def __init__(self, system, num_cpus, cpu_clock, cpu_voltage="1.0V"): cpu_config = [ ObjectList.cpu_list.get("AtomicSimpleCPU"), None, - None, None, None ] + None, None ] super(AtomicCluster, self).__init__(system, num_cpus, cpu_clock, cpu_voltage, *cpu_config) def addL1(self): @@ -185,7 +185,7 @@ class AtomicCluster(CpuCluster): class KvmCluster(CpuCluster): def __init__(self, system, num_cpus, cpu_clock, cpu_voltage="1.0V"): cpu_config = [ ObjectList.cpu_list.get("ArmV8KvmCPU"), None, None, - None, None ] + None ] super(KvmCluster, self).__init__(system, num_cpus, cpu_clock, cpu_voltage, *cpu_config) def addL1(self): From 5a94e73d00f131775b7634b8f42a769c8e3ad9f0 Mon Sep 17 00:00:00 2001 From: Matthew Poremba Date: Mon, 10 Jan 2022 15:13:35 -0600 Subject: [PATCH 036/658] arch-vega: Validate if scalar sources are scalar gprs Port the fixes for scalar source checks from arch-gcn3 at https://gem5-review.googlesource.com/c/public/gem5/+/48344. Scalar sources can either be a general-purpose register or a constant register that holds a single value. If we don't check for if the register is a general-purpose register, it's possible that we get a constant register, which then causes all of the register mapping code to break, as the constant registers aren't supposed to be mapped like the general-purpose registers are. This fix adds an isScalarReg check to the instruction encodings that were missing it. Change-Id: I30dd2d082a5a1dcc3075843bcefd325113ed1df6 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55343 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/amdgpu/vega/insts/op_encodings.cc | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/arch/amdgpu/vega/insts/op_encodings.cc b/src/arch/amdgpu/vega/insts/op_encodings.cc index 40910e4cac..6f78b6962e 100644 --- a/src/arch/amdgpu/vega/insts/op_encodings.cc +++ b/src/arch/amdgpu/vega/insts/op_encodings.cc @@ -1274,12 +1274,12 @@ namespace VegaISA reg = extData.SRSRC; srcOps.emplace_back(reg, getOperandSize(opNum), true, - true, false, false); + isScalarReg(reg), false, false); opNum++; reg = extData.SOFFSET; srcOps.emplace_back(reg, getOperandSize(opNum), true, - true, false, false); + isScalarReg(reg), false, false); opNum++; } @@ -1365,12 +1365,12 @@ namespace VegaISA reg = extData.SRSRC; srcOps.emplace_back(reg, getOperandSize(opNum), true, - true, false, false); + isScalarReg(reg), false, false); opNum++; reg = extData.SOFFSET; srcOps.emplace_back(reg, getOperandSize(opNum), true, - true, false, false); + isScalarReg(reg), false, false); opNum++; // extData.VDATA moves in the reg list depending on the instruction @@ -1438,13 +1438,13 @@ namespace VegaISA reg = extData.SRSRC; srcOps.emplace_back(reg, getOperandSize(opNum), true, - true, false, false); + isScalarReg(reg), false, false); opNum++; if (getNumOperands() == 4) { reg = extData.SSAMP; srcOps.emplace_back(reg, getOperandSize(opNum), true, - true, false, false); + isScalarReg(reg), false, false); opNum++; } From d6bd91a9fd4d6598e92034a4166ab7878c238fb8 Mon Sep 17 00:00:00 2001 From: Matthew Poremba Date: Mon, 10 Jan 2022 15:14:49 -0600 Subject: [PATCH 037/658] arch-vega: Implement large ds_read/write instructions Port large DS read/write instructions from https://gem5-review.googlesource.com/c/public/gem5/+/48342. This implements the 96 and 128b ds_read/write instructions in a similar fashion to the 3 and 4 dword flat_load/store instructions. These instructions are treated as reads/writes of 3 or 4 dwords, instead of as a single 96b/128b memory transaction, due to the limitations of the VecOperand class used in the amdgpu code. In order to handle treating the memory transaction as multiple dwords, the patch also adds in new initMemRead/initMemWrite functions for ds instructions. These are similar to the functions used in flat instructions for the same purpose. Change-Id: Iee2de14eb7f32b6654799d53dc97d806288af98f Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55344 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/amdgpu/vega/insts/instructions.cc | 190 ++++++++++++++++++++- src/arch/amdgpu/vega/insts/instructions.hh | 8 + src/arch/amdgpu/vega/insts/op_encodings.hh | 38 +++++ 3 files changed, 232 insertions(+), 4 deletions(-) diff --git a/src/arch/amdgpu/vega/insts/instructions.cc b/src/arch/amdgpu/vega/insts/instructions.cc index 56ccc3df55..7d5562451f 100644 --- a/src/arch/amdgpu/vega/insts/instructions.cc +++ b/src/arch/amdgpu/vega/insts/instructions.cc @@ -37766,8 +37766,51 @@ namespace VegaISA void Inst_DS__DS_WRITE_B96::execute(GPUDynInstPtr gpuDynInst) { - panicUnimplemented(); + Wavefront *wf = gpuDynInst->wavefront(); + gpuDynInst->execUnitId = wf->execUnitId; + gpuDynInst->latency.init(gpuDynInst->computeUnit()); + gpuDynInst->latency.set( + gpuDynInst->computeUnit()->cyclesToTicks(Cycles(24))); + ConstVecOperandU32 addr(gpuDynInst, extData.ADDR); + ConstVecOperandU32 data0(gpuDynInst, extData.DATA0); + ConstVecOperandU32 data1(gpuDynInst, extData.DATA0 + 1); + ConstVecOperandU32 data2(gpuDynInst, extData.DATA0 + 2); + + addr.read(); + data0.read(); + data1.read(); + data2.read(); + + calcAddr(gpuDynInst, addr); + + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4] = data0[lane]; + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 1] = data1[lane]; + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 2] = data2[lane]; + } + } + + gpuDynInst->computeUnit()->localMemoryPipe.issueRequest(gpuDynInst); } // execute + + void + Inst_DS__DS_WRITE_B96::initiateAcc(GPUDynInstPtr gpuDynInst) + { + Addr offset0 = instData.OFFSET0; + Addr offset1 = instData.OFFSET1; + Addr offset = (offset1 << 8) | offset0; + + initMemWrite<3>(gpuDynInst, offset); + } // initiateAcc + + void + Inst_DS__DS_WRITE_B96::completeAcc(GPUDynInstPtr gpuDynInst) + { + } // completeAcc // --- Inst_DS__DS_WRITE_B128 class methods --- Inst_DS__DS_WRITE_B128::Inst_DS__DS_WRITE_B128(InFmt_DS *iFmt) @@ -37787,8 +37830,55 @@ namespace VegaISA void Inst_DS__DS_WRITE_B128::execute(GPUDynInstPtr gpuDynInst) { - panicUnimplemented(); + Wavefront *wf = gpuDynInst->wavefront(); + gpuDynInst->execUnitId = wf->execUnitId; + gpuDynInst->latency.init(gpuDynInst->computeUnit()); + gpuDynInst->latency.set( + gpuDynInst->computeUnit()->cyclesToTicks(Cycles(24))); + ConstVecOperandU32 addr(gpuDynInst, extData.ADDR); + ConstVecOperandU32 data0(gpuDynInst, extData.DATA0); + ConstVecOperandU32 data1(gpuDynInst, extData.DATA0 + 1); + ConstVecOperandU32 data2(gpuDynInst, extData.DATA0 + 2); + ConstVecOperandU32 data3(gpuDynInst, extData.DATA0 + 3); + + addr.read(); + data0.read(); + data1.read(); + data2.read(); + data3.read(); + + calcAddr(gpuDynInst, addr); + + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4] = data0[lane]; + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 1] = data1[lane]; + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 2] = data2[lane]; + (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 3] = data3[lane]; + } + } + + gpuDynInst->computeUnit()->localMemoryPipe.issueRequest(gpuDynInst); } // execute + + void + Inst_DS__DS_WRITE_B128::initiateAcc(GPUDynInstPtr gpuDynInst) + { + Addr offset0 = instData.OFFSET0; + Addr offset1 = instData.OFFSET1; + Addr offset = (offset1 << 8) | offset0; + + initMemWrite<4>(gpuDynInst, offset); + } // initiateAcc + + void + Inst_DS__DS_WRITE_B128::completeAcc(GPUDynInstPtr gpuDynInst) + { + } // completeAcc // --- Inst_DS__DS_READ_B96 class methods --- Inst_DS__DS_READ_B96::Inst_DS__DS_READ_B96(InFmt_DS *iFmt) @@ -37807,8 +37897,52 @@ namespace VegaISA void Inst_DS__DS_READ_B96::execute(GPUDynInstPtr gpuDynInst) { - panicUnimplemented(); + Wavefront *wf = gpuDynInst->wavefront(); + gpuDynInst->execUnitId = wf->execUnitId; + gpuDynInst->latency.init(gpuDynInst->computeUnit()); + gpuDynInst->latency.set( + gpuDynInst->computeUnit()->cyclesToTicks(Cycles(24))); + ConstVecOperandU32 addr(gpuDynInst, extData.ADDR); + + addr.read(); + + calcAddr(gpuDynInst, addr); + + gpuDynInst->computeUnit()->localMemoryPipe.issueRequest(gpuDynInst); } // execute + + void + Inst_DS__DS_READ_B96::initiateAcc(GPUDynInstPtr gpuDynInst) + { + Addr offset0 = instData.OFFSET0; + Addr offset1 = instData.OFFSET1; + Addr offset = (offset1 << 8) | offset0; + + initMemRead<3>(gpuDynInst, offset); + } + + void + Inst_DS__DS_READ_B96::completeAcc(GPUDynInstPtr gpuDynInst) + { + VecOperandU32 vdst0(gpuDynInst, extData.VDST); + VecOperandU32 vdst1(gpuDynInst, extData.VDST + 1); + VecOperandU32 vdst2(gpuDynInst, extData.VDST + 2); + + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + vdst0[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4]; + vdst1[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 1]; + vdst2[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 2]; + } + } + + vdst0.write(); + vdst1.write(); + vdst2.write(); + } // --- Inst_DS__DS_READ_B128 class methods --- Inst_DS__DS_READ_B128::Inst_DS__DS_READ_B128(InFmt_DS *iFmt) @@ -37827,8 +37961,56 @@ namespace VegaISA void Inst_DS__DS_READ_B128::execute(GPUDynInstPtr gpuDynInst) { - panicUnimplemented(); + Wavefront *wf = gpuDynInst->wavefront(); + gpuDynInst->execUnitId = wf->execUnitId; + gpuDynInst->latency.init(gpuDynInst->computeUnit()); + gpuDynInst->latency.set( + gpuDynInst->computeUnit()->cyclesToTicks(Cycles(24))); + ConstVecOperandU32 addr(gpuDynInst, extData.ADDR); + + addr.read(); + + calcAddr(gpuDynInst, addr); + + gpuDynInst->computeUnit()->localMemoryPipe.issueRequest(gpuDynInst); } // execute + + void + Inst_DS__DS_READ_B128::initiateAcc(GPUDynInstPtr gpuDynInst) + { + Addr offset0 = instData.OFFSET0; + Addr offset1 = instData.OFFSET1; + Addr offset = (offset1 << 8) | offset0; + + initMemRead<4>(gpuDynInst, offset); + } // initiateAcc + + void + Inst_DS__DS_READ_B128::completeAcc(GPUDynInstPtr gpuDynInst) + { + VecOperandU32 vdst0(gpuDynInst, extData.VDST); + VecOperandU32 vdst1(gpuDynInst, extData.VDST + 1); + VecOperandU32 vdst2(gpuDynInst, extData.VDST + 2); + VecOperandU32 vdst3(gpuDynInst, extData.VDST + 3); + + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + vdst0[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4]; + vdst1[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 1]; + vdst2[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 2]; + vdst3[lane] = (reinterpret_cast( + gpuDynInst->d_data))[lane * 4 + 3]; + } + } + + vdst0.write(); + vdst1.write(); + vdst2.write(); + vdst3.write(); + } // completeAcc // --- Inst_MUBUF__BUFFER_LOAD_FORMAT_X class methods --- Inst_MUBUF__BUFFER_LOAD_FORMAT_X diff --git a/src/arch/amdgpu/vega/insts/instructions.hh b/src/arch/amdgpu/vega/insts/instructions.hh index 95c66ba90a..e14f52f8f4 100644 --- a/src/arch/amdgpu/vega/insts/instructions.hh +++ b/src/arch/amdgpu/vega/insts/instructions.hh @@ -35542,6 +35542,8 @@ namespace VegaISA } // getOperandSize void execute(GPUDynInstPtr) override; + void initiateAcc(GPUDynInstPtr) override; + void completeAcc(GPUDynInstPtr) override; }; // Inst_DS__DS_WRITE_B96 class Inst_DS__DS_WRITE_B128 : public Inst_DS @@ -35574,6 +35576,8 @@ namespace VegaISA } // getOperandSize void execute(GPUDynInstPtr) override; + void initiateAcc(GPUDynInstPtr) override; + void completeAcc(GPUDynInstPtr) override; }; // Inst_DS__DS_WRITE_B128 class Inst_DS__DS_READ_B96 : public Inst_DS @@ -35606,6 +35610,8 @@ namespace VegaISA } // getOperandSize void execute(GPUDynInstPtr) override; + void initiateAcc(GPUDynInstPtr) override; + void completeAcc(GPUDynInstPtr) override; }; // Inst_DS__DS_READ_B96 class Inst_DS__DS_READ_B128 : public Inst_DS @@ -35638,6 +35644,8 @@ namespace VegaISA } // getOperandSize void execute(GPUDynInstPtr) override; + void initiateAcc(GPUDynInstPtr) override; + void completeAcc(GPUDynInstPtr) override; }; // Inst_DS__DS_READ_B128 class Inst_MUBUF__BUFFER_LOAD_FORMAT_X : public Inst_MUBUF diff --git a/src/arch/amdgpu/vega/insts/op_encodings.hh b/src/arch/amdgpu/vega/insts/op_encodings.hh index 109e680f1e..bb45b749fe 100644 --- a/src/arch/amdgpu/vega/insts/op_encodings.hh +++ b/src/arch/amdgpu/vega/insts/op_encodings.hh @@ -414,6 +414,25 @@ namespace VegaISA } } + template + void + initMemRead(GPUDynInstPtr gpuDynInst, Addr offset) + { + Wavefront *wf = gpuDynInst->wavefront(); + + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane] + offset; + for (int i = 0; i < N; ++i) { + (reinterpret_cast( + gpuDynInst->d_data))[lane * N + i] + = wf->ldsChunk->read( + vaddr + i*sizeof(VecElemU32)); + } + } + } + } + template void initDualMemRead(GPUDynInstPtr gpuDynInst, Addr offset0, Addr offset1) @@ -448,6 +467,25 @@ namespace VegaISA } } + template + void + initMemWrite(GPUDynInstPtr gpuDynInst, Addr offset) + { + Wavefront *wf = gpuDynInst->wavefront(); + + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane] + offset; + for (int i = 0; i < N; ++i) { + wf->ldsChunk->write( + vaddr + i*sizeof(VecElemU32), + (reinterpret_cast( + gpuDynInst->d_data))[lane * N + i]); + } + } + } + } + template void initDualMemWrite(GPUDynInstPtr gpuDynInst, Addr offset0, Addr offset1) From a8d7a41f9f65c3fb7cdd1500d8feebec5414d788 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Wed, 18 Aug 2021 02:27:04 -0700 Subject: [PATCH 038/658] scons,util: Use external helper scripts to build enum hhs and ccs. Change-Id: Id5cfca9ca7848394baff39c76a4ed0edbec61573 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49426 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- build_tools/enum_cc.py | 54 +++++++++++++++++++++++++++++++++++ build_tools/enum_hh.py | 50 ++++++++++++++++++++++++++++++++ src/SConscript | 65 +++++++++++++++++------------------------- 3 files changed, 130 insertions(+), 39 deletions(-) create mode 100644 build_tools/enum_cc.py create mode 100644 build_tools/enum_hh.py diff --git a/build_tools/enum_cc.py b/build_tools/enum_cc.py new file mode 100644 index 0000000000..4a6cda0c14 --- /dev/null +++ b/build_tools/enum_cc.py @@ -0,0 +1,54 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import importlib +import os.path +import sys + +import importer + +from code_formatter import code_formatter + +parser = argparse.ArgumentParser() +parser.add_argument('modpath', help='module the enum belongs to') +parser.add_argument('enum_cc', help='enum cc file to generate') +parser.add_argument('--use-python', action="store_true", + help='python is enabled in gem5') + +args = parser.parse_args() + +basename = os.path.basename(args.enum_cc) +enum_name = os.path.splitext(basename)[0] + +importer.install() +module = importlib.import_module(args.modpath) +enum = getattr(module, enum_name) + +code = code_formatter() +enum.cxx_def(code) +if args.use_python: + enum.pybind_def(code) +code.write(args.enum_cc) diff --git a/build_tools/enum_hh.py b/build_tools/enum_hh.py new file mode 100644 index 0000000000..53eaf85357 --- /dev/null +++ b/build_tools/enum_hh.py @@ -0,0 +1,50 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import importlib +import os.path +import sys + +import importer + +from code_formatter import code_formatter + +parser = argparse.ArgumentParser() +parser.add_argument('modpath', help='module the enum belongs to') +parser.add_argument('enum_hh', help='enum header file to generate') + +args = parser.parse_args() + +basename = os.path.basename(args.enum_hh) +enum_name = os.path.splitext(basename)[0] + +importer.install() +module = importlib.import_module(args.modpath) +enum = getattr(module, enum_name) + +code = code_formatter() +enum.cxx_decl(code) +code.write(args.enum_hh) diff --git a/src/SConscript b/src/SConscript index e40262a75d..bd4d630601 100644 --- a/src/SConscript +++ b/src/SConscript @@ -731,7 +731,7 @@ if GetOption('with_cxx_config'): Transform("CXXCPRCC"))) env.Depends(cxx_config_hh_file, depends + extra_deps) env.Depends(cxx_config_cc_file, depends + extra_deps) - Source(cxx_config_cc_file) + Source(cxx_config_cc_file, add_tags='python') cxx_config_init_cc_file = File('cxx_config/init.cc') @@ -766,44 +766,31 @@ if GetOption('with_cxx_config'): MakeAction(createCxxConfigInitCC, Transform("CXXCINIT"))) Source(cxx_config_init_cc_file) -# Generate all enum header files -def createEnumStrings(target, source, env): - assert len(target) == 1 and len(source) == 2 - - name = source[0].get_text_contents() - use_python = source[1].read() - obj = all_enums[name] - - code = code_formatter() - obj.cxx_def(code) - if use_python: - obj.pybind_def(code) - code.write(target[0].abspath) - -def createEnumDecls(target, source, env): - assert len(target) == 1 and len(source) == 1 - - name = source[0].get_text_contents() - obj = all_enums[name] - - code = code_formatter() - obj.cxx_decl(code) - code.write(target[0].abspath) - -for name,enum in sorted(all_enums.items()): - py_source = PySource.modules[enum.__module__] - extra_deps = [ py_source.tnode ] - - cc_file = File('enums/%s.cc' % name) - env.Command(cc_file, [Value(name), Value(env['USE_PYTHON'])], - MakeAction(createEnumStrings, Transform("ENUM STR"))) - env.Depends(cc_file, depends + extra_deps) - Source(cc_file) - - hh_file = File('enums/%s.hh' % name) - env.Command(hh_file, Value(name), - MakeAction(createEnumDecls, Transform("ENUMDECL"))) - env.Depends(hh_file, depends + extra_deps) +# C++ versions of enum params. +for module, enums in sorted(SimObject.enums.items()): + tags = SimObject.tags[module] + for enum in enums: + gem5py_env.Command([ "${ENUM_HH}" ], + [ Value(module), Value(enum), "${GEM5PY_M5}", "${ENUMHH_PY}" ], + MakeAction('"${GEM5PY_M5}" "${ENUMHH_PY}" "${MODULE}" ' \ + '"${ENUM_HH}"', + Transform("ENUMDECL", 2)), + MODULE=module, + ENUM=enum, + ENUM_HH=File(f'enums/{enum}.hh'), + ENUMHH_PY=build_tools.File('enum_hh.py')) + cc_file = File(f'enums/{enum}.cc') + gem5py_env.Command([ "${ENUM_CC}" ], + [ Value(module), Value(enum), "${GEM5PY_M5}", "${ENUMCC_PY}" ], + MakeAction('"${GEM5PY_M5}" "${ENUMCC_PY}" "${MODULE}" ' \ + '"${ENUM_CC}" "${USE_PYTHON}"', + Transform("ENUM STR", 2)), + MODULE=module, + ENUM=enum, + ENUM_CC=cc_file, + ENUMCC_PY=build_tools.File('enum_cc.py'), + USE_PYTHON='--use-python' if env['USE_PYTHON'] else '') + Source(cc_file, tags=tags, add_tags='python') # version tags From ee8ad3f8eb16192c0e86cc1fefe6179b00648181 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Wed, 18 Aug 2021 21:15:33 -0700 Subject: [PATCH 039/658] scons: Generate cxx config wrappers using a helper script. Change-Id: I003426881dc0fd8a338048abbdfa05a606221c39 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49427 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- build_tools/cxx_config_cc.py | 50 +++++++++++++++++++++++ build_tools/cxx_config_hh.py | 50 +++++++++++++++++++++++ src/SConscript | 78 ++++++++++++++++-------------------- 3 files changed, 134 insertions(+), 44 deletions(-) create mode 100644 build_tools/cxx_config_cc.py create mode 100644 build_tools/cxx_config_hh.py diff --git a/build_tools/cxx_config_cc.py b/build_tools/cxx_config_cc.py new file mode 100644 index 0000000000..7047857760 --- /dev/null +++ b/build_tools/cxx_config_cc.py @@ -0,0 +1,50 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import importlib +import os.path +import sys + +import importer + +from code_formatter import code_formatter + +parser = argparse.ArgumentParser() +parser.add_argument('modpath', help='module the simobject belongs to') +parser.add_argument('cxx_config_cc', help='cxx config cc file to generate') + +args = parser.parse_args() + +basename = os.path.basename(args.cxx_config_cc) +sim_object_name = os.path.splitext(basename)[0] + +importer.install() +module = importlib.import_module(args.modpath) +sim_object = getattr(module, sim_object_name) + +code = code_formatter() +sim_object.cxx_config_param_file(code, False) +code.write(args.cxx_config_cc) diff --git a/build_tools/cxx_config_hh.py b/build_tools/cxx_config_hh.py new file mode 100644 index 0000000000..3cae84b69e --- /dev/null +++ b/build_tools/cxx_config_hh.py @@ -0,0 +1,50 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import importlib +import os.path +import sys + +import importer + +from code_formatter import code_formatter + +parser = argparse.ArgumentParser() +parser.add_argument('modpath', help='module the simobject belongs to') +parser.add_argument('cxx_config_hh', help='cxx config header file to generate') + +args = parser.parse_args() + +basename = os.path.basename(args.cxx_config_hh) +sim_object_name = os.path.splitext(basename)[0] + +importer.install() +module = importlib.import_module(args.modpath) +sim_object = getattr(module, sim_object_name) + +code = code_formatter() +sim_object.cxx_config_param_file(code, True) +code.write(args.cxx_config_hh) diff --git a/src/SConscript b/src/SConscript index bd4d630601..49f8c985c2 100644 --- a/src/SConscript +++ b/src/SConscript @@ -672,67 +672,57 @@ gem5py_env.Program(gem5py_m5, [ 'python/gem5py.cc' ] + m5_module_static) # Create all of the SimObject param headers and enum headers # -# Generate all of the SimObject param C++ struct header files +# Generate all of the SimObject param C++ files. for module, simobjs in sorted(SimObject.sim_objects.items()): tags = SimObject.tags[module] for simobj in simobjs: - gem5py_env.Command([ "${PARAMS_HH}" ], - [ Value(module), Value(simobj), - "${GEM5PY_M5}", "${PARAMSTRUCT_PY}" ], - MakeAction('"${GEM5PY_M5}" "${PARAMSTRUCT_PY}" "${MODULE}" ' \ - '"${PARAMS_HH}"', - Transform("SO Param", 2)), + + # Some helper functions + srcs = [ Value(module), Value(simobj), "${GEM5PY_M5}", "${PYSCRIPT}" ] + def cmdline(*args): + all_args = [ 'GEM5PY_M5', 'PYSCRIPT', 'MODULE' ] + list(args) + return ' '.join(list('"${%s}"' % arg for arg in all_args)) + + # Params header. + gem5py_env.Command([ "${PARAMS_HH}" ], srcs, + MakeAction(cmdline('PARAMS_HH'), Transform("SO Param", 2)), MODULE=module, SIMOBJ=simobj, - PARAMSTRUCT_PY=build_tools.File( - 'sim_object_param_struct_hh.py'), + PYSCRIPT=build_tools.File('sim_object_param_struct_hh.py'), PARAMS_HH=File(f'params/{simobj}.hh')) + + # Params cc. cc_file = File(f'python/_m5/param_{simobj}.cc') - gem5py_env.Command([ "${PARAMS_CC}" ], - [ Value(module), Value(simobj), - "${GEM5PY_M5}", "${PARAMSTRUCT_PY}" ], - MakeAction('"${GEM5PY_M5}" "${PARAMSTRUCT_PY}" "${MODULE}" ' \ - '"${PARAMS_CC}" "${USE_PYTHON}"', + gem5py_env.Command([ "${PARAMS_CC}" ], srcs, + MakeAction(cmdline('PARAMS_CC', 'USE_PYTHON'), Transform("SO Param", 2)), - PARAMSTRUCT_PY=build_tools.File( - 'sim_object_param_struct_cc.py'), + PYSCRIPT=build_tools.File('sim_object_param_struct_cc.py'), MODULE=module, SIMOBJ=simobj, PARAMS_CC=cc_file, USE_PYTHON=env['USE_PYTHON']) Source(cc_file, tags=tags, add_tags='python') + # CXX config header. + gem5py_env.Command([ "${CXXCONFIG_HH}" ], srcs, + MakeAction(cmdline('CXXCONFIG_HH'), Transform("CXXCPRHH", 2)), + PYSCRIPT=build_tools.File('cxx_config_hh.py'), + MODULE=module, + CXXCONFIG_HH=File(f'cxx_config/{simobj}.hh')) + + # CXX config cc. + cc_file=File(f'cxx_config/{simobj}.cc') + gem5py_env.Command([ "${CXXCONFIG_CC}" ], srcs, + MakeAction(cmdline('CXXCONFIG_CC'), Transform("CXXCPRCC", 2)), + PYSCRIPT=build_tools.File('cxx_config_cc.py'), + MODULE=module, + CXXCONFIG_CC=cc_file) + if GetOption('with_cxx_config'): + Source(cc_file) + # C++ parameter description files if GetOption('with_cxx_config'): - def createSimObjectCxxConfig(is_header): - def body(target, source, env): - assert len(target) == 1 and len(source) == 1 - - name = source[0].get_contents().decode('utf-8') - obj = sim_objects[name] - - code = code_formatter() - obj.cxx_config_param_file(code, is_header) - code.write(target[0].abspath) - return body - - for name,simobj in sorted(sim_objects.items()): - py_source = PySource.modules[simobj.__module__] - extra_deps = [ py_source.tnode ] - - cxx_config_hh_file = File('cxx_config/%s.hh' % name) - cxx_config_cc_file = File('cxx_config/%s.cc' % name) - env.Command(cxx_config_hh_file, Value(name), - MakeAction(createSimObjectCxxConfig(True), - Transform("CXXCPRHH"))) - env.Command(cxx_config_cc_file, Value(name), - MakeAction(createSimObjectCxxConfig(False), - Transform("CXXCPRCC"))) - env.Depends(cxx_config_hh_file, depends + extra_deps) - env.Depends(cxx_config_cc_file, depends + extra_deps) - Source(cxx_config_cc_file, add_tags='python') - cxx_config_init_cc_file = File('cxx_config/init.cc') def createCxxConfigInitCC(target, source, env): From 19c7fe03ac5c707f32999ed158c54ae2a400a6f4 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Wed, 18 Aug 2021 22:04:02 -0700 Subject: [PATCH 040/658] scons: Generate cxx_config/init.cc using a helper script. Change-Id: Ib0129fc5c2de3977f2dedc1bfec532bbedb2d20e Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49428 Reviewed-by: Daniel Carvalho Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- build_tools/cxx_config_init_cc.py | 58 +++++++++++++++++++++++++++++++ src/SConscript | 48 ++++++++----------------- 2 files changed, 73 insertions(+), 33 deletions(-) create mode 100644 build_tools/cxx_config_init_cc.py diff --git a/build_tools/cxx_config_init_cc.py b/build_tools/cxx_config_init_cc.py new file mode 100644 index 0000000000..d3af795f3e --- /dev/null +++ b/build_tools/cxx_config_init_cc.py @@ -0,0 +1,58 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import argparse +import sys + +from code_formatter import code_formatter + +parser = argparse.ArgumentParser() +parser.add_argument('cxx_config_init_cc', + help='cxx config init cc file to generate') +parser.add_argument('sim_objects', help='all simobjects to include', nargs='*') + +args = parser.parse_args() + +code = code_formatter() + +for sim_object in args.sim_objects: + code('#include "cxx_config/${sim_object}.hh"') +code('') +code('namespace gem5') +code('{') +code('') +code('void') +code('cxxConfigInit()') +code('{') +code.indent() +for sim_object in args.sim_objects: + code('cxx_config_directory["${sim_object}"] = ' + '${sim_object}CxxConfigParams::makeDirectoryEntry();') +code.dedent() +code('}') +code('') +code('} // namespace gem5') + +code.write(args.cxx_config_init_cc) diff --git a/src/SConscript b/src/SConscript index 49f8c985c2..0e172d326c 100644 --- a/src/SConscript +++ b/src/SConscript @@ -44,6 +44,7 @@ import importlib import importlib.abc import importlib.machinery import importlib.util +import itertools import os import os.path import re @@ -721,40 +722,21 @@ for module, simobjs in sorted(SimObject.sim_objects.items()): if GetOption('with_cxx_config'): Source(cc_file) -# C++ parameter description files +# CXX config init.cc +all_sim_objects = sorted(itertools.chain.from_iterable( + SimObject.sim_objects.values())) +sim_object_args = list(f'"{sim_object}"' for sim_object in all_sim_objects) +cc_file = File('cxx_config/init.cc') +gem5py_env.Command([ "${CXXCONFIGINIT_CC}" ], + [ "${GEM5PY}", "${CXXCONFIGINITCC_PY}" ], + MakeAction('"${GEM5PY}" "${CXXCONFIGINITCC_PY}" "${TARGET}" ' + '${SIM_OBJECTS}', + Transform("CXXCINIT", 0)), + CXXCONFIGINITCC_PY=build_tools.File('cxx_config_init_cc.py'), + SIM_OBJECTS=' '.join(sim_object_args), + CXXCONFIGINIT_CC=cc_file) if GetOption('with_cxx_config'): - cxx_config_init_cc_file = File('cxx_config/init.cc') - - def createCxxConfigInitCC(target, source, env): - assert len(target) == 1 - - code = code_formatter() - - for name,simobj in sorted(sim_objects.items()): - if not hasattr(simobj, 'abstract') or not simobj.abstract: - code('#include "cxx_config/${name}.hh"') - code() - code('namespace gem5') - code('{') - code() - code('void cxxConfigInit()') - code('{') - code.indent() - for name,simobj in sorted(sim_objects.items()): - not_abstract = not hasattr(simobj, 'abstract') or \ - not simobj.abstract - if not_abstract and 'type' in simobj.__dict__: - code('cxx_config_directory["${name}"] = ' - '${name}CxxConfigParams::makeDirectoryEntry();') - code.dedent() - code('}') - code('') - code('} // namespace gem5') - code.write(target[0].abspath) - - env.Command(cxx_config_init_cc_file, [], - MakeAction(createCxxConfigInitCC, Transform("CXXCINIT"))) - Source(cxx_config_init_cc_file) + Source(cc_file) # C++ versions of enum params. for module, enums in sorted(SimObject.enums.items()): From f42b198371be27f41fe8ab4defca31c9b87799b6 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Wed, 18 Aug 2021 22:27:45 -0700 Subject: [PATCH 041/658] scons: Stop importing SimObjects into src/SConscript. Get rid of the actual imports, and all the machinery which supports it. Everything that had been using them is now handled using helper scripts and/or the gem5py_m5 utility binary. Change-Id: I079e50bdabef6d8d199caa80b589319d6419c4ba Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49429 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- src/SConscript | 110 ------------------------------------------------- 1 file changed, 110 deletions(-) diff --git a/src/SConscript b/src/SConscript index 0e172d326c..87176d9c72 100644 --- a/src/SConscript +++ b/src/SConscript @@ -37,13 +37,8 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -import bisect import collections import distutils.spawn -import importlib -import importlib.abc -import importlib.machinery -import importlib.util import itertools import os import os.path @@ -94,8 +89,6 @@ gem5py_env['ENV']['PYTHONPATH'] = ':'.join(pythonpath) class PySource(SourceFile): '''Add a python source file to the named package''' - modules = {} - def __init__(self, package, source, tags=None, add_tags=None): '''specify the python package, the source file, and any tags''' super().__init__(source, tags, add_tags) @@ -117,11 +110,7 @@ class PySource(SourceFile): if not os.path.exists(abspath): abspath = self.tnode.abspath - self.modname = modname self.modpath = modpath - self.abspath = abspath - - PySource.modules[modpath] = self cpp = File(self.filename + '.cc') @@ -532,105 +521,6 @@ env.Command('config/the_gpu_isa.hh', [], # SimObject.fixed = True -class SimpleModuleLoader(importlib.abc.Loader): - '''A simple wrapper which delegates setting up a module to a function.''' - def __init__(self, executor): - super().__init__() - self.executor = executor - def create_module(self, spec): - return None - - def exec_module(self, module): - self.executor(module) - -class M5MetaPathFinder(importlib.abc.MetaPathFinder): - def __init__(self, modules): - super().__init__() - self.modules = modules - self.installed = set() - - def unload(self): - import sys - for module in self.installed: - del sys.modules[module] - self.installed = set() - - def find_spec(self, fullname, path, target=None): - spec = None - - # If this isn't even in the m5 package, ignore it. - if fullname.startswith('m5.'): - if fullname.startswith('m5.objects'): - # When imported in this context, return a spec for a dummy - # package which just serves to house the modules within it. - # This is subtley different from "import * from m5.objects" - # which relies on the __init__.py in m5.objects. That in turn - # indirectly relies on the c++ based _m5 package which doesn't - # exist yet. - if fullname == 'm5.objects': - dummy_loader = SimpleModuleLoader(lambda x: None) - spec = importlib.machinery.ModuleSpec( - name=fullname, loader=dummy_loader, - is_package=True) - spec.loader_state = self.modules.keys() - - # If this is a module within the m5.objects package, return a - # spec that maps to its source file. - elif fullname in self.modules: - source = self.modules[fullname] - spec = importlib.util.spec_from_file_location( - name=fullname, location=source.abspath) - - # The artificial m5.defines subpackage. - elif fullname == 'm5.defines': - def build_m5_defines(module): - module.__dict__['buildEnv'] = dict(build_env) - - spec = importlib.util.spec_from_loader(name=fullname, - loader=SimpleModuleLoader(build_m5_defines)) - - # If we're handling this module, write it down so we can unload it - # later. - if spec is not None: - self.installed.add(fullname) - - return spec - -import m5.SimObject -import m5.params - -m5.SimObject.clear() -m5.params.clear() - -# install the python importer so we can grab stuff from the source -# tree itself. We can't have SimObjects added after this point or -# else we won't know about them for the rest of the stuff. -importer = M5MetaPathFinder(PySource.modules) -sys.meta_path[0:0] = [ importer ] - -import_globals = globals().copy() -# import all sim objects so we can populate the all_objects list -# make sure that we're working with a list, then let's sort it -gem5_lib_simobjects = SimObject.all.with_tag(env, 'gem5 lib') -gem5_lib_modnames = sorted(map(lambda so: so.modname, gem5_lib_simobjects)) -for modname in gem5_lib_modnames: - exec('from m5.objects import %s' % modname, import_globals) - -# we need to unload all of the currently imported modules so that they -# will be re-imported the next time the sconscript is run -importer.unload() -sys.meta_path.remove(importer) - -sim_objects = m5.SimObject.allClasses -all_enums = m5.params.allEnums - -######################################################################## -# -# calculate extra dependencies -# -module_depends = ["m5", "m5.SimObject", "m5.params"] -depends = [ PySource.modules[dep].snode for dep in module_depends ] -depends.sort(key = lambda x: x.name) ######################################################################## # From df540f0dbf1bcdcb49de72c02bd21d9125d45d88 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Thu, 19 Aug 2021 21:59:22 -0700 Subject: [PATCH 042/658] python,util: Pull param struct generation code out of SimObject. Change-Id: I9f9c3b858a214650f6f07e6127bb316a227982a0 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49450 Reviewed-by: Gabe Black Reviewed-by: Andreas Sandberg Maintainer: Gabe Black Maintainer: Andreas Sandberg Tested-by: kokoro --- build_tools/sim_object_param_struct_cc.py | 213 ++++++++++++- build_tools/sim_object_param_struct_hh.py | 176 ++++++++++- src/python/m5/SimObject.py | 354 ---------------------- 3 files changed, 387 insertions(+), 356 deletions(-) diff --git a/build_tools/sim_object_param_struct_cc.py b/build_tools/sim_object_param_struct_cc.py index 7266556641..1b72e3cb41 100644 --- a/build_tools/sim_object_param_struct_cc.py +++ b/build_tools/sim_object_param_struct_cc.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -57,6 +70,204 @@ importer.install() module = importlib.import_module(args.modpath) sim_object = getattr(module, sim_object_name) +from m5.objects.SimObject import PyBindProperty + code = code_formatter() -sim_object.params_create_decl(code, use_python) + +py_class_name = sim_object.pybind_class + +# The 'local' attribute restricts us to the params declared in +# the object itself, not including inherited params (which +# will also be inherited from the base class's param struct +# here). Sort the params based on their key +params = list(map(lambda k_v: k_v[1], + sorted(sim_object._params.local.items()))) +ports = sim_object._ports.local + +# only include pybind if python is enabled in the build +if use_python: + + code('''#include "pybind11/pybind11.h" +#include "pybind11/stl.h" + +#include + +#include "base/compiler.hh" +#include "params/$sim_object.hh" +#include "sim/init.hh" +#include "sim/sim_object.hh" + +#include "${{sim_object.cxx_header}}" + +''') +else: + code(''' +#include + +#include "base/compiler.hh" +#include "params/$sim_object.hh" + +#include "${{sim_object.cxx_header}}" + +''') +# only include the python params code if python is enabled. +if use_python: + for param in params: + param.pybind_predecls(code) + + code('''namespace py = pybind11; + +namespace gem5 +{ + +static void +module_init(py::module_ &m_internal) +{ +py::module_ m = m_internal.def_submodule("param_${sim_object}"); +''') + code.indent() + if sim_object._base: + code('py::class_<${sim_object}Params, ' \ + '${{sim_object._base.type}}Params, ' \ + 'std::unique_ptr<${{sim_object}}Params, py::nodelete>>(' \ + 'm, "${sim_object}Params")') + else: + code('py::class_<${sim_object}Params, ' \ + 'std::unique_ptr<${sim_object}Params, py::nodelete>>(' \ + 'm, "${sim_object}Params")') + + code.indent() + if not hasattr(sim_object, 'abstract') or not sim_object.abstract: + code('.def(py::init<>())') + code('.def("create", &${sim_object}Params::create)') + + param_exports = sim_object.cxx_param_exports + [ + PyBindProperty(k) + for k, v in sorted(sim_object._params.local.items()) + ] + [ + PyBindProperty(f"port_{port.name}_connection_count") + for port in ports.values() + ] + for exp in param_exports: + exp.export(code, f"{sim_object}Params") + + code(';') + code() + code.dedent() + + bases = [] + if 'cxx_base' in sim_object._value_dict: + # If the c++ base class implied by python inheritance was + # overridden, use that value. + if sim_object.cxx_base: + bases.append(sim_object.cxx_base) + elif sim_object._base: + # If not and if there was a SimObject base, use its c++ class + # as this class' base. + bases.append(sim_object._base.cxx_class) + # Add in any extra bases that were requested. + bases.extend(sim_object.cxx_extra_bases) + + if bases: + base_str = ", ".join(bases) + code('py::class_<${{sim_object.cxx_class}}, ${base_str}, ' \ + 'std::unique_ptr<${{sim_object.cxx_class}}, py::nodelete>>(' \ + 'm, "${py_class_name}")') + else: + code('py::class_<${{sim_object.cxx_class}}, ' \ + 'std::unique_ptr<${{sim_object.cxx_class}}, py::nodelete>>(' \ + 'm, "${py_class_name}")') + code.indent() + for exp in sim_object.cxx_exports: + exp.export(code, sim_object.cxx_class) + code(';') + code.dedent() + code() + code.dedent() + code('}') + code() + code('static EmbeddedPyBind ' + 'embed_obj("${0}", module_init, "${1}");', + sim_object, sim_object._base.type if sim_object._base else "") + code() + code('} // namespace gem5') + +# include the create() methods whether or not python is enabled. +if not hasattr(sim_object, 'abstract') or not sim_object.abstract: + if 'type' in sim_object.__dict__: + code(''' +namespace gem5 +{ + +namespace +{ + +/* + * If we can't define a default create() method for this params + * struct because the SimObject doesn't have the right + * constructor, use template magic to make it so we're actually + * defining a create method for this class instead. + */ +class Dummy${sim_object}ParamsClass +{ + public: + ${{sim_object.cxx_class}} *create() const; +}; + +template +class Dummy${sim_object}Shunt; + +/* + * This version directs to the real Params struct and the + * default behavior of create if there's an appropriate + * constructor. + */ +template +class Dummy${sim_object}Shunt>> +{ + public: + using Params = ${sim_object}Params; + static ${{sim_object.cxx_class}} * + create(const Params &p) + { + return new CxxClass(p); + } +}; + +/* + * This version diverts to the DummyParamsClass and a dummy + * implementation of create if the appropriate constructor does + * not exist. + */ +template +class Dummy${sim_object}Shunt>> +{ + public: + using Params = Dummy${sim_object}ParamsClass; + static ${{sim_object.cxx_class}} * + create(const Params &p) + { + return nullptr; + } +}; + +} // anonymous namespace + +/* + * An implementation of either the real Params struct's create + * method, or the Dummy one. Either an implementation is + * mandantory since this was shunted off to the dummy class, or + * one is optional which will override this weak version. + */ +[[maybe_unused]] ${{sim_object.cxx_class}} * +Dummy${sim_object}Shunt<${{sim_object.cxx_class}}>::Params::create() const +{ + return Dummy${sim_object}Shunt<${{sim_object.cxx_class}}>::create(*this); +} + +} // namespace gem5 +''') + code.write(args.param_cc) diff --git a/build_tools/sim_object_param_struct_hh.py b/build_tools/sim_object_param_struct_hh.py index 0652ae5801..ff525ee074 100644 --- a/build_tools/sim_object_param_struct_hh.py +++ b/build_tools/sim_object_param_struct_hh.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -45,6 +58,167 @@ importer.install() module = importlib.import_module(args.modpath) sim_object = getattr(module, sim_object_name) +from m5.objects.SimObject import SimObject +from m5.params import Enum + code = code_formatter() -sim_object.cxx_param_decl(code) + +# The 'local' attribute restricts us to the params declared in +# the object itself, not including inherited params (which +# will also be inherited from the base class's param struct +# here). Sort the params based on their key +params = list(map(lambda k_v: k_v[1], + sorted(sim_object._params.local.items()))) +ports = sim_object._ports.local +try: + ptypes = [p.ptype for p in params] +except: + print(sim_object, p, p.ptype_str) + print(params) + raise + +warned_about_nested_templates = False + +class CxxClass(object): + def __init__(self, sig, template_params=[]): + # Split the signature into its constituent parts. This could + # potentially be done with regular expressions, but + # it's simple enough to pick appart a class signature + # manually. + parts = sig.split('<', 1) + base = parts[0] + t_args = [] + if len(parts) > 1: + # The signature had template arguments. + text = parts[1].rstrip(' \t\n>') + arg = '' + # Keep track of nesting to avoid splitting on ","s embedded + # in the arguments themselves. + depth = 0 + for c in text: + if c == '<': + depth = depth + 1 + if depth > 0 and not warned_about_nested_templates: + warned_about_nested_templates = True + print('Nested template argument in cxx_class.' + ' This feature is largely untested and ' + ' may not work.') + elif c == '>': + depth = depth - 1 + elif c == ',' and depth == 0: + t_args.append(arg.strip()) + arg = '' + else: + arg = arg + c + if arg: + t_args.append(arg.strip()) + # Split the non-template part on :: boundaries. + class_path = base.split('::') + + # The namespaces are everything except the last part of the class path. + self.namespaces = class_path[:-1] + # And the class name is the last part. + self.name = class_path[-1] + + self.template_params = template_params + self.template_arguments = [] + # Iterate through the template arguments and their values. This + # will likely break if parameter packs are used. + for arg, param in zip(t_args, template_params): + type_keys = ('class', 'typename') + # If a parameter is a type, parse it recursively. Otherwise + # assume it's a constant, and store it verbatim. + if any(param.strip().startswith(kw) for kw in type_keys): + self.template_arguments.append(CxxClass(arg)) + else: + self.template_arguments.append(arg) + + def declare(self, code): + # First declare any template argument types. + for arg in self.template_arguments: + if isinstance(arg, CxxClass): + arg.declare(code) + # Re-open the target namespace. + for ns in self.namespaces: + code('namespace $ns {') + # If this is a class template... + if self.template_params: + code('template <${{", ".join(self.template_params)}}>') + # The actual class declaration. + code('class ${{self.name}};') + # Close the target namespaces. + for ns in reversed(self.namespaces): + code('} // namespace $ns') + +code('''\ +#ifndef __PARAMS__${sim_object}__ +#define __PARAMS__${sim_object}__ + +''') + + +# The base SimObject has a couple of params that get +# automatically set from Python without being declared through +# the normal Param mechanism; we slip them in here (needed +# predecls now, actual declarations below) +if sim_object == SimObject: + code('''#include ''') + +cxx_class = CxxClass(sim_object._value_dict['cxx_class'], + sim_object._value_dict['cxx_template_params']) + +# A forward class declaration is sufficient since we are just +# declaring a pointer. +cxx_class.declare(code) + +for param in params: + param.cxx_predecls(code) +for port in ports.values(): + port.cxx_predecls(code) +code() + +if sim_object._base: + code('#include "params/${{sim_object._base.type}}.hh"') + code() + +for ptype in ptypes: + if issubclass(ptype, Enum): + code('#include "enums/${{ptype.__name__}}.hh"') + code() + +code('namespace gem5') +code('{') +code('') + +# now generate the actual param struct +code("struct ${sim_object}Params") +if sim_object._base: + code(" : public ${{sim_object._base.type}}Params") +code("{") +if not hasattr(sim_object, 'abstract') or not sim_object.abstract: + if 'type' in sim_object.__dict__: + code(" ${{sim_object.cxx_type}} create() const;") + +code.indent() +if sim_object == SimObject: + code(''' +SimObjectParams() {} +virtual ~SimObjectParams() {} + +std::string name; + ''') + +for param in params: + param.cxx_decl(code) +for port in ports.values(): + port.cxx_decl(code) + +code.dedent() +code('};') +code() +code('} // namespace gem5') + +code() +code('#endif // __PARAMS__${sim_object}__') + code.write(args.param_hh) diff --git a/src/python/m5/SimObject.py b/src/python/m5/SimObject.py index b07d90f7b8..b2ed967d12 100644 --- a/src/python/m5/SimObject.py +++ b/src/python/m5/SimObject.py @@ -708,360 +708,6 @@ class MetaSimObject(type): def pybind_predecls(cls, code): code('#include "${{cls.cxx_header}}"') - def params_create_decl(cls, code, python_enabled): - py_class_name = cls.pybind_class - - # The 'local' attribute restricts us to the params declared in - # the object itself, not including inherited params (which - # will also be inherited from the base class's param struct - # here). Sort the params based on their key - params = list(map(lambda k_v: k_v[1], - sorted(cls._params.local.items()))) - ports = cls._ports.local - - # only include pybind if python is enabled in the build - if python_enabled: - - code('''#include "pybind11/pybind11.h" -#include "pybind11/stl.h" - -#include - -#include "base/compiler.hh" -#include "params/$cls.hh" -#include "sim/init.hh" -#include "sim/sim_object.hh" - -#include "${{cls.cxx_header}}" - -''') - else: - code(''' -#include - -#include "base/compiler.hh" -#include "params/$cls.hh" - -#include "${{cls.cxx_header}}" - -''') - # only include the python params code if python is enabled. - if python_enabled: - for param in params: - param.pybind_predecls(code) - - code('''namespace py = pybind11; - -namespace gem5 -{ - -static void -module_init(py::module_ &m_internal) -{ - py::module_ m = m_internal.def_submodule("param_${cls}"); -''') - code.indent() - if cls._base: - code('py::class_<${cls}Params, ${{cls._base.type}}Params, ' \ - 'std::unique_ptr<${{cls}}Params, py::nodelete>>(' \ - 'm, "${cls}Params")') - else: - code('py::class_<${cls}Params, ' \ - 'std::unique_ptr<${cls}Params, py::nodelete>>(' \ - 'm, "${cls}Params")') - - code.indent() - if not hasattr(cls, 'abstract') or not cls.abstract: - code('.def(py::init<>())') - code('.def("create", &${cls}Params::create)') - - param_exports = cls.cxx_param_exports + [ - PyBindProperty(k) - for k, v in sorted(cls._params.local.items()) - ] + [ - PyBindProperty("port_%s_connection_count" % port.name) - for port in ports.values() - ] - for exp in param_exports: - exp.export(code, "%sParams" % cls) - - code(';') - code() - code.dedent() - - bases = [] - if 'cxx_base' in cls._value_dict: - # If the c++ base class implied by python inheritance was - # overridden, use that value. - if cls.cxx_base: - bases.append(cls.cxx_base) - elif cls._base: - # If not and if there was a SimObject base, use its c++ class - # as this class' base. - bases.append(cls._base.cxx_class) - # Add in any extra bases that were requested. - bases.extend(cls.cxx_extra_bases) - - if bases: - base_str = ", ".join(bases) - code('py::class_<${{cls.cxx_class}}, ${base_str}, ' \ - 'std::unique_ptr<${{cls.cxx_class}}, py::nodelete>>(' \ - 'm, "${py_class_name}")') - else: - code('py::class_<${{cls.cxx_class}}, ' \ - 'std::unique_ptr<${{cls.cxx_class}}, py::nodelete>>(' \ - 'm, "${py_class_name}")') - code.indent() - for exp in cls.cxx_exports: - exp.export(code, cls.cxx_class) - code(';') - code.dedent() - code() - code.dedent() - code('}') - code() - code('static EmbeddedPyBind ' - 'embed_obj("${0}", module_init, "${1}");', - cls, cls._base.type if cls._base else "") - code() - code('} // namespace gem5') - - # include the create() methods whether or not python is enabled. - if not hasattr(cls, 'abstract') or not cls.abstract: - if 'type' in cls.__dict__: - code() - code('namespace gem5') - code('{') - code() - code('namespace') - code('{') - code() - # If we can't define a default create() method for this params - # struct because the SimObject doesn't have the right - # constructor, use template magic to make it so we're actually - # defining a create method for this class instead. - code('class Dummy${cls}ParamsClass') - code('{') - code(' public:') - code(' ${{cls.cxx_class}} *create() const;') - code('};') - code() - code('template ') - code('class Dummy${cls}Shunt;') - code() - # This version directs to the real Params struct and the - # default behavior of create if there's an appropriate - # constructor. - code('template ') - code('class Dummy${cls}Shunt>>') - code('{') - code(' public:') - code(' using Params = ${cls}Params;') - code(' static ${{cls.cxx_class}} *') - code(' create(const Params &p)') - code(' {') - code(' return new CxxClass(p);') - code(' }') - code('};') - code() - # This version diverts to the DummyParamsClass and a dummy - # implementation of create if the appropriate constructor does - # not exist. - code('template ') - code('class Dummy${cls}Shunt>>') - code('{') - code(' public:') - code(' using Params = Dummy${cls}ParamsClass;') - code(' static ${{cls.cxx_class}} *') - code(' create(const Params &p)') - code(' {') - code(' return nullptr;') - code(' }') - code('};') - code() - code('} // anonymous namespace') - code() - # An implementation of either the real Params struct's create - # method, or the Dummy one. Either an implementation is - # mandantory since this was shunted off to the dummy class, or - # one is optional which will override this weak version. - code('[[maybe_unused]] ${{cls.cxx_class}} *') - code('Dummy${cls}Shunt<${{cls.cxx_class}}>::Params::create() ' - 'const') - code('{') - code(' return Dummy${cls}Shunt<${{cls.cxx_class}}>::') - code(' create(*this);') - code('}') - code() - code('} // namespace gem5') - - _warned_about_nested_templates = False - - # Generate the C++ declaration (.hh file) for this SimObject's - # param struct. Called from src/SConscript. - def cxx_param_decl(cls, code): - # The 'local' attribute restricts us to the params declared in - # the object itself, not including inherited params (which - # will also be inherited from the base class's param struct - # here). Sort the params based on their key - params = list(map(lambda k_v: k_v[1], sorted(cls._params.local.items()))) - ports = cls._ports.local - try: - ptypes = [p.ptype for p in params] - except: - print(cls, p, p.ptype_str) - print(params) - raise - - class CxxClass(object): - def __init__(self, sig, template_params=[]): - # Split the signature into its constituent parts. This could - # potentially be done with regular expressions, but - # it's simple enough to pick appart a class signature - # manually. - parts = sig.split('<', 1) - base = parts[0] - t_args = [] - if len(parts) > 1: - # The signature had template arguments. - text = parts[1].rstrip(' \t\n>') - arg = '' - # Keep track of nesting to avoid splitting on ","s embedded - # in the arguments themselves. - depth = 0 - for c in text: - if c == '<': - depth = depth + 1 - if depth > 0 and not \ - self._warned_about_nested_templates: - self._warned_about_nested_templates = True - print('Nested template argument in cxx_class.' - ' This feature is largely untested and ' - ' may not work.') - elif c == '>': - depth = depth - 1 - elif c == ',' and depth == 0: - t_args.append(arg.strip()) - arg = '' - else: - arg = arg + c - if arg: - t_args.append(arg.strip()) - # Split the non-template part on :: boundaries. - class_path = base.split('::') - - # The namespaces are everything except the last part of the - # class path. - self.namespaces = class_path[:-1] - # And the class name is the last part. - self.name = class_path[-1] - - self.template_params = template_params - self.template_arguments = [] - # Iterate through the template arguments and their values. This - # will likely break if parameter packs are used. - for arg, param in zip(t_args, template_params): - type_keys = ('class', 'typename') - # If a parameter is a type, parse it recursively. Otherwise - # assume it's a constant, and store it verbatim. - if any(param.strip().startswith(kw) for kw in type_keys): - self.template_arguments.append(CxxClass(arg)) - else: - self.template_arguments.append(arg) - - def declare(self, code): - # First declare any template argument types. - for arg in self.template_arguments: - if isinstance(arg, CxxClass): - arg.declare(code) - # Re-open the target namespace. - for ns in self.namespaces: - code('namespace $ns {') - # If this is a class template... - if self.template_params: - code('template <${{", ".join(self.template_params)}}>') - # The actual class declaration. - code('class ${{self.name}};') - # Close the target namespaces. - for ns in reversed(self.namespaces): - code('} // namespace $ns') - - code('''\ -#ifndef __PARAMS__${cls}__ -#define __PARAMS__${cls}__ - -''') - - - # The base SimObject has a couple of params that get - # automatically set from Python without being declared through - # the normal Param mechanism; we slip them in here (needed - # predecls now, actual declarations below) - if cls == SimObject: - code('''#include ''') - - cxx_class = CxxClass(cls._value_dict['cxx_class'], - cls._value_dict['cxx_template_params']) - - # A forward class declaration is sufficient since we are just - # declaring a pointer. - cxx_class.declare(code) - - for param in params: - param.cxx_predecls(code) - for port in ports.values(): - port.cxx_predecls(code) - code() - - if cls._base: - code('#include "params/${{cls._base.type}}.hh"') - code() - - for ptype in ptypes: - if issubclass(ptype, Enum): - code('#include "enums/${{ptype.__name__}}.hh"') - code() - - code('namespace gem5') - code('{') - code('') - - # now generate the actual param struct - code("struct ${cls}Params") - if cls._base: - code(" : public ${{cls._base.type}}Params") - code("{") - if not hasattr(cls, 'abstract') or not cls.abstract: - if 'type' in cls.__dict__: - code(" ${{cls.cxx_type}} create() const;") - - code.indent() - if cls == SimObject: - code(''' - SimObjectParams() {} - virtual ~SimObjectParams() {} - - std::string name; - ''') - - for param in params: - param.cxx_decl(code) - for port in ports.values(): - port.cxx_decl(code) - - code.dedent() - code('};') - code() - code('} // namespace gem5') - - code() - code('#endif // __PARAMS__${cls}__') - return code - # Generate the C++ declaration/definition files for this SimObject's # param struct to allow C++ initialisation def cxx_config_param_file(cls, code, is_header): From 83b703c6b82113b9c98fb10447bcda275bb4d5da Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Mon, 10 Jan 2022 11:28:05 -0800 Subject: [PATCH 043/658] stdlib: Remove stdlib README.md This README.md is outdated and incompleted. User's wishing to learn about the gem5 stdlib should reference the gem5 website: https://www.gem5.org/documentation/gem5-stdlib/overview Issue-on: https://gem5.atlassian.net/browse/GEM5-1019 Change-Id: Ib66bd748d517708833ac591515601f206ce4728a Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55323 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/python/gem5/README.md | 37 ------------------------------------- 1 file changed, 37 deletions(-) delete mode 100644 src/python/gem5/README.md diff --git a/src/python/gem5/README.md b/src/python/gem5/README.md deleted file mode 100644 index 344034d3ac..0000000000 --- a/src/python/gem5/README.md +++ /dev/null @@ -1,37 +0,0 @@ -# The gem5 Components Library - -**IMPORTANT NOTE:** This is a Work-In-Process Documentation. This will be expanded and completed in later revisions of the components library. - -This is a high-level overview of what this library is. - -## Philosophy - -Like the [Zen of Python](https://www.python.org/dev/peps/pep-0020/), the gem5 Components Library has a set of guiding principles. -Note, these are note rules, and they are meant to be *bent* if needed (but maybe not broken). - -### Components are extensible, not configurable - -We prefer *extensibility* instead of *configurability*. -Instead of each component taking many different parameters, we have decided to make many different components. -For instance, instead of having one core component which takes a parameter of the type (e.g., in-order or out-of-order), we specify multiple different components, an `InOrderCPU` and an `OutOfOrder` CPU. - -### Components use easy to remember names - -We prefer longer and easier to remember names than shorter or jargon names. - -## Structure of the components library - -### Boards - -### Processors - -### Memories - -### Cache hierarchies - -## Contributing to the components library - -### Code style - -- Use [Black](https://black.readthedocs.io/en/stable/) to format your code. -- Docstring should follow the [ReST style and Sphinx](https://www.sphinx-doc.org/) From cd9fc30d92076562214ec4c319440d4375d1d88a Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Mon, 10 Jan 2022 16:36:15 +0800 Subject: [PATCH 044/658] dev-arm: Add missing sim_objects of VExpressFastmodel Change-Id: Ic6a9e5f1381c6c6412faa6d19f1448ca0e08b1e7 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55304 Reviewed-by: Gabe Black Maintainer: Gabe Black Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- src/dev/arm/SConscript | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dev/arm/SConscript b/src/dev/arm/SConscript index e74b190f86..e59dc9442d 100644 --- a/src/dev/arm/SConscript +++ b/src/dev/arm/SConscript @@ -64,7 +64,7 @@ SimObject('NoMali.py', sim_objects=['NoMaliGpu', 'CustomNoMaliGpu'], enums=['NoMaliGpuType'], tags='arm isa') SimObject('VirtIOMMIO.py', sim_objects=['MmioVirtIO'], tags='arm isa') if env['USE_ARM_FASTMODEL']: - SimObject('VExpressFastmodel.py', tags='arm isa') + SimObject('VExpressFastmodel.py', sim_objects=[], tags='arm isa') Source('a9scu.cc', tags='arm isa') Source('amba_device.cc', tags='arm isa') From 301ddefa284cc500a52fccda6970440107d54bcf Mon Sep 17 00:00:00 2001 From: Wing Li Date: Mon, 10 Jan 2022 15:43:05 -0800 Subject: [PATCH 045/658] dev: define VectorIntSourcePin type Change-Id: Ic457593cefb4f82794d3fe4c8c91931c1bf76a63 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55363 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Reviewed-by: Gabe Black Tested-by: kokoro --- src/dev/IntPin.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/dev/IntPin.py b/src/dev/IntPin.py index a6851cc7cb..80618ce251 100644 --- a/src/dev/IntPin.py +++ b/src/dev/IntPin.py @@ -35,6 +35,17 @@ class IntSourcePin(VectorPort): def __init__(self, desc): super().__init__(INT_SOURCE_ROLE, desc, is_source=True) +# A vector of source pins which might represent a bank of physical pins. Unlike +# IntSourcePin, each source pin in VectorIntSourcePin can only connect to a +# single sink pin. VectorIntSourcePin has the same definition as IntSourcePin +# right now, but will likely be implemented differently in the future. +# VectorIntSourcePin is defined as its own separate type to differentiate it +# from IntSourcePin and make it clear to the user how it should be interpreted +# and used. +class VectorIntSourcePin(VectorPort): + def __init__(self, desc): + super().__init__(INT_SOURCE_ROLE, desc, is_source=True) + # Each "physical" pin can be driven by a single source pin since there are no # provisions for resolving competing signals running to the same pin. class IntSinkPin(Port): From ad7ff8e27195357755726bb8e6ac3839a040f00e Mon Sep 17 00:00:00 2001 From: Wing Li Date: Wed, 22 Dec 2021 17:28:03 -0800 Subject: [PATCH 046/658] fastmodel: export wake request ports from GIC Change-Id: I561ef876a4e873501ed2e9775b5bdb59707521a9 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/54783 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/arm/fastmodel/GIC/FastModelGIC.py | 3 +++ src/arch/arm/fastmodel/GIC/GIC.lisa | 5 +++++ src/arch/arm/fastmodel/GIC/GIC.sgproj | 1 + src/arch/arm/fastmodel/GIC/gic.cc | 21 ++++++++++++++++++++- src/arch/arm/fastmodel/GIC/gic.hh | 5 +++++ 5 files changed, 34 insertions(+), 1 deletion(-) diff --git a/src/arch/arm/fastmodel/GIC/FastModelGIC.py b/src/arch/arm/fastmodel/GIC/FastModelGIC.py index 5a551dfb97..8a94d59e2e 100644 --- a/src/arch/arm/fastmodel/GIC/FastModelGIC.py +++ b/src/arch/arm/fastmodel/GIC/FastModelGIC.py @@ -41,6 +41,7 @@ from m5.SimObject import SimObject from m5.objects.FastModel import AmbaInitiatorSocket, AmbaTargetSocket from m5.objects.Gic import BaseGic +from m5.objects.IntPin import VectorIntSourcePin from m5.objects.SystemC import SystemC_ScModule GICV3_COMMS_TARGET_ROLE = 'GICV3 COMMS TARGET' @@ -473,6 +474,8 @@ class FastModelGIC(BaseGic): redistributor = VectorGicv3CommsInitiatorSocket( 'GIC communication initiator') + wake_request = VectorIntSourcePin('GIC wake request initiator') + # Used for DTB autogeneration _state = FdtState(addr_cells=2, size_cells=2, interrupt_cells=3) diff --git a/src/arch/arm/fastmodel/GIC/GIC.lisa b/src/arch/arm/fastmodel/GIC/GIC.lisa index 9e4d917a66..34b09c8366 100644 --- a/src/arch/arm/fastmodel/GIC/GIC.lisa +++ b/src/arch/arm/fastmodel/GIC/GIC.lisa @@ -53,6 +53,9 @@ component GIC // For the CPU interface. gic.redistributor_m => self.redistributor; + // Outgoing wake requests. + gic.wake_request => self.wake_request; + // Internal ports for PPI and SPI programmatic access. self.ppi_0 => gic.ppi_in_0; self.ppi_1 => gic.ppi_in_1; @@ -324,6 +327,8 @@ component GIC master port redistributor[256]; + master port wake_request[256]; + #define setPPI(C) \ case C: ppi_##C[num].setValue(state); \ break diff --git a/src/arch/arm/fastmodel/GIC/GIC.sgproj b/src/arch/arm/fastmodel/GIC/GIC.sgproj index c835356092..7c503b2a51 100644 --- a/src/arch/arm/fastmodel/GIC/GIC.sgproj +++ b/src/arch/arm/fastmodel/GIC/GIC.sgproj @@ -16,6 +16,7 @@ config "gcc" SIMGEN_COMMAND_LINE = "--num-comps-file 50"; TARGET_MAXVIEW = "0"; TARGET_SYSTEMC = "1"; + TARGET_SYSTEMC_AUTO = "1"; } files { diff --git a/src/arch/arm/fastmodel/GIC/gic.cc b/src/arch/arm/fastmodel/GIC/gic.cc index d1b59807c4..fbe863a166 100644 --- a/src/arch/arm/fastmodel/GIC/gic.cc +++ b/src/arch/arm/fastmodel/GIC/gic.cc @@ -77,6 +77,12 @@ SCGIC::SCGIC(const SCFastModelGICParams ¶ms, { signalInterrupt.bind(signal_interrupt); + for (int i = 0; i < wake_request.size(); i++) { + wakeRequests.emplace_back( + new SignalReceiver(csprintf("%s.wakerequest[%d]", name(), i))); + wake_request[i].bind(wakeRequests[i]->signal_in); + } + set_parameter("gic.enabled", params.enabled); set_parameter("gic.has-gicv3", params.has_gicv3); set_parameter("gic.has-gicv4.1", params.has_gicv4_1); @@ -306,7 +312,18 @@ GIC::GIC(const FastModelGICParams ¶ms) : ambaS(params.sc_gic->amba_s, params.name + ".amba_s", -1), redistributors(params.port_redistributor_connection_count), scGIC(params.sc_gic) -{} +{ + for (int i = 0; i < params.port_wake_request_connection_count; i++) { + wakeRequestPorts.emplace_back(new IntSourcePin( + csprintf("%s.wakerequestport[%d]", name(), i), i, this)); + auto handler = [this, i](bool status) + { + auto &port = wakeRequestPorts[i]; + status ? port->raise() : port->lower(); + }; + scGIC->wakeRequests[i]->onChange(handler); + } +} Port & GIC::getPort(const std::string &if_name, PortID idx) @@ -323,6 +340,8 @@ GIC::getPort(const std::string &if_name, PortID idx) name(), idx), idx)); } return *ptr; + } else if (if_name == "wake_request") { + return *wakeRequestPorts.at(idx); } else { return BaseGic::getPort(if_name, idx); } diff --git a/src/arch/arm/fastmodel/GIC/gic.hh b/src/arch/arm/fastmodel/GIC/gic.hh index 27eccd4139..33a172ded2 100644 --- a/src/arch/arm/fastmodel/GIC/gic.hh +++ b/src/arch/arm/fastmodel/GIC/gic.hh @@ -36,7 +36,9 @@ #include #include "arch/arm/fastmodel/amba_ports.hh" +#include "arch/arm/fastmodel/common/signal_receiver.hh" #include "dev/arm/base_gic.hh" +#include "dev/intpin.hh" #include "params/FastModelGIC.hh" #include "params/SCFastModelGIC.hh" #include "scx_evs_GIC.h" @@ -92,6 +94,8 @@ class SCGIC : public scx_evs_GIC SignalInterruptInitiatorSocket signalInterrupt; + std::vector> wakeRequests; + void before_end_of_elaboration() override; void @@ -118,6 +122,7 @@ class GIC : public BaseGic AmbaInitiator ambaM; AmbaTarget ambaS; std::vector> redistributors; + std::vector>> wakeRequestPorts; SCGIC *scGIC; From 1e0504cf4acae8e7fa6edab7cf9e435ea488d66a Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Mon, 10 Jan 2022 13:36:30 +0800 Subject: [PATCH 047/658] fastmodel: Fix cluster build failed FastModelCortexCluster subclasses don't have `type` property. They don't need to be specified in sim_objects for generating *Params class. Change-Id: Ic09e494042e05d68c890f9603b8b78a4a8d815a9 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55305 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/arm/fastmodel/CortexA76/SConscript | 3 +-- src/arch/arm/fastmodel/CortexR52/SConscript | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/arch/arm/fastmodel/CortexA76/SConscript b/src/arch/arm/fastmodel/CortexA76/SConscript index ce51268467..016f6134ea 100644 --- a/src/arch/arm/fastmodel/CortexA76/SConscript +++ b/src/arch/arm/fastmodel/CortexA76/SConscript @@ -39,8 +39,7 @@ for name in ('x1', 'x2', 'x3', 'x4'): SimObject('FastModelCortexA76.py', sim_objects=[ 'FastModelCortexA76', 'FastModelCortexA76Cluster'] + - [f'FastModelScxEvsCortexA76x{num}' for num in (1, 2, 3, 4)] + - [f'FastModelCortexA76x{num}' for num in (1, 2, 3, 4)]) + [f'FastModelScxEvsCortexA76x{num}' for num in (1, 2, 3, 4)]) Source('cortex_a76.cc') Source('evs.cc') Source('thread_context.cc') diff --git a/src/arch/arm/fastmodel/CortexR52/SConscript b/src/arch/arm/fastmodel/CortexR52/SConscript index 4e5e147a01..c1dc1fe136 100644 --- a/src/arch/arm/fastmodel/CortexR52/SConscript +++ b/src/arch/arm/fastmodel/CortexR52/SConscript @@ -40,8 +40,7 @@ for name in ('x1', 'x2', 'x3', 'x4'): SimObject('FastModelCortexR52.py', sim_objects=[ 'FastModelCortexR52', 'FastModelCortexR52Cluster'] + - [f'FastModelScxEvsCortexR52x{num}' for num in (1, 2, 3, 4)] + - [f'FastModelCortexR52x{num}' for num in (1, 2, 3, 4)]) + [f'FastModelScxEvsCortexR52x{num}' for num in (1, 2, 3, 4)]) Source('cortex_r52.cc') Source('evs.cc') Source('thread_context.cc') From a8c85b1c401ee62fe2128810662a2c7233b41ce0 Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Mon, 10 Jan 2022 13:36:39 +0800 Subject: [PATCH 048/658] dev-arm: Mask el2_watchdog in VExpressFastmodel platform el2_watchdog depends on SystemCounter. However, we have mask system_counter in the platform. We should also mask the el2_watchdog accordingly. Change-Id: I2ed774549272438d654e0573ffe9f482a6659d37 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55306 Reviewed-by: Gabe Black Reviewed-by: Giacomo Travaglini Maintainer: Giacomo Travaglini Tested-by: kokoro --- src/dev/arm/VExpressFastmodel.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/dev/arm/VExpressFastmodel.py b/src/dev/arm/VExpressFastmodel.py index 6f9a731d3a..6e5ade4150 100644 --- a/src/dev/arm/VExpressFastmodel.py +++ b/src/dev/arm/VExpressFastmodel.py @@ -45,6 +45,7 @@ class VExpressFastmodel(VExpress_GEM5_Base): generic_timer = SubSystem() generic_timer_mem = SubSystem() sys_counter = SubSystem() + el2_watchdog = SubSystem() def _on_chip_devices(self): return [ From f4e84cd25eb4ed30417eb7a33df3b9a31473a47f Mon Sep 17 00:00:00 2001 From: Alex Richardson Date: Thu, 30 Dec 2021 18:23:34 +0000 Subject: [PATCH 049/658] cpu-simple: Convert invalid access assertions to panic() Currently, an access to an invalid address will cause GEM5 to exit with a `!pkt.isError()` assertion failure. I was seeing this assertion while running a baremetal RISC-V binary that faulted before the trap vector had been configured and therefore tried to jump to address zero. With this change we now print the invalid address and the type of access (ifetch/load/store/amo) which makes debugging such a problem much easier. For example, my faulting program now prints the following: `panic: Instruction fetch ([0:0x4]) failed: BadAddressError [0:3] IF` I also saw this assertion with a program that was dereferencing a NULL pointer, which now prints a more helpful message: `panic: Data fetch ([0x10:0x11]) failed: BadAddressError [10:10]` Change-Id: Id983b74bf4688711f47308c6c7c15f49662ac495 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55203 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/cpu/simple/atomic.cc | 13 ++++++++----- src/cpu/simple/timing.cc | 6 ++++-- 2 files changed, 12 insertions(+), 7 deletions(-) diff --git a/src/cpu/simple/atomic.cc b/src/cpu/simple/atomic.cc index d9738d22b0..d9e36758f1 100644 --- a/src/cpu/simple/atomic.cc +++ b/src/cpu/simple/atomic.cc @@ -406,7 +406,8 @@ AtomicSimpleCPU::readMem(Addr addr, uint8_t *data, unsigned size, } dcache_access = true; - assert(!pkt.isError()); + panic_if(pkt.isError(), "Data fetch (%s) failed: %s", + pkt.getAddrRange().to_string(), pkt.print()); if (req->isLLSC()) { thread->getIsaPtr()->handleLockedRead(req); @@ -508,8 +509,8 @@ AtomicSimpleCPU::writeMem(uint8_t *data, unsigned size, Addr addr, threadSnoop(&pkt, curThread); } dcache_access = true; - assert(!pkt.isError()); - + panic_if(pkt.isError(), "Data write (%s) failed: %s", + pkt.getAddrRange().to_string(), pkt.print()); if (req->isSwap()) { assert(res && curr_frag_id == 0); memcpy(res, pkt.getConstPtr(), size); @@ -597,7 +598,8 @@ AtomicSimpleCPU::amoMem(Addr addr, uint8_t* data, unsigned size, dcache_access = true; - assert(!pkt.isError()); + panic_if(pkt.isError(), "Atomic access (%s) failed: %s", + pkt.getAddrRange().to_string(), pkt.print()); assert(!req->isLLSC()); } @@ -752,7 +754,8 @@ AtomicSimpleCPU::fetchInstMem() pkt.dataStatic(decoder->moreBytesPtr()); Tick latency = sendPacket(icachePort, &pkt); - assert(!pkt.isError()); + panic_if(pkt.isError(), "Instruction fetch (%s) failed: %s", + pkt.getAddrRange().to_string(), pkt.print()); return latency; } diff --git a/src/cpu/simple/timing.cc b/src/cpu/simple/timing.cc index da3e0c0113..c7e63efa84 100644 --- a/src/cpu/simple/timing.cc +++ b/src/cpu/simple/timing.cc @@ -826,7 +826,8 @@ TimingSimpleCPU::completeIfetch(PacketPtr pkt) // received a response from the icache: execute the received // instruction - assert(!pkt || !pkt->isError()); + panic_if(pkt && pkt->isError(), "Instruction fetch (%s) failed: %s", + pkt->getAddrRange().to_string(), pkt->print()); assert(_status == IcacheWaitResponse); _status = BaseSimpleCPU::Running; @@ -950,7 +951,8 @@ TimingSimpleCPU::completeDataAccess(PacketPtr pkt) // received a response from the dcache: complete the load or store // instruction - assert(!pkt->isError()); + panic_if(pkt->isError(), "Data access (%s) failed: %s", + pkt->getAddrRange().to_string(), pkt->print()); assert(_status == DcacheWaitResponse || _status == DTBWaitResponse || pkt->req->getFlags().isSet(Request::NO_ACCESS)); From c498d8bced61bae51345a352b199b5c75eabadf8 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Fri, 29 Oct 2021 18:40:54 -0700 Subject: [PATCH 050/658] cpu: Specialize CPUs for an ISA at the leaves, not BaseCPU. The BaseCPU type had been specializing itself based on the value of TARGET_ISA, which is not compatible with building more than one ISA at a time. This change refactors the CPU models so that the BaseCPU is more general, and the ISA specific components are added to the CPU when the CPU types are fully specialized. For instance, The AtomicSimpleCPU has a version called X86AtomicSimpleCPU which installs the X86 specific aspects of the CPU. This specialization is done in three ways. 1. The mmu parameter is assigned an instance of the architecture specific MMU type. This provides a reasonable default, but also avoids having having to use the ISA specific type when the parameter is created. 2. The ISA specific types are made available as class attributes, and the utility functions (including __init__!) in the BaseCPU class can refer to them to get the types they need to set up the CPU at run time. Because SimObjects have strange, unhelpful semantics as far as assigning to their attributes, these types need to be set up in a non-SimObject class, which is then brought in as a base of the actual SimObject type. Because the metaclass of this other type is just "type", things work like you would expect. The SimObject doesn't do any special processing of base classes if they aren't also SimObjects, so these attributes survive and are accessible using normal lookup in the BaseCPU class. 3. There are some methods like addCheckerCPU and properties like needsTSO which have ISA specific values or behaviors. These are set in the ISA specific subclass, where they are inherently specific to an ISA and don't need to check TARGET_ISA. Also, the DummyChecker which was set up for the BaseSimpleCPU which doesn't actually do anything in either C++ or python was not carried forward. The CPU type still exists, but it isn't installed in the simple CPUs. To provide backward compatibility, each ISA implements a .py file which matches the original .py for a CPU, and the original is renamed with a Base prefix. The ISA specific version creates an alias with the old CPU name which maps to the ISA specific type. This way, old scripts which refer to, for example, AtomicSimpleCPU, will get the X86AtomicSimpleCPU if the x86 version was compiled in, the ArmAtomicSimpleCPU on arm, etc. Unfortunately, because of how tags on PySource and by extension SimObjects are implemented right now, if you set the tags on two SimObjects or PySources which have the same module path, the later will overwrite the former whether or not they both would be included. There are some changes in review which would revamp this and make it work like you would expect, without this central bookkeeping which has the conflict. Since I can't use that here, I fell back to checking TARGET_ISA to decide whether to tell SCons about those files at all. In the long term, this mechanism should be revamped so that these compatibility types are only available if there is exactly one ISA compiled into gem5. After the configs have been updated and no longer assume they can use AtomicSimpleCPU in all cases, then these types can be deleted. Also, because ISAs can now either provide subclasses for a CPU or not, the CPU_MODELS variable has been removed, meaning the non-ISA specialized versions of those CPU models will always be included in gem5, except when building the NULL ISA. In the future, a more granular config mechanism will hopefully be implemented for *all* of gem5 and not just the CPUs, and these can be conditional again in case you only need certain models, and want to reduce build time or binary size by excluding the others. Change-Id: I02fc3f645c551678ede46268bbea9f66c3f6c74b Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/52490 Reviewed-by: Andreas Sandberg Maintainer: Gabe Black Tested-by: kokoro --- build_opts/ARM | 1 - build_opts/ARM_MESI_Three_Level | 1 - build_opts/ARM_MESI_Three_Level_HTM | 1 - build_opts/ARM_MOESI_hammer | 1 - build_opts/GCN3_X86 | 1 - build_opts/Garnet_standalone | 1 - build_opts/MIPS | 1 - build_opts/NULL | 1 - build_opts/NULL_MESI_Two_Level | 1 - build_opts/NULL_MOESI_CMP_directory | 1 - build_opts/NULL_MOESI_CMP_token | 1 - build_opts/NULL_MOESI_hammer | 1 - build_opts/POWER | 1 - build_opts/RISCV | 1 - build_opts/SPARC | 1 - build_opts/VEGA_X86 | 1 - build_opts/X86 | 3 +- build_opts/X86_MESI_Two_Level | 1 - build_opts/X86_MI_example | 1 - build_opts/X86_MOESI_AMD_Base | 1 - configs/common/cores/arm/HPI.py | 2 +- configs/common/cores/arm/O3_ARM_v7a.py | 2 +- configs/common/cores/arm/ex5_LITTLE.py | 2 +- configs/common/cores/arm/ex5_big.py | 2 +- src/arch/arm/ArmCPU.py | 78 +++++++++++++++++++ src/arch/arm/AtomicSimpleCPU.py | 28 +++++++ src/arch/arm/MinorCPU.py | 28 +++++++ src/arch/arm/NonCachingSimpleCPU.py | 28 +++++++ src/{cpu/o3/SConsopts => arch/arm/O3CPU.py} | 12 +-- src/{cpu/o3 => arch/arm}/O3Checker.py | 11 +-- src/arch/arm/SConscript | 9 +++ src/arch/arm/TimingSimpleCPU.py | 28 +++++++ src/arch/arm/fastmodel/iris/Iris.py | 10 ++- src/arch/arm/kvm/BaseArmKvmCPU.py | 6 +- src/arch/mips/AtomicSimpleCPU.py | 28 +++++++ .../minor/SConsopts => arch/mips/MipsCPU.py} | 41 ++++++---- src/arch/mips/NonCachingSimpleCPU.py | 28 +++++++ .../checker/SConsopts => arch/mips/O3CPU.py} | 12 +-- src/arch/mips/SConscript | 7 ++ src/arch/mips/TimingSimpleCPU.py | 28 +++++++ src/arch/power/AtomicSimpleCPU.py | 28 +++++++ src/arch/power/NonCachingSimpleCPU.py | 28 +++++++ .../simple/SConsopts => arch/power/O3CPU.py} | 12 +-- src/arch/power/PowerCPU.py | 51 ++++++++++++ src/arch/power/SConscript | 7 ++ src/arch/power/TimingSimpleCPU.py | 28 +++++++ src/arch/riscv/AtomicSimpleCPU.py | 28 +++++++ src/arch/riscv/MinorCPU.py | 28 +++++++ src/arch/riscv/NonCachingSimpleCPU.py | 28 +++++++ src/{cpu/SConsopts => arch/riscv/O3CPU.py} | 12 +-- src/arch/riscv/RiscvCPU.py | 55 +++++++++++++ src/arch/riscv/SConscript | 8 ++ src/arch/riscv/TimingSimpleCPU.py | 28 +++++++ src/arch/sparc/AtomicSimpleCPU.py | 28 +++++++ src/arch/sparc/NonCachingSimpleCPU.py | 28 +++++++ src/arch/sparc/O3CPU.py | 31 ++++++++ src/arch/sparc/SConscript | 7 ++ src/arch/sparc/SparcCPU.py | 51 ++++++++++++ src/arch/sparc/TimingSimpleCPU.py | 28 +++++++ src/arch/x86/AtomicSimpleCPU.py | 28 +++++++ src/arch/x86/NonCachingSimpleCPU.py | 28 +++++++ src/arch/x86/O3CPU.py | 31 ++++++++ src/arch/x86/SConscript | 7 ++ src/arch/x86/TimingSimpleCPU.py | 28 +++++++ src/arch/x86/X86CPU.py | 62 +++++++++++++++ src/arch/x86/kvm/X86KvmCPU.py | 6 +- src/cpu/BaseCPU.py | 56 +++---------- .../minor/{MinorCPU.py => BaseMinorCPU.py} | 4 +- src/cpu/minor/SConscript | 6 +- src/cpu/minor/cpu.cc | 2 +- src/cpu/minor/cpu.hh | 4 +- src/cpu/minor/decode.cc | 2 +- src/cpu/minor/decode.hh | 2 +- src/cpu/minor/execute.cc | 2 +- src/cpu/minor/execute.hh | 2 +- src/cpu/minor/fetch1.cc | 2 +- src/cpu/minor/fetch1.hh | 2 +- src/cpu/minor/fetch2.cc | 2 +- src/cpu/minor/fetch2.hh | 4 +- src/cpu/minor/pipeline.cc | 2 +- src/cpu/minor/pipeline.hh | 4 +- src/cpu/o3/{O3CPU.py => BaseO3CPU.py} | 61 +++++---------- src/cpu/o3/BaseO3Checker.py | 33 ++++++++ src/cpu/o3/SConscript | 6 +- src/cpu/o3/commit.cc | 4 +- src/cpu/o3/commit.hh | 4 +- src/cpu/o3/cpu.cc | 2 +- src/cpu/o3/cpu.hh | 4 +- src/cpu/o3/decode.cc | 4 +- src/cpu/o3/decode.hh | 4 +- src/cpu/o3/fetch.cc | 4 +- src/cpu/o3/fetch.hh | 4 +- src/cpu/o3/iew.cc | 4 +- src/cpu/o3/iew.hh | 4 +- src/cpu/o3/inst_queue.cc | 4 +- src/cpu/o3/inst_queue.hh | 5 +- src/cpu/o3/lsq.cc | 4 +- src/cpu/o3/lsq.hh | 4 +- src/cpu/o3/lsq_unit.cc | 2 +- src/cpu/o3/lsq_unit.hh | 4 +- src/cpu/o3/mem_dep_unit.cc | 6 +- src/cpu/o3/mem_dep_unit.hh | 6 +- src/cpu/o3/probe/SConscript | 2 +- src/cpu/o3/rename.cc | 4 +- src/cpu/o3/rename.hh | 4 +- src/cpu/o3/rob.cc | 4 +- src/cpu/o3/rob.hh | 4 +- ...micSimpleCPU.py => BaseAtomicSimpleCPU.py} | 4 +- ...impleCPU.py => BaseNonCachingSimpleCPU.py} | 6 +- src/cpu/simple/BaseSimpleCPU.py | 12 --- ...ingSimpleCPU.py => BaseTimingSimpleCPU.py} | 4 +- src/cpu/simple/SConscript | 16 ++-- src/cpu/simple/atomic.cc | 4 +- src/cpu/simple/atomic.hh | 4 +- src/cpu/simple/noncaching.cc | 3 +- src/cpu/simple/noncaching.hh | 4 +- src/cpu/simple/probes/SConscript | 2 +- src/cpu/simple/timing.cc | 4 +- src/cpu/simple/timing.hh | 4 +- src/cpu/testers/memtest/SConscript | 1 - 120 files changed, 1194 insertions(+), 277 deletions(-) create mode 100644 src/arch/arm/ArmCPU.py create mode 100644 src/arch/arm/AtomicSimpleCPU.py create mode 100644 src/arch/arm/MinorCPU.py create mode 100644 src/arch/arm/NonCachingSimpleCPU.py rename src/{cpu/o3/SConsopts => arch/arm/O3CPU.py} (90%) rename src/{cpu/o3 => arch/arm}/O3Checker.py (83%) create mode 100644 src/arch/arm/TimingSimpleCPU.py create mode 100644 src/arch/mips/AtomicSimpleCPU.py rename src/{cpu/minor/SConsopts => arch/mips/MipsCPU.py} (62%) create mode 100644 src/arch/mips/NonCachingSimpleCPU.py rename src/{cpu/checker/SConsopts => arch/mips/O3CPU.py} (89%) create mode 100644 src/arch/mips/TimingSimpleCPU.py create mode 100644 src/arch/power/AtomicSimpleCPU.py create mode 100644 src/arch/power/NonCachingSimpleCPU.py rename src/{cpu/simple/SConsopts => arch/power/O3CPU.py} (88%) create mode 100644 src/arch/power/PowerCPU.py create mode 100644 src/arch/power/TimingSimpleCPU.py create mode 100644 src/arch/riscv/AtomicSimpleCPU.py create mode 100644 src/arch/riscv/MinorCPU.py create mode 100644 src/arch/riscv/NonCachingSimpleCPU.py rename src/{cpu/SConsopts => arch/riscv/O3CPU.py} (86%) create mode 100644 src/arch/riscv/RiscvCPU.py create mode 100644 src/arch/riscv/TimingSimpleCPU.py create mode 100644 src/arch/sparc/AtomicSimpleCPU.py create mode 100644 src/arch/sparc/NonCachingSimpleCPU.py create mode 100644 src/arch/sparc/O3CPU.py create mode 100644 src/arch/sparc/SparcCPU.py create mode 100644 src/arch/sparc/TimingSimpleCPU.py create mode 100644 src/arch/x86/AtomicSimpleCPU.py create mode 100644 src/arch/x86/NonCachingSimpleCPU.py create mode 100644 src/arch/x86/O3CPU.py create mode 100644 src/arch/x86/TimingSimpleCPU.py create mode 100644 src/arch/x86/X86CPU.py rename src/cpu/minor/{MinorCPU.py => BaseMinorCPU.py} (99%) rename src/cpu/o3/{O3CPU.py => BaseO3CPU.py} (78%) create mode 100644 src/cpu/o3/BaseO3Checker.py rename src/cpu/simple/{AtomicSimpleCPU.py => BaseAtomicSimpleCPU.py} (97%) rename src/cpu/simple/{NonCachingSimpleCPU.py => BaseNonCachingSimpleCPU.py} (94%) rename src/cpu/simple/{TimingSimpleCPU.py => BaseTimingSimpleCPU.py} (96%) diff --git a/build_opts/ARM b/build_opts/ARM index e4cb9a5066..5b7da10e22 100644 --- a/build_opts/ARM +++ b/build_opts/ARM @@ -1,3 +1,2 @@ TARGET_ISA = 'arm' -CPU_MODELS = 'AtomicSimpleCPU,TimingSimpleCPU,O3CPU,MinorCPU' PROTOCOL = 'CHI' diff --git a/build_opts/ARM_MESI_Three_Level b/build_opts/ARM_MESI_Three_Level index 29a429ce68..2ca31b64cc 100644 --- a/build_opts/ARM_MESI_Three_Level +++ b/build_opts/ARM_MESI_Three_Level @@ -2,5 +2,4 @@ # All rights reserved. TARGET_ISA = 'arm' -CPU_MODELS = 'TimingSimpleCPU,O3CPU' PROTOCOL = 'MESI_Three_Level' diff --git a/build_opts/ARM_MESI_Three_Level_HTM b/build_opts/ARM_MESI_Three_Level_HTM index fd7c164940..703398d786 100644 --- a/build_opts/ARM_MESI_Three_Level_HTM +++ b/build_opts/ARM_MESI_Three_Level_HTM @@ -2,5 +2,4 @@ # All rights reserved. TARGET_ISA = 'arm' -CPU_MODELS = 'TimingSimpleCPU,O3CPU' PROTOCOL = 'MESI_Three_Level_HTM' diff --git a/build_opts/ARM_MOESI_hammer b/build_opts/ARM_MOESI_hammer index 2ba8ce835b..bd5c63f0d2 100644 --- a/build_opts/ARM_MOESI_hammer +++ b/build_opts/ARM_MOESI_hammer @@ -2,5 +2,4 @@ # All rights reserved. TARGET_ISA = 'arm' -CPU_MODELS = 'TimingSimpleCPU,O3CPU' PROTOCOL = 'MOESI_hammer' diff --git a/build_opts/GCN3_X86 b/build_opts/GCN3_X86 index 21e3cf0e45..b39690812e 100644 --- a/build_opts/GCN3_X86 +++ b/build_opts/GCN3_X86 @@ -2,4 +2,3 @@ PROTOCOL = 'GPU_VIPER' TARGET_ISA = 'x86' TARGET_GPU_ISA = 'gcn3' BUILD_GPU = True -CPU_MODELS = 'AtomicSimpleCPU,O3CPU,TimingSimpleCPU' diff --git a/build_opts/Garnet_standalone b/build_opts/Garnet_standalone index f749d54ca2..fd730c3f48 100644 --- a/build_opts/Garnet_standalone +++ b/build_opts/Garnet_standalone @@ -1,3 +1,2 @@ TARGET_ISA = 'null' -CPU_MODELS = '' PROTOCOL = 'Garnet_standalone' diff --git a/build_opts/MIPS b/build_opts/MIPS index ecb2b09725..26cb23c393 100644 --- a/build_opts/MIPS +++ b/build_opts/MIPS @@ -1,3 +1,2 @@ TARGET_ISA = 'mips' -CPU_MODELS = 'AtomicSimpleCPU,TimingSimpleCPU,O3CPU' PROTOCOL = 'MI_example' diff --git a/build_opts/NULL b/build_opts/NULL index 1242fa9ef6..b749729fbe 100644 --- a/build_opts/NULL +++ b/build_opts/NULL @@ -1,3 +1,2 @@ TARGET_ISA = 'null' -CPU_MODELS = '' PROTOCOL='MI_example' diff --git a/build_opts/NULL_MESI_Two_Level b/build_opts/NULL_MESI_Two_Level index db05046b52..09147b2250 100644 --- a/build_opts/NULL_MESI_Two_Level +++ b/build_opts/NULL_MESI_Two_Level @@ -1,3 +1,2 @@ TARGET_ISA = 'null' -CPU_MODELS = '' PROTOCOL = 'MESI_Two_Level' diff --git a/build_opts/NULL_MOESI_CMP_directory b/build_opts/NULL_MOESI_CMP_directory index 7136d0b93c..466a268c9d 100644 --- a/build_opts/NULL_MOESI_CMP_directory +++ b/build_opts/NULL_MOESI_CMP_directory @@ -1,3 +1,2 @@ TARGET_ISA = 'null' -CPU_MODELS = '' PROTOCOL='MOESI_CMP_directory' diff --git a/build_opts/NULL_MOESI_CMP_token b/build_opts/NULL_MOESI_CMP_token index 42fff75f36..0cd030503d 100644 --- a/build_opts/NULL_MOESI_CMP_token +++ b/build_opts/NULL_MOESI_CMP_token @@ -1,3 +1,2 @@ TARGET_ISA = 'null' -CPU_MODELS = '' PROTOCOL='MOESI_CMP_token' diff --git a/build_opts/NULL_MOESI_hammer b/build_opts/NULL_MOESI_hammer index ff4c22c4b2..39ebcae641 100644 --- a/build_opts/NULL_MOESI_hammer +++ b/build_opts/NULL_MOESI_hammer @@ -1,3 +1,2 @@ TARGET_ISA = 'null' -CPU_MODELS = '' PROTOCOL='MOESI_hammer' diff --git a/build_opts/POWER b/build_opts/POWER index 672046ceeb..35772a4795 100644 --- a/build_opts/POWER +++ b/build_opts/POWER @@ -1,3 +1,2 @@ TARGET_ISA = 'power' -CPU_MODELS = 'AtomicSimpleCPU,TimingSimpleCPU,O3CPU' PROTOCOL = 'MI_example' diff --git a/build_opts/RISCV b/build_opts/RISCV index 38abd92165..0bd069d489 100644 --- a/build_opts/RISCV +++ b/build_opts/RISCV @@ -1,3 +1,2 @@ TARGET_ISA = 'riscv' -CPU_MODELS = 'AtomicSimpleCPU,TimingSimpleCPU,MinorCPU,O3CPU' PROTOCOL = 'MI_example' diff --git a/build_opts/SPARC b/build_opts/SPARC index 63ec7cbaff..98acfe2406 100644 --- a/build_opts/SPARC +++ b/build_opts/SPARC @@ -1,3 +1,2 @@ TARGET_ISA = 'sparc' -CPU_MODELS = 'AtomicSimpleCPU,TimingSimpleCPU,O3CPU' PROTOCOL = 'MI_example' diff --git a/build_opts/VEGA_X86 b/build_opts/VEGA_X86 index 796b556129..11e8232129 100644 --- a/build_opts/VEGA_X86 +++ b/build_opts/VEGA_X86 @@ -2,4 +2,3 @@ PROTOCOL = 'GPU_VIPER' TARGET_ISA = 'x86' TARGET_GPU_ISA = 'vega' BUILD_GPU = True -CPU_MODELS = 'AtomicSimpleCPU,O3CPU,TimingSimpleCPU' diff --git a/build_opts/X86 b/build_opts/X86 index 27c1b586b0..72b200acaa 100644 --- a/build_opts/X86 +++ b/build_opts/X86 @@ -1,4 +1,3 @@ TARGET_ISA = 'x86' -CPU_MODELS = 'TimingSimpleCPU,O3CPU,AtomicSimpleCPU' PROTOCOL = 'MESI_Two_Level' -NUMBER_BITS_PER_SET = '128' \ No newline at end of file +NUMBER_BITS_PER_SET = '128' diff --git a/build_opts/X86_MESI_Two_Level b/build_opts/X86_MESI_Two_Level index eba850b331..72b200acaa 100644 --- a/build_opts/X86_MESI_Two_Level +++ b/build_opts/X86_MESI_Two_Level @@ -1,4 +1,3 @@ TARGET_ISA = 'x86' -CPU_MODELS = 'TimingSimpleCPU,O3CPU,AtomicSimpleCPU' PROTOCOL = 'MESI_Two_Level' NUMBER_BITS_PER_SET = '128' diff --git a/build_opts/X86_MI_example b/build_opts/X86_MI_example index 60d1645c95..483cf0486a 100644 --- a/build_opts/X86_MI_example +++ b/build_opts/X86_MI_example @@ -1,3 +1,2 @@ TARGET_ISA = 'x86' -CPU_MODELS = 'TimingSimpleCPU,O3CPU,AtomicSimpleCPU' PROTOCOL = 'MI_example' diff --git a/build_opts/X86_MOESI_AMD_Base b/build_opts/X86_MOESI_AMD_Base index e85f36d822..261bedb925 100644 --- a/build_opts/X86_MOESI_AMD_Base +++ b/build_opts/X86_MOESI_AMD_Base @@ -1,3 +1,2 @@ PROTOCOL = 'MOESI_AMD_Base' TARGET_ISA = 'x86' -CPU_MODELS = 'AtomicSimpleCPU,O3CPU,TimingSimpleCPU' \ No newline at end of file diff --git a/configs/common/cores/arm/HPI.py b/configs/common/cores/arm/HPI.py index 620c01ebd5..3a11133a5b 100644 --- a/configs/common/cores/arm/HPI.py +++ b/configs/common/cores/arm/HPI.py @@ -1379,7 +1379,7 @@ class HPI_L2(Cache): write_buffers = 16 # prefetcher FIXME -class HPI(MinorCPU): +class HPI(ArmMinorCPU): # Inherit the doc string from the module to avoid repeating it # here. __doc__ = __doc__ diff --git a/configs/common/cores/arm/O3_ARM_v7a.py b/configs/common/cores/arm/O3_ARM_v7a.py index 8cacc65ebb..d032a1aa88 100644 --- a/configs/common/cores/arm/O3_ARM_v7a.py +++ b/configs/common/cores/arm/O3_ARM_v7a.py @@ -99,7 +99,7 @@ class O3_ARM_v7a_BP(BiModeBP): RASSize = 16 instShiftAmt = 2 -class O3_ARM_v7a_3(DerivO3CPU): +class O3_ARM_v7a_3(ArmO3CPU): LQEntries = 16 SQEntries = 16 LSQDepCheckShift = 0 diff --git a/configs/common/cores/arm/ex5_LITTLE.py b/configs/common/cores/arm/ex5_LITTLE.py index bcbaa922cd..57f6a6b812 100644 --- a/configs/common/cores/arm/ex5_LITTLE.py +++ b/configs/common/cores/arm/ex5_LITTLE.py @@ -88,7 +88,7 @@ class ex5_LITTLE_FUP(MinorFUPool): ex5_LITTLE_FP(), ex5_LITTLE_MemFU(), ex5_LITTLE_MiscFU()] -class ex5_LITTLE(MinorCPU): +class ex5_LITTLE(ArmMinorCPU): executeFuncUnits = ex5_LITTLE_FUP() class L1Cache(Cache): diff --git a/configs/common/cores/arm/ex5_big.py b/configs/common/cores/arm/ex5_big.py index eb5f53ff0c..de7a45063a 100644 --- a/configs/common/cores/arm/ex5_big.py +++ b/configs/common/cores/arm/ex5_big.py @@ -99,7 +99,7 @@ class ex5_big_BP(BiModeBP): RASSize = 48 instShiftAmt = 2 -class ex5_big(DerivO3CPU): +class ex5_big(ArmO3CPU): LQEntries = 16 SQEntries = 16 LSQDepCheckShift = 0 diff --git a/src/arch/arm/ArmCPU.py b/src/arch/arm/ArmCPU.py new file mode 100644 index 0000000000..c55d99bf1a --- /dev/null +++ b/src/arch/arm/ArmCPU.py @@ -0,0 +1,78 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.proxy import Self + +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU +from m5.objects.BaseNonCachingSimpleCPU import BaseNonCachingSimpleCPU +from m5.objects.BaseTimingSimpleCPU import BaseTimingSimpleCPU +from m5.objects.BaseO3CPU import BaseO3CPU +from m5.objects.BaseO3Checker import BaseO3Checker +from m5.objects.BaseMinorCPU import BaseMinorCPU +from m5.objects.ArmDecoder import ArmDecoder +from m5.objects.ArmMMU import ArmMMU +from m5.objects.ArmInterrupts import ArmInterrupts +from m5.objects.ArmISA import ArmISA + +class ArmCPU: + ArchDecoder = ArmDecoder + ArchMMU = ArmMMU + ArchInterrupts = ArmInterrupts + ArchISA = ArmISA + +class ArmAtomicSimpleCPU(BaseAtomicSimpleCPU, ArmCPU): + mmu = ArmMMU() + +class ArmNonCachingSimpleCPU(BaseNonCachingSimpleCPU, ArmCPU): + mmu = ArmMMU() + +class ArmTimingSimpleCPU(BaseTimingSimpleCPU, ArmCPU): + mmu = ArmMMU() + +class ArmO3Checker(BaseO3Checker, ArmCPU): + mmu = ArmMMU() + +class ArmO3CPU(BaseO3CPU, ArmCPU): + mmu = ArmMMU() + + # For x86, each CC reg is used to hold only a subset of the + # flags, so we need 4-5 times the number of CC regs as + # physical integer regs to be sure we don't run out. In + # typical real machines, CC regs are not explicitly renamed + # (it's a side effect of int reg renaming), so they should + # never be the bottleneck here. + numPhysCCRegs = Self.numPhysIntRegs * 5 + + def addCheckerCpu(self): + self.checker = ArmO3Checker(workload=self.workload, + exitOnError=False, + updateOnError=True, + warnOnlyOnLoadError=True) + self.checker.mmu.itb.size = self.mmu.itb.size + self.checker.mmu.dtb.size = self.mmu.dtb.size + self.checker.cpu_id = self.cpu_id + +class ArmMinorCPU(BaseMinorCPU, ArmCPU): + mmu = ArmMMU() diff --git a/src/arch/arm/AtomicSimpleCPU.py b/src/arch/arm/AtomicSimpleCPU.py new file mode 100644 index 0000000000..c3a25ba52e --- /dev/null +++ b/src/arch/arm/AtomicSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.ArmCPU import ArmAtomicSimpleCPU + +AtomicSimpleCPU = ArmAtomicSimpleCPU diff --git a/src/arch/arm/MinorCPU.py b/src/arch/arm/MinorCPU.py new file mode 100644 index 0000000000..bac019774e --- /dev/null +++ b/src/arch/arm/MinorCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.ArmCPU import ArmMinorCPU + +MinorCPU = ArmMinorCPU diff --git a/src/arch/arm/NonCachingSimpleCPU.py b/src/arch/arm/NonCachingSimpleCPU.py new file mode 100644 index 0000000000..bfad3ba88b --- /dev/null +++ b/src/arch/arm/NonCachingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.ArmCPU import ArmNonCachingSimpleCPU + +NonCachingSimpleCPU = ArmNonCachingSimpleCPU diff --git a/src/cpu/o3/SConsopts b/src/arch/arm/O3CPU.py similarity index 90% rename from src/cpu/o3/SConsopts rename to src/arch/arm/O3CPU.py index 3479484f16..54782e746e 100644 --- a/src/cpu/o3/SConsopts +++ b/src/arch/arm/O3CPU.py @@ -1,7 +1,4 @@ -# -*- mode:python -*- - -# Copyright (c) 2006 The Regents of The University of Michigan -# All rights reserved. +# Copyright 2021 Google, Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -26,6 +23,9 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -Import('*') +from m5.objects.ArmCPU import ArmO3CPU -main.Append(ALL_CPU_MODELS=['O3CPU']) +O3CPU = ArmO3CPU + +# Deprecated +DerivO3CPU = O3CPU diff --git a/src/cpu/o3/O3Checker.py b/src/arch/arm/O3Checker.py similarity index 83% rename from src/cpu/o3/O3Checker.py rename to src/arch/arm/O3Checker.py index c343cd678e..0ac7ab42a7 100644 --- a/src/cpu/o3/O3Checker.py +++ b/src/arch/arm/O3Checker.py @@ -1,5 +1,4 @@ -# Copyright (c) 2007 The Regents of The University of Michigan -# All rights reserved. +# Copyright 2021 Google, Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -24,10 +23,6 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -from m5.params import * -from m5.objects.CheckerCPU import CheckerCPU +from m5.objects.ArmCPU import ArmO3Checker -class O3Checker(CheckerCPU): - type = 'O3Checker' - cxx_class = 'gem5::o3::Checker' - cxx_header = 'cpu/o3/checker.hh' +O3Checker = ArmO3Checker diff --git a/src/arch/arm/SConscript b/src/arch/arm/SConscript index b13821270e..a00ba8d749 100644 --- a/src/arch/arm/SConscript +++ b/src/arch/arm/SConscript @@ -112,6 +112,15 @@ SimObject('ArmTLB.py', sim_objects=['ArmTLB'], enums=['ArmLookupLevel'], tags='arm isa') SimObject('ArmPMU.py', sim_objects=['ArmPMU'], tags='arm isa') +SimObject('ArmCPU.py', sim_objects=[], tags='arm isa') +if env['TARGET_ISA'] == 'arm': + SimObject('AtomicSimpleCPU.py', sim_objects=[], tags='arm isa') + SimObject('TimingSimpleCPU.py', sim_objects=[], tags='arm isa') + SimObject('NonCachingSimpleCPU.py', sim_objects=[], tags='arm isa') + SimObject('O3CPU.py', sim_objects=[], tags='arm isa') + SimObject('O3Checker.py', sim_objects=[], tags='arm isa') + SimObject('MinorCPU.py', sim_objects=[], tags='arm isa') + DebugFlag('Arm', tags='arm isa') DebugFlag('ArmTme', 'Transactional Memory Extension', tags='arm isa') DebugFlag('Semihosting', tags='arm isa') diff --git a/src/arch/arm/TimingSimpleCPU.py b/src/arch/arm/TimingSimpleCPU.py new file mode 100644 index 0000000000..8a20a36345 --- /dev/null +++ b/src/arch/arm/TimingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.ArmCPU import ArmTimingSimpleCPU + +TimingSimpleCPU = ArmTimingSimpleCPU diff --git a/src/arch/arm/fastmodel/iris/Iris.py b/src/arch/arm/fastmodel/iris/Iris.py index 497971531c..51eb3943dc 100644 --- a/src/arch/arm/fastmodel/iris/Iris.py +++ b/src/arch/arm/fastmodel/iris/Iris.py @@ -66,7 +66,12 @@ class IrisISA(BaseISA): cxx_class = 'gem5::Iris::ISA' cxx_header = 'arch/arm/fastmodel/iris/isa.hh' -class IrisBaseCPU(BaseCPU): +class IrisCPU(): + ArchMMU = IrisMMU + ArchInterrupts = IrisInterrupts + ArchISA = IrisISA + +class IrisBaseCPU(BaseCPU, IrisCPU): type = 'IrisBaseCPU' abstract = True cxx_class = 'gem5::Iris::BaseCPU' @@ -97,6 +102,3 @@ class IrisBaseCPU(BaseCPU): self.isa = [ IrisISA() for i in range(self.numThreads) ] else: assert(len(self.isa) == int(self.numThreads)) - - def createInterruptController(self): - self.interrupts = [ IrisInterrupts() for i in range(self.numThreads) ] diff --git a/src/arch/arm/kvm/BaseArmKvmCPU.py b/src/arch/arm/kvm/BaseArmKvmCPU.py index 63a11d8f60..364fe447a1 100644 --- a/src/arch/arm/kvm/BaseArmKvmCPU.py +++ b/src/arch/arm/kvm/BaseArmKvmCPU.py @@ -34,10 +34,14 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. from m5.params import * +from m5.objects.ArmCPU import ArmCPU +from m5.objects.ArmMMU import ArmMMU from m5.objects.BaseKvmCPU import BaseKvmCPU -class BaseArmKvmCPU(BaseKvmCPU): +class BaseArmKvmCPU(BaseKvmCPU, ArmCPU): type = 'BaseArmKvmCPU' cxx_header = "arch/arm/kvm/base_cpu.hh" cxx_class = 'gem5::BaseArmKvmCPU' abstract = True + + mmu = ArmMMU() diff --git a/src/arch/mips/AtomicSimpleCPU.py b/src/arch/mips/AtomicSimpleCPU.py new file mode 100644 index 0000000000..93c289aadf --- /dev/null +++ b/src/arch/mips/AtomicSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.MipsCPU import MipsAtomicSimpleCPU + +AtomicSimpleCPU = MipsAtomicSimpleCPU diff --git a/src/cpu/minor/SConsopts b/src/arch/mips/MipsCPU.py similarity index 62% rename from src/cpu/minor/SConsopts rename to src/arch/mips/MipsCPU.py index 16ff599cb6..61b7fd23b5 100644 --- a/src/cpu/minor/SConsopts +++ b/src/arch/mips/MipsCPU.py @@ -1,16 +1,4 @@ -# -*- mode:python -*- - -# Copyright (c) 2012-2014 ARM Limited -# All rights reserved. -# -# The license below extends only to copyright in the software and shall -# not be construed as granting a license to any other intellectual -# property including but not limited to intellectual property relating -# to a hardware implementation of the functionality of the software -# licensed hereunder. You may use the software subject to the license -# terms below provided that you ensure that this notice is replicated -# unmodified and in its entirety in all distributions of the software, -# modified or unmodified, in source code or in binary form. +# Copyright 2021 Google, Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -35,6 +23,29 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -Import('*') +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU +from m5.objects.BaseNonCachingSimpleCPU import BaseNonCachingSimpleCPU +from m5.objects.BaseTimingSimpleCPU import BaseTimingSimpleCPU +from m5.objects.BaseO3CPU import BaseO3CPU +from m5.objects.MipsDecoder import MipsDecoder +from m5.objects.MipsMMU import MipsMMU +from m5.objects.MipsInterrupts import MipsInterrupts +from m5.objects.MipsISA import MipsISA -main.Append(ALL_CPU_MODELS=['MinorCPU']) +class MipsCPU: + ArchDecoder = MipsDecoder + ArchMMU = MipsMMU + ArchInterrupts = MipsInterrupts + ArchISA = MipsISA + +class MipsAtomicSimpleCPU(BaseAtomicSimpleCPU, MipsCPU): + mmu = MipsMMU() + +class MipsNonCachingSimpleCPU(BaseNonCachingSimpleCPU, MipsCPU): + mmu = MipsMMU() + +class MipsTimingSimpleCPU(BaseTimingSimpleCPU, MipsCPU): + mmu = MipsMMU() + +class MipsO3CPU(BaseO3CPU, MipsCPU): + mmu = MipsMMU() diff --git a/src/arch/mips/NonCachingSimpleCPU.py b/src/arch/mips/NonCachingSimpleCPU.py new file mode 100644 index 0000000000..b3753475e1 --- /dev/null +++ b/src/arch/mips/NonCachingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.MipsCPU import MipsNonCachingSimpleCPU + +NonCachingSimpleCPU = MipsNonCachingSimpleCPU diff --git a/src/cpu/checker/SConsopts b/src/arch/mips/O3CPU.py similarity index 89% rename from src/cpu/checker/SConsopts rename to src/arch/mips/O3CPU.py index 5a7a873819..8f7b14cfc6 100644 --- a/src/cpu/checker/SConsopts +++ b/src/arch/mips/O3CPU.py @@ -1,7 +1,4 @@ -# -*- mode:python -*- - -# Copyright (c) 2003-2006 The Regents of The University of Michigan -# All rights reserved. +# Copyright 2021 Google, Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -26,6 +23,9 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -Import('*') +from m5.objects.MipsCPU import MipsO3CPU -main.Append(ALL_CPU_MODELS=['CheckerCPU']) +O3CPU = MipsO3CPU + +# Deprecated +DerivO3CPU = O3CPU diff --git a/src/arch/mips/SConscript b/src/arch/mips/SConscript index 2a4110a247..4f09e49641 100644 --- a/src/arch/mips/SConscript +++ b/src/arch/mips/SConscript @@ -51,6 +51,13 @@ SimObject('MipsSeWorkload.py', sim_objects=['MipsSEWorkload', 'MipsEmuLinux'], tags='mips isa') SimObject('MipsTLB.py', sim_objects=['MipsTLB'], tags='mips isa') +SimObject('MipsCPU.py', sim_objects=[], tags='mips isa') +if env['TARGET_ISA'] == 'mips': + SimObject('AtomicSimpleCPU.py', sim_objects=[], tags='mips isa') + SimObject('TimingSimpleCPU.py', sim_objects=[], tags='mips isa') + SimObject('NonCachingSimpleCPU.py', sim_objects=[], tags='mips isa') + SimObject('O3CPU.py', sim_objects=[], tags='mips isa') + DebugFlag('MipsPRA', tags='mips isa') ISADesc('isa/main.isa', tags='mips isa') diff --git a/src/arch/mips/TimingSimpleCPU.py b/src/arch/mips/TimingSimpleCPU.py new file mode 100644 index 0000000000..af687a7d1a --- /dev/null +++ b/src/arch/mips/TimingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.MipsCPU import MipsTimingSimpleCPU + +TimingSimpleCPU = MipsTimingSimpleCPU diff --git a/src/arch/power/AtomicSimpleCPU.py b/src/arch/power/AtomicSimpleCPU.py new file mode 100644 index 0000000000..55b6b960b1 --- /dev/null +++ b/src/arch/power/AtomicSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.PowerCPU import PowerAtomicSimpleCPU + +AtomicSimpleCPU = PowerAtomicSimpleCPU diff --git a/src/arch/power/NonCachingSimpleCPU.py b/src/arch/power/NonCachingSimpleCPU.py new file mode 100644 index 0000000000..171a90d9a1 --- /dev/null +++ b/src/arch/power/NonCachingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.PowerCPU import PowerNonCachingSimpleCPU + +NonCachingSimpleCPU = PowerNonCachingSimpleCPU diff --git a/src/cpu/simple/SConsopts b/src/arch/power/O3CPU.py similarity index 88% rename from src/cpu/simple/SConsopts rename to src/arch/power/O3CPU.py index f12fee2b78..fdb63edc9e 100644 --- a/src/cpu/simple/SConsopts +++ b/src/arch/power/O3CPU.py @@ -1,7 +1,4 @@ -# -*- mode:python -*- - -# Copyright (c) 2006 The Regents of The University of Michigan -# All rights reserved. +# Copyright 2021 Google, Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -26,6 +23,9 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -Import('*') +from m5.objects.PowerCPU import PowerO3CPU -main.Append(ALL_CPU_MODELS=['AtomicSimpleCPU', 'TimingSimpleCPU']) +O3CPU = PowerO3CPU + +# Deprecated +DerivO3CPU = O3CPU diff --git a/src/arch/power/PowerCPU.py b/src/arch/power/PowerCPU.py new file mode 100644 index 0000000000..bf7dc91d2e --- /dev/null +++ b/src/arch/power/PowerCPU.py @@ -0,0 +1,51 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU +from m5.objects.BaseNonCachingSimpleCPU import BaseNonCachingSimpleCPU +from m5.objects.BaseTimingSimpleCPU import BaseTimingSimpleCPU +from m5.objects.BaseO3CPU import BaseO3CPU +from m5.objects.PowerDecoder import PowerDecoder +from m5.objects.PowerMMU import PowerMMU +from m5.objects.PowerInterrupts import PowerInterrupts +from m5.objects.PowerISA import PowerISA + +class PowerCPU: + ArchDecoder = PowerDecoder + ArchMMU = PowerMMU + ArchInterrupts = PowerInterrupts + ArchISA = PowerISA + +class PowerAtomicSimpleCPU(BaseAtomicSimpleCPU, PowerCPU): + mmu = PowerMMU() + +class PowerNonCachingSimpleCPU(BaseNonCachingSimpleCPU, PowerCPU): + mmu = PowerMMU() + +class PowerTimingSimpleCPU(BaseTimingSimpleCPU, PowerCPU): + mmu = PowerMMU() + +class PowerO3CPU(BaseO3CPU, PowerCPU): + mmu = PowerMMU() diff --git a/src/arch/power/SConscript b/src/arch/power/SConscript index 7dd408933a..b20a4c9339 100644 --- a/src/arch/power/SConscript +++ b/src/arch/power/SConscript @@ -55,6 +55,13 @@ SimObject('PowerSeWorkload.py', sim_objects=[ 'PowerSEWorkload', 'PowerEmuLinux'], tags='power isa') SimObject('PowerTLB.py', sim_objects=['PowerTLB'], tags='power isa') +SimObject('PowerCPU.py', sim_objects=[], tags='power isa') +if env['TARGET_ISA'] == 'power': + SimObject('AtomicSimpleCPU.py', sim_objects=[], tags='power isa') + SimObject('TimingSimpleCPU.py', sim_objects=[], tags='power isa') + SimObject('NonCachingSimpleCPU.py', sim_objects=[], tags='power isa') + SimObject('O3CPU.py', sim_objects=[], tags='power isa') + DebugFlag('Power', tags='power isa') ISADesc('isa/main.isa', tags='power isa') diff --git a/src/arch/power/TimingSimpleCPU.py b/src/arch/power/TimingSimpleCPU.py new file mode 100644 index 0000000000..5a9cfa7052 --- /dev/null +++ b/src/arch/power/TimingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.PowerCPU import PowerTimingSimpleCPU + +TimingSimpleCPU = PowerTimingSimpleCPU diff --git a/src/arch/riscv/AtomicSimpleCPU.py b/src/arch/riscv/AtomicSimpleCPU.py new file mode 100644 index 0000000000..f471b64420 --- /dev/null +++ b/src/arch/riscv/AtomicSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.RiscvCPU import RiscvAtomicSimpleCPU + +AtomicSimpleCPU = RiscvAtomicSimpleCPU diff --git a/src/arch/riscv/MinorCPU.py b/src/arch/riscv/MinorCPU.py new file mode 100644 index 0000000000..5254bada24 --- /dev/null +++ b/src/arch/riscv/MinorCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.RiscvCPU import RiscvMinorCPU + +MinorCPU = RiscvMinorCPU diff --git a/src/arch/riscv/NonCachingSimpleCPU.py b/src/arch/riscv/NonCachingSimpleCPU.py new file mode 100644 index 0000000000..f7dcebf3c6 --- /dev/null +++ b/src/arch/riscv/NonCachingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.RiscvCPU import RiscvNonCachingSimpleCPU + +NonCachingSimpleCPU = RiscvNonCachingSimpleCPU diff --git a/src/cpu/SConsopts b/src/arch/riscv/O3CPU.py similarity index 86% rename from src/cpu/SConsopts rename to src/arch/riscv/O3CPU.py index c39d1eb010..74e658b0db 100644 --- a/src/cpu/SConsopts +++ b/src/arch/riscv/O3CPU.py @@ -1,4 +1,4 @@ -# Copyright 2020 Google, Inc. +# Copyright 2021 Google, Inc. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -23,9 +23,9 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -Import('*') +from m5.objects.RiscvCPU import RiscvO3CPU -def add_cpu_models_var(): - sticky_vars.Add(ListVariable('CPU_MODELS', 'CPU models', [], - sorted(set(main.Split('${ALL_CPU_MODELS}'))))) -AfterSConsopts(add_cpu_models_var) +O3CPU = RiscvO3CPU + +# Deprecated +DerivO3CPU = O3CPU diff --git a/src/arch/riscv/RiscvCPU.py b/src/arch/riscv/RiscvCPU.py new file mode 100644 index 0000000000..36c2920713 --- /dev/null +++ b/src/arch/riscv/RiscvCPU.py @@ -0,0 +1,55 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU +from m5.objects.BaseNonCachingSimpleCPU import BaseNonCachingSimpleCPU +from m5.objects.BaseTimingSimpleCPU import BaseTimingSimpleCPU +from m5.objects.BaseO3CPU import BaseO3CPU +from m5.objects.BaseMinorCPU import BaseMinorCPU +from m5.objects.RiscvDecoder import RiscvDecoder +from m5.objects.RiscvMMU import RiscvMMU +from m5.objects.RiscvInterrupts import RiscvInterrupts +from m5.objects.RiscvISA import RiscvISA + +class RiscvCPU: + ArchDecoder = RiscvDecoder + ArchMMU = RiscvMMU + ArchInterrupts = RiscvInterrupts + ArchISA = RiscvISA + +class RiscvAtomicSimpleCPU(BaseAtomicSimpleCPU, RiscvCPU): + mmu = RiscvMMU() + +class RiscvNonCachingSimpleCPU(BaseNonCachingSimpleCPU, RiscvCPU): + mmu = RiscvMMU() + +class RiscvTimingSimpleCPU(BaseTimingSimpleCPU, RiscvCPU): + mmu = RiscvMMU() + +class RiscvO3CPU(BaseO3CPU, RiscvCPU): + mmu = RiscvMMU() + +class RiscvMinorCPU(BaseMinorCPU, RiscvCPU): + mmu = RiscvMMU() diff --git a/src/arch/riscv/SConscript b/src/arch/riscv/SConscript index 8b7942e40d..66a983ade8 100644 --- a/src/arch/riscv/SConscript +++ b/src/arch/riscv/SConscript @@ -74,6 +74,14 @@ SimObject('RiscvSeWorkload.py', sim_objects=[ SimObject('RiscvTLB.py', sim_objects=['RiscvPagetableWalker', 'RiscvTLB'], tags='riscv isa') +SimObject('RiscvCPU.py', sim_objects=[], tags='riscv isa') +if env['TARGET_ISA'] == 'riscv': + SimObject('AtomicSimpleCPU.py', sim_objects=[], tags='riscv isa') + SimObject('TimingSimpleCPU.py', sim_objects=[], tags='riscv isa') + SimObject('NonCachingSimpleCPU.py', sim_objects=[], tags='riscv isa') + SimObject('O3CPU.py', sim_objects=[], tags='riscv isa') + SimObject('MinorCPU.py', sim_objects=[], tags='riscv isa') + DebugFlag('RiscvMisc', tags='riscv isa') DebugFlag('PMP', tags='riscv isa') diff --git a/src/arch/riscv/TimingSimpleCPU.py b/src/arch/riscv/TimingSimpleCPU.py new file mode 100644 index 0000000000..03d530f5ad --- /dev/null +++ b/src/arch/riscv/TimingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.RiscvCPU import RiscvTimingSimpleCPU + +TimingSimpleCPU = RiscvTimingSimpleCPU diff --git a/src/arch/sparc/AtomicSimpleCPU.py b/src/arch/sparc/AtomicSimpleCPU.py new file mode 100644 index 0000000000..6f57f88064 --- /dev/null +++ b/src/arch/sparc/AtomicSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.SparcCPU import SparcAtomicSimpleCPU + +AtomicSimpleCPU = SparcAtomicSimpleCPU diff --git a/src/arch/sparc/NonCachingSimpleCPU.py b/src/arch/sparc/NonCachingSimpleCPU.py new file mode 100644 index 0000000000..5d8b5ffcdb --- /dev/null +++ b/src/arch/sparc/NonCachingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.SparcCPU import SparcNonCachingSimpleCPU + +NonCachingSimpleCPU = SparcNonCachingSimpleCPU diff --git a/src/arch/sparc/O3CPU.py b/src/arch/sparc/O3CPU.py new file mode 100644 index 0000000000..486c6c8bc7 --- /dev/null +++ b/src/arch/sparc/O3CPU.py @@ -0,0 +1,31 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.SparcCPU import SparcO3CPU + +O3CPU = SparcO3CPU + +# Deprecated +DerivO3CPU = O3CPU diff --git a/src/arch/sparc/SConscript b/src/arch/sparc/SConscript index c25d33f681..fe3a037231 100644 --- a/src/arch/sparc/SConscript +++ b/src/arch/sparc/SConscript @@ -56,6 +56,13 @@ SimObject('SparcSeWorkload.py', sim_objects=[ 'SparcSEWorkload', 'SparcEmuLinux'], tags='sparc isa') SimObject('SparcTLB.py', sim_objects=['SparcTLB'], tags='sparc isa') +SimObject('SparcCPU.py', sim_objects=[], tags='sparc isa') +if env['TARGET_ISA'] == 'sparc': + SimObject('AtomicSimpleCPU.py', sim_objects=[], tags='sparc isa') + SimObject('TimingSimpleCPU.py', sim_objects=[], tags='sparc isa') + SimObject('NonCachingSimpleCPU.py', sim_objects=[], tags='sparc isa') + SimObject('O3CPU.py', sim_objects=[], tags='sparc isa') + DebugFlag('Sparc', "Generic SPARC ISA stuff", tags='sparc isa') DebugFlag('RegisterWindows', "Register window manipulation", tags='sparc isa') diff --git a/src/arch/sparc/SparcCPU.py b/src/arch/sparc/SparcCPU.py new file mode 100644 index 0000000000..b6c33059df --- /dev/null +++ b/src/arch/sparc/SparcCPU.py @@ -0,0 +1,51 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU +from m5.objects.BaseNonCachingSimpleCPU import BaseNonCachingSimpleCPU +from m5.objects.BaseTimingSimpleCPU import BaseTimingSimpleCPU +from m5.objects.BaseO3CPU import BaseO3CPU +from m5.objects.SparcDecoder import SparcDecoder +from m5.objects.SparcMMU import SparcMMU +from m5.objects.SparcInterrupts import SparcInterrupts +from m5.objects.SparcISA import SparcISA + +class SparcCPU: + ArchDecoder = SparcDecoder + ArchMMU = SparcMMU + ArchInterrupts = SparcInterrupts + ArchISA = SparcISA + +class SparcAtomicSimpleCPU(BaseAtomicSimpleCPU, SparcCPU): + mmu = SparcMMU() + +class SparcNonCachingSimpleCPU(BaseNonCachingSimpleCPU, SparcCPU): + mmu = SparcMMU() + +class SparcTimingSimpleCPU(BaseTimingSimpleCPU, SparcCPU): + mmu = SparcMMU() + +class SparcO3CPU(BaseO3CPU, SparcCPU): + mmu = SparcMMU() diff --git a/src/arch/sparc/TimingSimpleCPU.py b/src/arch/sparc/TimingSimpleCPU.py new file mode 100644 index 0000000000..0471c1882b --- /dev/null +++ b/src/arch/sparc/TimingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.SparcCPU import SparcTimingSimpleCPU + +TimingSimpleCPU = SparcTimingSimpleCPU diff --git a/src/arch/x86/AtomicSimpleCPU.py b/src/arch/x86/AtomicSimpleCPU.py new file mode 100644 index 0000000000..432346102c --- /dev/null +++ b/src/arch/x86/AtomicSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.X86CPU import X86AtomicSimpleCPU + +AtomicSimpleCPU = X86AtomicSimpleCPU diff --git a/src/arch/x86/NonCachingSimpleCPU.py b/src/arch/x86/NonCachingSimpleCPU.py new file mode 100644 index 0000000000..0559bf6082 --- /dev/null +++ b/src/arch/x86/NonCachingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.X86CPU import X86NonCachingSimpleCPU + +NonCachingSimpleCPU = X86NonCachingSimpleCPU diff --git a/src/arch/x86/O3CPU.py b/src/arch/x86/O3CPU.py new file mode 100644 index 0000000000..a81acf1234 --- /dev/null +++ b/src/arch/x86/O3CPU.py @@ -0,0 +1,31 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.X86CPU import X86O3CPU + +O3CPU = X86O3CPU + +# Deprecated +DerivO3CPU = O3CPU diff --git a/src/arch/x86/SConscript b/src/arch/x86/SConscript index d1ec5499ea..ad3d698bd7 100644 --- a/src/arch/x86/SConscript +++ b/src/arch/x86/SConscript @@ -72,6 +72,13 @@ SimObject('X86NativeTrace.py', sim_objects=['X86NativeTrace'], tags='x86 isa') SimObject('X86TLB.py', sim_objects=['X86PagetableWalker', 'X86TLB'], tags='x86 isa') +SimObject('X86CPU.py', sim_objects=[], tags='x86 isa') +if env['TARGET_ISA'] == 'x86': + SimObject('AtomicSimpleCPU.py', sim_objects=[], tags='x86 isa') + SimObject('TimingSimpleCPU.py', sim_objects=[], tags='x86 isa') + SimObject('NonCachingSimpleCPU.py', sim_objects=[], tags='x86 isa') + SimObject('O3CPU.py', sim_objects=[], tags='x86 isa') + DebugFlag('LocalApic', "Local APIC debugging", tags='x86 isa') DebugFlag('X86', "Generic X86 ISA debugging", tags='x86 isa') DebugFlag('ACPI', "ACPI debugging", tags='x86 isa') diff --git a/src/arch/x86/TimingSimpleCPU.py b/src/arch/x86/TimingSimpleCPU.py new file mode 100644 index 0000000000..cf6c529b13 --- /dev/null +++ b/src/arch/x86/TimingSimpleCPU.py @@ -0,0 +1,28 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.objects.X86CPU import X86TimingSimpleCPU + +TimingSimpleCPU = X86TimingSimpleCPU diff --git a/src/arch/x86/X86CPU.py b/src/arch/x86/X86CPU.py new file mode 100644 index 0000000000..0b46c94c6e --- /dev/null +++ b/src/arch/x86/X86CPU.py @@ -0,0 +1,62 @@ +# Copyright 2021 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.proxy import Self + +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU +from m5.objects.BaseNonCachingSimpleCPU import BaseNonCachingSimpleCPU +from m5.objects.BaseTimingSimpleCPU import BaseTimingSimpleCPU +from m5.objects.BaseO3CPU import BaseO3CPU +from m5.objects.X86Decoder import X86Decoder +from m5.objects.X86MMU import X86MMU +from m5.objects.X86LocalApic import X86LocalApic +from m5.objects.X86ISA import X86ISA + +class X86CPU: + ArchDecoder = X86Decoder + ArchMMU = X86MMU + ArchInterrupts = X86LocalApic + ArchISA = X86ISA + +class X86AtomicSimpleCPU(BaseAtomicSimpleCPU, X86CPU): + mmu = X86MMU() + +class X86NonCachingSimpleCPU(BaseNonCachingSimpleCPU, X86CPU): + mmu = X86MMU() + +class X86TimingSimpleCPU(BaseTimingSimpleCPU, X86CPU): + mmu = X86MMU() + +class X86O3CPU(BaseO3CPU, X86CPU): + mmu = X86MMU() + needsTSO = True + + # For x86, each CC reg is used to hold only a subset of the + # flags, so we need 4-5 times the number of CC regs as + # physical integer regs to be sure we don't run out. In + # typical real machines, CC regs are not explicitly renamed + # (it's a side effect of int reg renaming), so they should + # never be the bottleneck here. + numPhysCCRegs = Self.numPhysIntRegs * 5 diff --git a/src/arch/x86/kvm/X86KvmCPU.py b/src/arch/x86/kvm/X86KvmCPU.py index 54cf0f20eb..59de5eafda 100644 --- a/src/arch/x86/kvm/X86KvmCPU.py +++ b/src/arch/x86/kvm/X86KvmCPU.py @@ -28,12 +28,16 @@ from m5.params import * from m5.SimObject import * from m5.objects.BaseKvmCPU import BaseKvmCPU +from m5.objects.X86CPU import X86CPU +from m5.objects.X86MMU import X86MMU -class X86KvmCPU(BaseKvmCPU): +class X86KvmCPU(BaseKvmCPU, X86CPU): type = 'X86KvmCPU' cxx_header = "arch/x86/kvm/x86_cpu.hh" cxx_class = 'gem5::X86KvmCPU' + mmu = X86MMU() + cxx_exports = [ PyBindMethod("dumpFpuRegs"), PyBindMethod("dumpIntRegs"), diff --git a/src/cpu/BaseCPU.py b/src/cpu/BaseCPU.py index 5eeedd3642..bf4d43c359 100644 --- a/src/cpu/BaseCPU.py +++ b/src/cpu/BaseCPU.py @@ -56,41 +56,6 @@ from m5.objects.Platform import Platform default_tracer = ExeTracer() -if buildEnv['TARGET_ISA'] == 'sparc': - from m5.objects.SparcMMU import SparcMMU as ArchMMU - from m5.objects.SparcInterrupts import SparcInterrupts as ArchInterrupts - from m5.objects.SparcISA import SparcISA as ArchISA - from m5.objects.SparcDecoder import SparcDecoder as ArchDecoder -elif buildEnv['TARGET_ISA'] == 'x86': - from m5.objects.X86MMU import X86MMU as ArchMMU - from m5.objects.X86LocalApic import X86LocalApic as ArchInterrupts - from m5.objects.X86ISA import X86ISA as ArchISA - from m5.objects.X86Decoder import X86Decoder as ArchDecoder -elif buildEnv['TARGET_ISA'] == 'mips': - from m5.objects.MipsMMU import MipsMMU as ArchMMU - from m5.objects.MipsInterrupts import MipsInterrupts as ArchInterrupts - from m5.objects.MipsISA import MipsISA as ArchISA - from m5.objects.MipsDecoder import MipsDecoder as ArchDecoder -elif buildEnv['TARGET_ISA'] == 'arm': - from m5.objects.ArmMMU import ArmMMU as ArchMMU - from m5.objects.ArmInterrupts import ArmInterrupts as ArchInterrupts - from m5.objects.ArmISA import ArmISA as ArchISA - from m5.objects.ArmDecoder import ArmDecoder as ArchDecoder -elif buildEnv['TARGET_ISA'] == 'power': - from m5.objects.PowerMMU import PowerMMU as ArchMMU - from m5.objects.PowerInterrupts import PowerInterrupts as ArchInterrupts - from m5.objects.PowerISA import PowerISA as ArchISA - from m5.objects.PowerDecoder import PowerDecoder as ArchDecoder -elif buildEnv['TARGET_ISA'] == 'riscv': - from m5.objects.RiscvMMU import RiscvMMU as ArchMMU - from m5.objects.RiscvInterrupts import RiscvInterrupts as ArchInterrupts - from m5.objects.RiscvISA import RiscvISA as ArchISA - from m5.objects.RiscvDecoder import RiscvDecoder as ArchDecoder -else: - print("Don't know what object types to use for ISA %s" % - buildEnv['TARGET_ISA']) - sys.exit(1) - class BaseCPU(ClockedObject): type = 'BaseCPU' abstract = True @@ -155,7 +120,7 @@ class BaseCPU(ClockedObject): workload = VectorParam.Process([], "processes to run") - mmu = Param.BaseMMU(ArchMMU(), "CPU memory management unit") + mmu = Param.BaseMMU(NULL, "CPU memory management unit") interrupts = VectorParam.BaseInterrupts([], "Interrupt Controller") isa = VectorParam.BaseISA([], "ISA instance") decoder = VectorParam.InstDecoder([], "Decoder instance") @@ -183,7 +148,8 @@ class BaseCPU(ClockedObject): _uncached_interrupt_request_ports = [] def createInterruptController(self): - self.interrupts = [ArchInterrupts() for i in range(self.numThreads)] + self.interrupts = [ + self.ArchInterrupts() for i in range(self.numThreads)] def connectCachedPorts(self, in_ports): for p in self._cached_ports: @@ -217,13 +183,13 @@ class BaseCPU(ClockedObject): self._cached_ports += ["itb_walker_cache.mem_side", \ "dtb_walker_cache.mem_side"] else: - self._cached_ports += ArchMMU.walkerPorts() + self._cached_ports += self.ArchMMU.walkerPorts() # Checker doesn't need its own tlb caches because it does # functional accesses only if self.checker != NULL: self._cached_ports += [ "checker." + port - for port in ArchMMU.walkerPorts() ] + for port in self.ArchMMU.walkerPorts() ] def addTwoLevelCacheHierarchy(self, ic, dc, l2c, iwc=None, dwc=None, xbar=None): @@ -238,14 +204,14 @@ class BaseCPU(ClockedObject): # If no ISAs have been created, assume that the user wants the # default ISA. if len(self.isa) == 0: - self.isa = list([ ArchISA() for i in range(self.numThreads) ]) + self.isa = [ self.ArchISA() for i in range(self.numThreads) ] else: if len(self.isa) != int(self.numThreads): raise RuntimeError("Number of ISA instances doesn't " "match thread count") if len(self.decoder) != 0: raise RuntimeError("Decoders should not be set up manually") - self.decoder = list([ ArchDecoder(isa=isa) for isa in self.isa ]) + self.decoder = list([ self.ArchDecoder(isa=isa) for isa in self.isa ]) if self.checker != NULL: self.checker.createThreads() @@ -308,18 +274,18 @@ class BaseCPU(ClockedObject): super().__init__(**kwargs) self.power_state.possible_states=['ON', 'CLK_GATED', 'OFF'] - self._cached_ports = self._cached_ports + ArchMMU.walkerPorts() + self._cached_ports = self._cached_ports + self.ArchMMU.walkerPorts() # Practically speaking, these ports will exist on the x86 interrupt # controller class. - if "pio" in ArchInterrupts._ports: + if "pio" in self.ArchInterrupts._ports: self._uncached_interrupt_response_ports = \ self._uncached_interrupt_response_ports + ["interrupts[0].pio"] - if "int_responder" in ArchInterrupts._ports: + if "int_responder" in self.ArchInterrupts._ports: self._uncached_interrupt_response_ports = \ self._uncached_interrupt_response_ports + [ "interrupts[0].int_responder"] - if "int_requestor" in ArchInterrupts._ports: + if "int_requestor" in self.ArchInterrupts._ports: self._uncached_interrupt_request_ports = \ self._uncached_interrupt_request_ports + [ "interrupts[0].int_requestor"] diff --git a/src/cpu/minor/MinorCPU.py b/src/cpu/minor/BaseMinorCPU.py similarity index 99% rename from src/cpu/minor/MinorCPU.py rename to src/cpu/minor/BaseMinorCPU.py index 5b360ca249..ac26743a7d 100644 --- a/src/cpu/minor/MinorCPU.py +++ b/src/cpu/minor/BaseMinorCPU.py @@ -184,8 +184,8 @@ class MinorDefaultFUPool(MinorFUPool): class ThreadPolicy(Enum): vals = ['SingleThreaded', 'RoundRobin', 'Random'] -class MinorCPU(BaseCPU): - type = 'MinorCPU' +class BaseMinorCPU(BaseCPU): + type = 'BaseMinorCPU' cxx_header = "cpu/minor/cpu.hh" cxx_class = 'gem5::MinorCPU' diff --git a/src/cpu/minor/SConscript b/src/cpu/minor/SConscript index 090ac442e4..db4b1bfb59 100644 --- a/src/cpu/minor/SConscript +++ b/src/cpu/minor/SConscript @@ -40,10 +40,10 @@ Import('*') -if 'MinorCPU' in env['CPU_MODELS']: - SimObject('MinorCPU.py', sim_objects=[ +if env['TARGET_ISA'] != 'null': + SimObject('BaseMinorCPU.py', sim_objects=[ 'MinorOpClass', 'MinorOpClassSet', 'MinorFUTiming', 'MinorFU', - 'MinorFUPool', 'MinorCPU'], + 'MinorFUPool', 'BaseMinorCPU'], enums=['ThreadPolicy']) Source('activity.cc') diff --git a/src/cpu/minor/cpu.cc b/src/cpu/minor/cpu.cc index 0bc26e3c4c..2e554aaa0b 100644 --- a/src/cpu/minor/cpu.cc +++ b/src/cpu/minor/cpu.cc @@ -47,7 +47,7 @@ namespace gem5 { -MinorCPU::MinorCPU(const MinorCPUParams ¶ms) : +MinorCPU::MinorCPU(const BaseMinorCPUParams ¶ms) : BaseCPU(params), threadPolicy(params.threadPolicy), stats(this) diff --git a/src/cpu/minor/cpu.hh b/src/cpu/minor/cpu.hh index 9ed93db463..b5b04ae908 100644 --- a/src/cpu/minor/cpu.hh +++ b/src/cpu/minor/cpu.hh @@ -51,7 +51,7 @@ #include "cpu/minor/stats.hh" #include "cpu/simple_thread.hh" #include "enums/ThreadPolicy.hh" -#include "params/MinorCPU.hh" +#include "params/BaseMinorCPU.hh" namespace gem5 { @@ -126,7 +126,7 @@ class MinorCPU : public BaseCPU Port &getInstPort() override; public: - MinorCPU(const MinorCPUParams ¶ms); + MinorCPU(const BaseMinorCPUParams ¶ms); ~MinorCPU(); diff --git a/src/cpu/minor/decode.cc b/src/cpu/minor/decode.cc index 5adf2cacfc..53c02f321d 100644 --- a/src/cpu/minor/decode.cc +++ b/src/cpu/minor/decode.cc @@ -51,7 +51,7 @@ namespace minor Decode::Decode(const std::string &name, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Input out_, std::vector> &next_stage_input_buffer) : diff --git a/src/cpu/minor/decode.hh b/src/cpu/minor/decode.hh index 6e9cb62fbd..156b92038c 100644 --- a/src/cpu/minor/decode.hh +++ b/src/cpu/minor/decode.hh @@ -141,7 +141,7 @@ class Decode : public Named public: Decode(const std::string &name, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Input out_, std::vector> &next_stage_input_buffer); diff --git a/src/cpu/minor/execute.cc b/src/cpu/minor/execute.cc index c09f3be741..f7022d1234 100644 --- a/src/cpu/minor/execute.cc +++ b/src/cpu/minor/execute.cc @@ -63,7 +63,7 @@ namespace minor Execute::Execute(const std::string &name_, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Input out_) : Named(name_), diff --git a/src/cpu/minor/execute.hh b/src/cpu/minor/execute.hh index 9d184f7428..521b3b6cbb 100644 --- a/src/cpu/minor/execute.hh +++ b/src/cpu/minor/execute.hh @@ -326,7 +326,7 @@ class Execute : public Named public: Execute(const std::string &name_, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Input out_); diff --git a/src/cpu/minor/fetch1.cc b/src/cpu/minor/fetch1.cc index 482933995c..daf8d560b3 100644 --- a/src/cpu/minor/fetch1.cc +++ b/src/cpu/minor/fetch1.cc @@ -60,7 +60,7 @@ namespace minor Fetch1::Fetch1(const std::string &name_, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Input out_, Latch::Output prediction_, diff --git a/src/cpu/minor/fetch1.hh b/src/cpu/minor/fetch1.hh index bd8ad7d224..e33eb0493b 100644 --- a/src/cpu/minor/fetch1.hh +++ b/src/cpu/minor/fetch1.hh @@ -386,7 +386,7 @@ class Fetch1 : public Named public: Fetch1(const std::string &name_, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Input out_, Latch::Output prediction_, diff --git a/src/cpu/minor/fetch2.cc b/src/cpu/minor/fetch2.cc index c5a7045268..b506bc0428 100644 --- a/src/cpu/minor/fetch2.cc +++ b/src/cpu/minor/fetch2.cc @@ -58,7 +58,7 @@ namespace minor Fetch2::Fetch2(const std::string &name, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Output branchInp_, Latch::Input predictionOut_, diff --git a/src/cpu/minor/fetch2.hh b/src/cpu/minor/fetch2.hh index 2eb8a772f1..85012bf927 100644 --- a/src/cpu/minor/fetch2.hh +++ b/src/cpu/minor/fetch2.hh @@ -52,7 +52,7 @@ #include "cpu/minor/cpu.hh" #include "cpu/minor/pipe_data.hh" #include "cpu/pred/bpred_unit.hh" -#include "params/MinorCPU.hh" +#include "params/BaseMinorCPU.hh" namespace gem5 { @@ -201,7 +201,7 @@ class Fetch2 : public Named public: Fetch2(const std::string &name, MinorCPU &cpu_, - const MinorCPUParams ¶ms, + const BaseMinorCPUParams ¶ms, Latch::Output inp_, Latch::Output branchInp_, Latch::Input predictionOut_, diff --git a/src/cpu/minor/pipeline.cc b/src/cpu/minor/pipeline.cc index 358f4dfae9..e94181fcd8 100644 --- a/src/cpu/minor/pipeline.cc +++ b/src/cpu/minor/pipeline.cc @@ -55,7 +55,7 @@ GEM5_DEPRECATED_NAMESPACE(Minor, minor); namespace minor { -Pipeline::Pipeline(MinorCPU &cpu_, const MinorCPUParams ¶ms) : +Pipeline::Pipeline(MinorCPU &cpu_, const BaseMinorCPUParams ¶ms) : Ticked(cpu_, &(cpu_.BaseCPU::baseStats.numCycles)), cpu(cpu_), allow_idling(params.enableIdling), diff --git a/src/cpu/minor/pipeline.hh b/src/cpu/minor/pipeline.hh index f2eab5de18..ce0ae07d3e 100644 --- a/src/cpu/minor/pipeline.hh +++ b/src/cpu/minor/pipeline.hh @@ -51,7 +51,7 @@ #include "cpu/minor/execute.hh" #include "cpu/minor/fetch1.hh" #include "cpu/minor/fetch2.hh" -#include "params/MinorCPU.hh" +#include "params/BaseMinorCPU.hh" #include "sim/ticked_object.hh" namespace gem5 @@ -109,7 +109,7 @@ class Pipeline : public Ticked bool needToSignalDrained; public: - Pipeline(MinorCPU &cpu_, const MinorCPUParams ¶ms); + Pipeline(MinorCPU &cpu_, const BaseMinorCPUParams ¶ms); public: /** Wake up the Fetch unit. This is needed on thread activation esp. diff --git a/src/cpu/o3/O3CPU.py b/src/cpu/o3/BaseO3CPU.py similarity index 78% rename from src/cpu/o3/O3CPU.py rename to src/cpu/o3/BaseO3CPU.py index fb1a9dc9db..c58f9fee38 100644 --- a/src/cpu/o3/O3CPU.py +++ b/src/cpu/o3/BaseO3CPU.py @@ -42,7 +42,7 @@ from m5.proxy import * from m5.objects.BaseCPU import BaseCPU from m5.objects.FUPool import * -from m5.objects.O3Checker import O3Checker +#from m5.objects.O3Checker import O3Checker from m5.objects.BranchPredictor import * class SMTFetchPolicy(ScopedEnum): @@ -54,8 +54,8 @@ class SMTQueuePolicy(ScopedEnum): class CommitPolicy(ScopedEnum): vals = [ 'RoundRobin', 'OldestReady' ] -class O3CPU(BaseCPU): - type = 'O3CPU' +class BaseO3CPU(BaseCPU): + type = 'BaseO3CPU' cxx_class = 'gem5::o3::CPU' cxx_header = 'cpu/o3/dyn_inst.hh' @@ -120,40 +120,36 @@ class O3CPU(BaseCPU): trapLatency = Param.Cycles(13, "Trap latency") fetchTrapLatency = Param.Cycles(1, "Fetch trap latency") - backComSize = Param.Unsigned(5, "Time buffer size for backwards communication") - forwardComSize = Param.Unsigned(5, "Time buffer size for forward communication") + backComSize = Param.Unsigned(5, + "Time buffer size for backwards communication") + forwardComSize = Param.Unsigned(5, + "Time buffer size for forward communication") LQEntries = Param.Unsigned(32, "Number of load queue entries") SQEntries = Param.Unsigned(32, "Number of store queue entries") - LSQDepCheckShift = Param.Unsigned(4, "Number of places to shift addr before check") + LSQDepCheckShift = Param.Unsigned(4, + "Number of places to shift addr before check") LSQCheckLoads = Param.Bool(True, - "Should dependency violations be checked for loads & stores or just stores") + "Should dependency violations be checked for " + "loads & stores or just stores") store_set_clear_period = Param.Unsigned(250000, - "Number of load/store insts before the dep predictor should be invalidated") + "Number of load/store insts before the dep predictor " + "should be invalidated") LFSTSize = Param.Unsigned(1024, "Last fetched store table size") SSITSize = Param.Unsigned(1024, "Store set ID table size") numRobs = Param.Unsigned(1, "Number of Reorder Buffers"); - numPhysIntRegs = Param.Unsigned(256, "Number of physical integer registers") + numPhysIntRegs = Param.Unsigned(256, + "Number of physical integer registers") numPhysFloatRegs = Param.Unsigned(256, "Number of physical floating point " "registers") - # most ISAs don't use condition-code regs, so default is 0 - _defaultNumPhysCCRegs = 0 - if buildEnv['TARGET_ISA'] in ('arm','x86'): - # For x86, each CC reg is used to hold only a subset of the - # flags, so we need 4-5 times the number of CC regs as - # physical integer regs to be sure we don't run out. In - # typical real machines, CC regs are not explicitly renamed - # (it's a side effect of int reg renaming), so they should - # never be the bottleneck here. - _defaultNumPhysCCRegs = Self.numPhysIntRegs * 5 numPhysVecRegs = Param.Unsigned(256, "Number of physical vector " "registers") numPhysVecPredRegs = Param.Unsigned(32, "Number of physical predicate " "registers") - numPhysCCRegs = Param.Unsigned(_defaultNumPhysCCRegs, - "Number of physical cc registers") + # most ISAs don't use condition-code regs, so default is 0 + numPhysCCRegs = Param.Unsigned(0, "Number of physical cc registers") numIQEntries = Param.Unsigned(64, "Number of instruction queue entries") numROBEntries = Param.Unsigned(192, "Number of reorder buffer entries") @@ -173,25 +169,4 @@ class O3CPU(BaseCPU): branchPred = Param.BranchPredictor(TournamentBP(numThreads = Parent.numThreads), "Branch Predictor") - needsTSO = Param.Bool(buildEnv['TARGET_ISA'] == 'x86', - "Enable TSO Memory model") - - def addCheckerCpu(self): - if buildEnv['TARGET_ISA'] in ['arm']: - from m5.objects.ArmMMU import ArmMMU - - self.checker = O3Checker(workload=self.workload, - exitOnError=False, - updateOnError=True, - warnOnlyOnLoadError=True) - self.checker.mmu = ArmMMU() - self.checker.mmu.itb.size = self.mmu.itb.size - self.checker.mmu.dtb.size = self.mmu.dtb.size - self.checker.cpu_id = self.cpu_id - - else: - print("ERROR: Checker only supported under ARM ISA!") - exit(1) - -# Deprecated -DerivO3CPU = O3CPU + needsTSO = Param.Bool(False, "Enable TSO Memory model") diff --git a/src/cpu/o3/BaseO3Checker.py b/src/cpu/o3/BaseO3Checker.py new file mode 100644 index 0000000000..6365491950 --- /dev/null +++ b/src/cpu/o3/BaseO3Checker.py @@ -0,0 +1,33 @@ +# Copyright (c) 2007 The Regents of The University of Michigan +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from m5.params import * +from m5.objects.CheckerCPU import CheckerCPU + +class BaseO3Checker(CheckerCPU): + type = 'BaseO3Checker' + cxx_class = 'gem5::o3::Checker' + cxx_header = 'cpu/o3/checker.hh' diff --git a/src/cpu/o3/SConscript b/src/cpu/o3/SConscript index ba021a892a..a0bebb295c 100755 --- a/src/cpu/o3/SConscript +++ b/src/cpu/o3/SConscript @@ -30,10 +30,10 @@ import sys Import('*') -if 'O3CPU' in env['CPU_MODELS']: +if env['TARGET_ISA'] != 'null': SimObject('FUPool.py', sim_objects=['FUPool']) SimObject('FuncUnitConfig.py', sim_objects=[]) - SimObject('O3CPU.py', sim_objects=['O3CPU'], enums=[ + SimObject('BaseO3CPU.py', sim_objects=['BaseO3CPU'], enums=[ 'SMTFetchPolicy', 'SMTQueuePolicy', 'CommitPolicy']) Source('commit.cc') @@ -74,5 +74,5 @@ if 'O3CPU' in env['CPU_MODELS']: 'IQ', 'ROB', 'FreeList', 'LSQ', 'LSQUnit', 'StoreSet', 'MemDepUnit', 'DynInst', 'O3CPU', 'Activity', 'Scoreboard', 'Writeback' ]) - SimObject('O3Checker.py', sim_objects=['O3Checker']) + SimObject('BaseO3Checker.py', sim_objects=['BaseO3Checker']) Source('checker.cc') diff --git a/src/cpu/o3/commit.cc b/src/cpu/o3/commit.cc index d2011c56d3..97def7e59a 100644 --- a/src/cpu/o3/commit.cc +++ b/src/cpu/o3/commit.cc @@ -64,7 +64,7 @@ #include "debug/ExecFaulting.hh" #include "debug/HtmCpu.hh" #include "debug/O3PipeView.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" #include "sim/faults.hh" #include "sim/full_system.hh" @@ -82,7 +82,7 @@ Commit::processTrapEvent(ThreadID tid) trapSquash[tid] = true; } -Commit::Commit(CPU *_cpu, const O3CPUParams ¶ms) +Commit::Commit(CPU *_cpu, const BaseO3CPUParams ¶ms) : commitPolicy(params.smtCommitPolicy), cpu(_cpu), iewToCommitDelay(params.iewToCommitDelay), diff --git a/src/cpu/o3/commit.hh b/src/cpu/o3/commit.hh index da271ededd..cf4eaf5d92 100644 --- a/src/cpu/o3/commit.hh +++ b/src/cpu/o3/commit.hh @@ -59,7 +59,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -132,7 +132,7 @@ class Commit public: /** Construct a Commit with the given parameters. */ - Commit(CPU *_cpu, const O3CPUParams ¶ms); + Commit(CPU *_cpu, const BaseO3CPUParams ¶ms); /** Returns the name of the Commit. */ std::string name() const; diff --git a/src/cpu/o3/cpu.cc b/src/cpu/o3/cpu.cc index 19660b2c51..c9ed6c7229 100644 --- a/src/cpu/o3/cpu.cc +++ b/src/cpu/o3/cpu.cc @@ -70,7 +70,7 @@ struct BaseCPUParams; namespace o3 { -CPU::CPU(const O3CPUParams ¶ms) +CPU::CPU(const BaseO3CPUParams ¶ms) : BaseCPU(params), mmu(params.mmu), tickEvent([this]{ tick(); }, "O3CPU tick", diff --git a/src/cpu/o3/cpu.hh b/src/cpu/o3/cpu.hh index 670b92fa0d..4de99af9b2 100644 --- a/src/cpu/o3/cpu.hh +++ b/src/cpu/o3/cpu.hh @@ -68,7 +68,7 @@ #include "cpu/base.hh" #include "cpu/simple_thread.hh" #include "cpu/timebuf.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" #include "sim/process.hh" namespace gem5 @@ -169,7 +169,7 @@ class CPU : public BaseCPU public: /** Constructs a CPU with the given parameters. */ - CPU(const O3CPUParams ¶ms); + CPU(const BaseO3CPUParams ¶ms); ProbePointArg *ppInstAccessComplete; ProbePointArg > *ppDataAccessComplete; diff --git a/src/cpu/o3/decode.cc b/src/cpu/o3/decode.cc index 362daee171..40c929949a 100644 --- a/src/cpu/o3/decode.cc +++ b/src/cpu/o3/decode.cc @@ -49,7 +49,7 @@ #include "debug/Activity.hh" #include "debug/Decode.hh" #include "debug/O3PipeView.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" #include "sim/full_system.hh" // clang complains about std::set being overloaded with Packet::set if @@ -62,7 +62,7 @@ namespace gem5 namespace o3 { -Decode::Decode(CPU *_cpu, const O3CPUParams ¶ms) +Decode::Decode(CPU *_cpu, const BaseO3CPUParams ¶ms) : cpu(_cpu), renameToDecodeDelay(params.renameToDecodeDelay), iewToDecodeDelay(params.iewToDecodeDelay), diff --git a/src/cpu/o3/decode.hh b/src/cpu/o3/decode.hh index e8c2db2174..79bacdc6c6 100644 --- a/src/cpu/o3/decode.hh +++ b/src/cpu/o3/decode.hh @@ -52,7 +52,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -98,7 +98,7 @@ class Decode public: /** Decode constructor. */ - Decode(CPU *_cpu, const O3CPUParams ¶ms); + Decode(CPU *_cpu, const BaseO3CPUParams ¶ms); void startupStage(); diff --git a/src/cpu/o3/fetch.cc b/src/cpu/o3/fetch.cc index 2105900d51..5358b3313e 100644 --- a/src/cpu/o3/fetch.cc +++ b/src/cpu/o3/fetch.cc @@ -63,7 +63,7 @@ #include "debug/O3CPU.hh" #include "debug/O3PipeView.hh" #include "mem/packet.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" #include "sim/byteswap.hh" #include "sim/core.hh" #include "sim/eventq.hh" @@ -81,7 +81,7 @@ Fetch::IcachePort::IcachePort(Fetch *_fetch, CPU *_cpu) : {} -Fetch::Fetch(CPU *_cpu, const O3CPUParams ¶ms) +Fetch::Fetch(CPU *_cpu, const BaseO3CPUParams ¶ms) : fetchPolicy(params.smtFetchPolicy), cpu(_cpu), branchPred(nullptr), diff --git a/src/cpu/o3/fetch.hh b/src/cpu/o3/fetch.hh index 392e7cbe4b..1ca812b8d5 100644 --- a/src/cpu/o3/fetch.hh +++ b/src/cpu/o3/fetch.hh @@ -61,7 +61,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -203,7 +203,7 @@ class Fetch public: /** Fetch constructor. */ - Fetch(CPU *_cpu, const O3CPUParams ¶ms); + Fetch(CPU *_cpu, const BaseO3CPUParams ¶ms); /** Returns the name of fetch. */ std::string name() const; diff --git a/src/cpu/o3/iew.cc b/src/cpu/o3/iew.cc index 8dbd5b3376..5c507f01a4 100644 --- a/src/cpu/o3/iew.cc +++ b/src/cpu/o3/iew.cc @@ -57,7 +57,7 @@ #include "debug/Drain.hh" #include "debug/IEW.hh" #include "debug/O3PipeView.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" namespace gem5 { @@ -65,7 +65,7 @@ namespace gem5 namespace o3 { -IEW::IEW(CPU *_cpu, const O3CPUParams ¶ms) +IEW::IEW(CPU *_cpu, const BaseO3CPUParams ¶ms) : issueToExecQueue(params.backComSize, params.forwardComSize), cpu(_cpu), instQueue(_cpu, this, params), diff --git a/src/cpu/o3/iew.hh b/src/cpu/o3/iew.hh index ea5350d79c..80fed295df 100644 --- a/src/cpu/o3/iew.hh +++ b/src/cpu/o3/iew.hh @@ -58,7 +58,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -127,7 +127,7 @@ class IEW public: /** Constructs a IEW with the given parameters. */ - IEW(CPU *_cpu, const O3CPUParams ¶ms); + IEW(CPU *_cpu, const BaseO3CPUParams ¶ms); /** Returns the name of the IEW stage. */ std::string name() const; diff --git a/src/cpu/o3/inst_queue.cc b/src/cpu/o3/inst_queue.cc index 0fac84f03b..3f900649ed 100644 --- a/src/cpu/o3/inst_queue.cc +++ b/src/cpu/o3/inst_queue.cc @@ -50,7 +50,7 @@ #include "cpu/o3/limits.hh" #include "debug/IQ.hh" #include "enums/OpClass.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" #include "sim/core.hh" // clang complains about std::set being overloaded with Packet::set if @@ -85,7 +85,7 @@ InstructionQueue::FUCompletion::description() const } InstructionQueue::InstructionQueue(CPU *cpu_ptr, IEW *iew_ptr, - const O3CPUParams ¶ms) + const BaseO3CPUParams ¶ms) : cpu(cpu_ptr), iewStage(iew_ptr), fuPool(params.fuPool), diff --git a/src/cpu/o3/inst_queue.hh b/src/cpu/o3/inst_queue.hh index b2d930339e..57928e7478 100644 --- a/src/cpu/o3/inst_queue.hh +++ b/src/cpu/o3/inst_queue.hh @@ -64,7 +64,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace memory { @@ -130,7 +130,8 @@ class InstructionQueue }; /** Constructs an IQ. */ - InstructionQueue(CPU *cpu_ptr, IEW *iew_ptr, const O3CPUParams ¶ms); + InstructionQueue(CPU *cpu_ptr, IEW *iew_ptr, + const BaseO3CPUParams ¶ms); /** Destructs the IQ. */ ~InstructionQueue(); diff --git a/src/cpu/o3/lsq.cc b/src/cpu/o3/lsq.cc index 78999ee46b..72ecc52926 100644 --- a/src/cpu/o3/lsq.cc +++ b/src/cpu/o3/lsq.cc @@ -56,7 +56,7 @@ #include "debug/HtmCpu.hh" #include "debug/LSQ.hh" #include "debug/Writeback.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" namespace gem5 { @@ -68,7 +68,7 @@ LSQ::DcachePort::DcachePort(LSQ *_lsq, CPU *_cpu) : RequestPort(_cpu->name() + ".dcache_port", _cpu), lsq(_lsq), cpu(_cpu) {} -LSQ::LSQ(CPU *cpu_ptr, IEW *iew_ptr, const O3CPUParams ¶ms) +LSQ::LSQ(CPU *cpu_ptr, IEW *iew_ptr, const BaseO3CPUParams ¶ms) : cpu(cpu_ptr), iewStage(iew_ptr), _cacheBlocked(false), cacheStorePorts(params.cacheStorePorts), usedStorePorts(0), diff --git a/src/cpu/o3/lsq.hh b/src/cpu/o3/lsq.hh index 798ceb90b3..2e9945559a 100644 --- a/src/cpu/o3/lsq.hh +++ b/src/cpu/o3/lsq.hh @@ -63,7 +63,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -647,7 +647,7 @@ class LSQ }; /** Constructs an LSQ with the given parameters. */ - LSQ(CPU *cpu_ptr, IEW *iew_ptr, const O3CPUParams ¶ms); + LSQ(CPU *cpu_ptr, IEW *iew_ptr, const BaseO3CPUParams ¶ms); /** Returns the name of the LSQ. */ std::string name() const; diff --git a/src/cpu/o3/lsq_unit.cc b/src/cpu/o3/lsq_unit.cc index baf09710c5..1541d2c893 100644 --- a/src/cpu/o3/lsq_unit.cc +++ b/src/cpu/o3/lsq_unit.cc @@ -201,7 +201,7 @@ LSQUnit::LSQUnit(uint32_t lqEntries, uint32_t sqEntries) } void -LSQUnit::init(CPU *cpu_ptr, IEW *iew_ptr, const O3CPUParams ¶ms, +LSQUnit::init(CPU *cpu_ptr, IEW *iew_ptr, const BaseO3CPUParams ¶ms, LSQ *lsq_ptr, unsigned id) { lsqID = id; diff --git a/src/cpu/o3/lsq_unit.hh b/src/cpu/o3/lsq_unit.hh index 0d2f80f186..e68cb53404 100644 --- a/src/cpu/o3/lsq_unit.hh +++ b/src/cpu/o3/lsq_unit.hh @@ -67,7 +67,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -223,7 +223,7 @@ class LSQUnit } /** Initializes the LSQ unit with the specified number of entries. */ - void init(CPU *cpu_ptr, IEW *iew_ptr, const O3CPUParams ¶ms, + void init(CPU *cpu_ptr, IEW *iew_ptr, const BaseO3CPUParams ¶ms, LSQ *lsq_ptr, unsigned id); /** Returns the name of the LSQ unit. */ diff --git a/src/cpu/o3/mem_dep_unit.cc b/src/cpu/o3/mem_dep_unit.cc index 11a6135b8e..bffbf2380d 100644 --- a/src/cpu/o3/mem_dep_unit.cc +++ b/src/cpu/o3/mem_dep_unit.cc @@ -38,7 +38,7 @@ #include "cpu/o3/inst_queue.hh" #include "cpu/o3/limits.hh" #include "debug/MemDepUnit.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" namespace gem5 { @@ -54,7 +54,7 @@ int MemDepUnit::MemDepEntry::memdep_erase = 0; MemDepUnit::MemDepUnit() : iqPtr(NULL), stats(nullptr) {} -MemDepUnit::MemDepUnit(const O3CPUParams ¶ms) +MemDepUnit::MemDepUnit(const BaseO3CPUParams ¶ms) : _name(params.name + ".memdepunit"), depPred(params.store_set_clear_period, params.SSITSize, params.LFSTSize), @@ -89,7 +89,7 @@ MemDepUnit::~MemDepUnit() } void -MemDepUnit::init(const O3CPUParams ¶ms, ThreadID tid, CPU *cpu) +MemDepUnit::init(const BaseO3CPUParams ¶ms, ThreadID tid, CPU *cpu) { DPRINTF(MemDepUnit, "Creating MemDepUnit %i object.\n",tid); diff --git a/src/cpu/o3/mem_dep_unit.hh b/src/cpu/o3/mem_dep_unit.hh index c6b270cfe1..6609f8dcad 100644 --- a/src/cpu/o3/mem_dep_unit.hh +++ b/src/cpu/o3/mem_dep_unit.hh @@ -68,7 +68,7 @@ struct SNHash } }; -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -97,7 +97,7 @@ class MemDepUnit MemDepUnit(); /** Constructs a MemDepUnit with given parameters. */ - MemDepUnit(const O3CPUParams ¶ms); + MemDepUnit(const BaseO3CPUParams ¶ms); /** Frees up any memory allocated. */ ~MemDepUnit(); @@ -106,7 +106,7 @@ class MemDepUnit std::string name() const { return _name; } /** Initializes the unit with parameters and a thread id. */ - void init(const O3CPUParams ¶ms, ThreadID tid, CPU *cpu); + void init(const BaseO3CPUParams ¶ms, ThreadID tid, CPU *cpu); /** Determine if we are drained. */ bool isDrained() const; diff --git a/src/cpu/o3/probe/SConscript b/src/cpu/o3/probe/SConscript index bd06b62c1c..d7098ad925 100644 --- a/src/cpu/o3/probe/SConscript +++ b/src/cpu/o3/probe/SConscript @@ -37,7 +37,7 @@ Import('*') -if 'O3CPU' in env['CPU_MODELS']: +if env['TARGET_ISA'] != 'null': SimObject('SimpleTrace.py', sim_objects=['SimpleTrace']) Source('simple_trace.cc') DebugFlag('SimpleTrace') diff --git a/src/cpu/o3/rename.cc b/src/cpu/o3/rename.cc index a3f8700f46..f198870cf2 100644 --- a/src/cpu/o3/rename.cc +++ b/src/cpu/o3/rename.cc @@ -50,7 +50,7 @@ #include "debug/Activity.hh" #include "debug/O3PipeView.hh" #include "debug/Rename.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" namespace gem5 { @@ -58,7 +58,7 @@ namespace gem5 namespace o3 { -Rename::Rename(CPU *_cpu, const O3CPUParams ¶ms) +Rename::Rename(CPU *_cpu, const BaseO3CPUParams ¶ms) : cpu(_cpu), iewToRenameDelay(params.iewToRenameDelay), decodeToRenameDelay(params.decodeToRenameDelay), diff --git a/src/cpu/o3/rename.hh b/src/cpu/o3/rename.hh index 0204109480..0b42b6eaa0 100644 --- a/src/cpu/o3/rename.hh +++ b/src/cpu/o3/rename.hh @@ -58,7 +58,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -125,7 +125,7 @@ class Rename public: /** Rename constructor. */ - Rename(CPU *_cpu, const O3CPUParams ¶ms); + Rename(CPU *_cpu, const BaseO3CPUParams ¶ms); /** Returns the name of rename. */ std::string name() const; diff --git a/src/cpu/o3/rob.cc b/src/cpu/o3/rob.cc index 9e42651f42..5d0fac9a60 100644 --- a/src/cpu/o3/rob.cc +++ b/src/cpu/o3/rob.cc @@ -47,7 +47,7 @@ #include "cpu/o3/limits.hh" #include "debug/Fetch.hh" #include "debug/ROB.hh" -#include "params/O3CPU.hh" +#include "params/BaseO3CPU.hh" namespace gem5 { @@ -55,7 +55,7 @@ namespace gem5 namespace o3 { -ROB::ROB(CPU *_cpu, const O3CPUParams ¶ms) +ROB::ROB(CPU *_cpu, const BaseO3CPUParams ¶ms) : robPolicy(params.smtROBPolicy), cpu(_cpu), numEntries(params.numROBEntries), diff --git a/src/cpu/o3/rob.hh b/src/cpu/o3/rob.hh index 3889ef59db..d36db733e1 100644 --- a/src/cpu/o3/rob.hh +++ b/src/cpu/o3/rob.hh @@ -57,7 +57,7 @@ namespace gem5 { -struct O3CPUParams; +struct BaseO3CPUParams; namespace o3 { @@ -95,7 +95,7 @@ class ROB * @param _cpu The cpu object pointer. * @param params The cpu params including several ROB-specific parameters. */ - ROB(CPU *_cpu, const O3CPUParams ¶ms); + ROB(CPU *_cpu, const BaseO3CPUParams ¶ms); std::string name() const; diff --git a/src/cpu/simple/AtomicSimpleCPU.py b/src/cpu/simple/BaseAtomicSimpleCPU.py similarity index 97% rename from src/cpu/simple/AtomicSimpleCPU.py rename to src/cpu/simple/BaseAtomicSimpleCPU.py index 8dc0a5b1a0..ba3b8121f1 100644 --- a/src/cpu/simple/AtomicSimpleCPU.py +++ b/src/cpu/simple/BaseAtomicSimpleCPU.py @@ -40,12 +40,12 @@ from m5.params import * from m5.objects.BaseSimpleCPU import BaseSimpleCPU from m5.objects.SimPoint import SimPoint -class AtomicSimpleCPU(BaseSimpleCPU): +class BaseAtomicSimpleCPU(BaseSimpleCPU): """Simple CPU model executing a configurable number of instructions per cycle. This model uses the simplified 'atomic' memory mode.""" - type = 'AtomicSimpleCPU' + type = 'BaseAtomicSimpleCPU' cxx_header = "cpu/simple/atomic.hh" cxx_class = 'gem5::AtomicSimpleCPU' diff --git a/src/cpu/simple/NonCachingSimpleCPU.py b/src/cpu/simple/BaseNonCachingSimpleCPU.py similarity index 94% rename from src/cpu/simple/NonCachingSimpleCPU.py rename to src/cpu/simple/BaseNonCachingSimpleCPU.py index e01905a9ae..f5cf1c7a75 100644 --- a/src/cpu/simple/NonCachingSimpleCPU.py +++ b/src/cpu/simple/BaseNonCachingSimpleCPU.py @@ -34,9 +34,9 @@ # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. from m5.params import * -from m5.objects.AtomicSimpleCPU import AtomicSimpleCPU +from m5.objects.BaseAtomicSimpleCPU import BaseAtomicSimpleCPU -class NonCachingSimpleCPU(AtomicSimpleCPU): +class BaseNonCachingSimpleCPU(BaseAtomicSimpleCPU): """Simple CPU model based on the atomic CPU. Unlike the atomic CPU, this model causes the memory system to bypass caches and is therefore slightly faster in some cases. However, its main purpose @@ -45,7 +45,7 @@ class NonCachingSimpleCPU(AtomicSimpleCPU): """ - type = 'NonCachingSimpleCPU' + type = 'BaseNonCachingSimpleCPU' cxx_header = "cpu/simple/noncaching.hh" cxx_class = 'gem5::NonCachingSimpleCPU' diff --git a/src/cpu/simple/BaseSimpleCPU.py b/src/cpu/simple/BaseSimpleCPU.py index 64444e4137..67ba739767 100644 --- a/src/cpu/simple/BaseSimpleCPU.py +++ b/src/cpu/simple/BaseSimpleCPU.py @@ -37,16 +37,4 @@ class BaseSimpleCPU(BaseCPU): cxx_header = "cpu/simple/base.hh" cxx_class = 'gem5::BaseSimpleCPU' - def addCheckerCpu(self): - if buildEnv['TARGET_ISA'] in ['arm']: - from m5.objects.ArmTLB import ArmMMU - - self.checker = DummyChecker(workload = self.workload) - self.checker.mmu = ArmMMU() - self.checker.mmu.itb.size = self.mmu.itb.size - self.checker.mmu.dtb.size = self.mmu.dtb.size - else: - print("ERROR: Checker only supported under ARM ISA!") - exit(1) - branchPred = Param.BranchPredictor(NULL, "Branch Predictor") diff --git a/src/cpu/simple/TimingSimpleCPU.py b/src/cpu/simple/BaseTimingSimpleCPU.py similarity index 96% rename from src/cpu/simple/TimingSimpleCPU.py rename to src/cpu/simple/BaseTimingSimpleCPU.py index f670cc4c8e..1f317a87be 100644 --- a/src/cpu/simple/TimingSimpleCPU.py +++ b/src/cpu/simple/BaseTimingSimpleCPU.py @@ -28,8 +28,8 @@ from m5.params import * from m5.objects.BaseSimpleCPU import BaseSimpleCPU -class TimingSimpleCPU(BaseSimpleCPU): - type = 'TimingSimpleCPU' +class BaseTimingSimpleCPU(BaseSimpleCPU): + type = 'BaseTimingSimpleCPU' cxx_header = "cpu/simple/timing.hh" cxx_class = 'gem5::TimingSimpleCPU' diff --git a/src/cpu/simple/SConscript b/src/cpu/simple/SConscript index b953d1f852..5a66e8da6c 100644 --- a/src/cpu/simple/SConscript +++ b/src/cpu/simple/SConscript @@ -28,27 +28,21 @@ Import('*') -need_simple_base = False -if 'AtomicSimpleCPU' in env['CPU_MODELS']: - need_simple_base = True - SimObject('AtomicSimpleCPU.py', sim_objects=['AtomicSimpleCPU']) +if env['TARGET_ISA'] != 'null': + SimObject('BaseAtomicSimpleCPU.py', sim_objects=['BaseAtomicSimpleCPU']) Source('atomic.cc') # The NonCachingSimpleCPU is really an atomic CPU in # disguise. It's therefore always enabled when the atomic CPU is # enabled. - SimObject('NonCachingSimpleCPU.py', sim_objects=['NonCachingSimpleCPU']) + SimObject('BaseNonCachingSimpleCPU.py', + sim_objects=['BaseNonCachingSimpleCPU']) Source('noncaching.cc') -if 'TimingSimpleCPU' in env['CPU_MODELS']: - need_simple_base = True - SimObject('TimingSimpleCPU.py', sim_objects=['TimingSimpleCPU']) + SimObject('BaseTimingSimpleCPU.py', sim_objects=['BaseTimingSimpleCPU']) Source('timing.cc') -if 'AtomicSimpleCPU' in env['CPU_MODELS'] or \ - 'TimingSimpleCPU' in env['CPU_MODELS']: DebugFlag('SimpleCPU') -if need_simple_base: Source('base.cc') SimObject('BaseSimpleCPU.py', sim_objects=['BaseSimpleCPU']) diff --git a/src/cpu/simple/atomic.cc b/src/cpu/simple/atomic.cc index d9e36758f1..9cf7a294b9 100644 --- a/src/cpu/simple/atomic.cc +++ b/src/cpu/simple/atomic.cc @@ -52,7 +52,7 @@ #include "mem/packet.hh" #include "mem/packet_access.hh" #include "mem/physical.hh" -#include "params/AtomicSimpleCPU.hh" +#include "params/BaseAtomicSimpleCPU.hh" #include "sim/faults.hh" #include "sim/full_system.hh" #include "sim/system.hh" @@ -72,7 +72,7 @@ AtomicSimpleCPU::init() data_amo_req->setContext(cid); } -AtomicSimpleCPU::AtomicSimpleCPU(const AtomicSimpleCPUParams &p) +AtomicSimpleCPU::AtomicSimpleCPU(const BaseAtomicSimpleCPUParams &p) : BaseSimpleCPU(p), tickEvent([this]{ tick(); }, "AtomicSimpleCPU tick", false, Event::CPU_Tick_Pri), diff --git a/src/cpu/simple/atomic.hh b/src/cpu/simple/atomic.hh index aacd0dc033..c0d0f1d0bc 100644 --- a/src/cpu/simple/atomic.hh +++ b/src/cpu/simple/atomic.hh @@ -44,7 +44,7 @@ #include "cpu/simple/base.hh" #include "cpu/simple/exec_context.hh" #include "mem/request.hh" -#include "params/AtomicSimpleCPU.hh" +#include "params/BaseAtomicSimpleCPU.hh" #include "sim/probe/probe.hh" namespace gem5 @@ -54,7 +54,7 @@ class AtomicSimpleCPU : public BaseSimpleCPU { public: - AtomicSimpleCPU(const AtomicSimpleCPUParams ¶ms); + AtomicSimpleCPU(const BaseAtomicSimpleCPUParams ¶ms); virtual ~AtomicSimpleCPU(); void init() override; diff --git a/src/cpu/simple/noncaching.cc b/src/cpu/simple/noncaching.cc index 6458beeb28..424a496fe9 100644 --- a/src/cpu/simple/noncaching.cc +++ b/src/cpu/simple/noncaching.cc @@ -44,7 +44,8 @@ namespace gem5 { -NonCachingSimpleCPU::NonCachingSimpleCPU(const NonCachingSimpleCPUParams &p) +NonCachingSimpleCPU::NonCachingSimpleCPU( + const BaseNonCachingSimpleCPUParams &p) : AtomicSimpleCPU(p) { assert(p.numThreads == 1); diff --git a/src/cpu/simple/noncaching.hh b/src/cpu/simple/noncaching.hh index 289f482d43..5dea9c6498 100644 --- a/src/cpu/simple/noncaching.hh +++ b/src/cpu/simple/noncaching.hh @@ -41,7 +41,7 @@ #include "base/addr_range_map.hh" #include "cpu/simple/atomic.hh" #include "mem/backdoor.hh" -#include "params/NonCachingSimpleCPU.hh" +#include "params/BaseNonCachingSimpleCPU.hh" namespace gem5 { @@ -53,7 +53,7 @@ namespace gem5 class NonCachingSimpleCPU : public AtomicSimpleCPU { public: - NonCachingSimpleCPU(const NonCachingSimpleCPUParams &p); + NonCachingSimpleCPU(const BaseNonCachingSimpleCPUParams &p); void verifyMemoryMode() const override; diff --git a/src/cpu/simple/probes/SConscript b/src/cpu/simple/probes/SConscript index eae6a4581e..1c8abdb58e 100644 --- a/src/cpu/simple/probes/SConscript +++ b/src/cpu/simple/probes/SConscript @@ -28,6 +28,6 @@ Import('*') -if 'AtomicSimpleCPU' in env['CPU_MODELS']: +if env['TARGET_ISA'] != 'null': SimObject('SimPoint.py', sim_objects=['SimPoint']) Source('simpoint.cc') diff --git a/src/cpu/simple/timing.cc b/src/cpu/simple/timing.cc index c7e63efa84..d562c1710f 100644 --- a/src/cpu/simple/timing.cc +++ b/src/cpu/simple/timing.cc @@ -53,7 +53,7 @@ #include "debug/SimpleCPU.hh" #include "mem/packet.hh" #include "mem/packet_access.hh" -#include "params/TimingSimpleCPU.hh" +#include "params/BaseTimingSimpleCPU.hh" #include "sim/faults.hh" #include "sim/full_system.hh" #include "sim/system.hh" @@ -74,7 +74,7 @@ TimingSimpleCPU::TimingCPUPort::TickEvent::schedule(PacketPtr _pkt, Tick t) cpu->schedule(this, t); } -TimingSimpleCPU::TimingSimpleCPU(const TimingSimpleCPUParams &p) +TimingSimpleCPU::TimingSimpleCPU(const BaseTimingSimpleCPUParams &p) : BaseSimpleCPU(p), fetchTranslation(this), icachePort(this), dcachePort(this), ifetch_pkt(NULL), dcache_pkt(NULL), previousCycle(0), fetchEvent([this]{ fetch(); }, name()) diff --git a/src/cpu/simple/timing.hh b/src/cpu/simple/timing.hh index b2cc4e7ffd..b211ab14b4 100644 --- a/src/cpu/simple/timing.hh +++ b/src/cpu/simple/timing.hh @@ -45,7 +45,7 @@ #include "cpu/simple/base.hh" #include "cpu/simple/exec_context.hh" #include "cpu/translation.hh" -#include "params/TimingSimpleCPU.hh" +#include "params/BaseTimingSimpleCPU.hh" namespace gem5 { @@ -54,7 +54,7 @@ class TimingSimpleCPU : public BaseSimpleCPU { public: - TimingSimpleCPU(const TimingSimpleCPUParams ¶ms); + TimingSimpleCPU(const BaseTimingSimpleCPUParams ¶ms); virtual ~TimingSimpleCPU(); void init() override; diff --git a/src/cpu/testers/memtest/SConscript b/src/cpu/testers/memtest/SConscript index 51e443bd07..766739d609 100644 --- a/src/cpu/testers/memtest/SConscript +++ b/src/cpu/testers/memtest/SConscript @@ -28,7 +28,6 @@ Import('*') -#if 'O3CPU' in env['CPU_MODELS']: SimObject('MemTest.py', sim_objects=['MemTest']) Source('memtest.cc') From 4003ad7510df9114ab1ac17821b5e47bae4c1bb8 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Thu, 19 Aug 2021 22:45:44 -0700 Subject: [PATCH 051/658] python,util: Pull CXX config generation code out of SimObject. Change-Id: I94d6f5b172ab71ee8bedea854e1db9711748f313 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49451 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- build_tools/cxx_config_cc.py | 251 +++++++++++++++++++++++++- build_tools/cxx_config_hh.py | 71 +++++++- build_tools/cxx_config_init_cc.py | 39 +++-- src/python/m5/SimObject.py | 281 ------------------------------ 4 files changed, 349 insertions(+), 293 deletions(-) diff --git a/build_tools/cxx_config_cc.py b/build_tools/cxx_config_cc.py index 7047857760..c4a2d8957f 100644 --- a/build_tools/cxx_config_cc.py +++ b/build_tools/cxx_config_cc.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -45,6 +58,242 @@ importer.install() module = importlib.import_module(args.modpath) sim_object = getattr(module, sim_object_name) +from m5.params import isSimObjectClass +import m5.params + code = code_formatter() -sim_object.cxx_config_param_file(code, False) + +entry_class = 'CxxConfigDirectoryEntry_%s' % sim_object_name +param_class = '%sCxxConfigParams' % sim_object_name + +def cxx_bool(b): + return 'true' if b else 'false' + +code('#include "params/%s.hh"' % sim_object_name) + +for param in sim_object._params.values(): + if isSimObjectClass(param.ptype): + code('#include "%s"' % param.ptype._value_dict['cxx_header']) + code('#include "params/%s.hh"' % param.ptype.__name__) + else: + param.ptype.cxx_ini_predecls(code) + +code('''#include "${{sim_object._value_dict['cxx_header']}}" +#include "base/str.hh" +#include "cxx_config/${sim_object_name}.hh" + +namespace gem5 +{ + +${param_class}::DirectoryEntry::DirectoryEntry() +{ +''') +code.indent() +for param in sim_object._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + code('parameters["%s"] = new ParamDesc("%s", %s, %s);' % + (param.name, param.name, cxx_bool(is_vector), + cxx_bool(is_simobj))); + +for port in sim_object._ports.values(): + is_vector = isinstance(port, m5.params.VectorPort) + is_requestor = port.role == 'GEM5 REQUESTOR' + + code('ports["%s"] = new PortDesc("%s", %s, %s);' % + (port.name, port.name, cxx_bool(is_vector), + cxx_bool(is_requestor))) + +code.dedent() + +code('''} + +bool +${param_class}::setSimObject(const std::string &name, SimObject *simObject) +{ + bool ret = true; + if (false) { +''') + +code.indent() +for param in sim_object._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if is_simobj and not is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + code('this->${{param.name}} = ' + 'dynamic_cast<${{param.ptype.cxx_type}}>(simObject);') + code('if (simObject && !this->${{param.name}})') + code(' ret = false;') + code.dedent() +code.dedent() + +code(''' + } else { + ret = false; + } + + return ret; +} + +bool +${param_class}::setSimObjectVector(const std::string &name, + const std::vector &simObjects) +{ + bool ret = true; + + if (false) { +''') + +code.indent() +for param in sim_object._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if is_simobj and is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + code('this->${{param.name}}.clear();') + code('for (auto i = simObjects.begin(); ' + 'ret && i != simObjects.end(); i ++)') + code('{') + code.indent() + code('${{param.ptype.cxx_type}} object = ' + 'dynamic_cast<${{param.ptype.cxx_type}}>(*i);') + code('if (*i && !object)') + code(' ret = false;') + code('else') + code(' this->${{param.name}}.push_back(object);') + code.dedent() + code('}') + code.dedent() +code.dedent() + +code(''' + } else { + ret = false; + } + + return ret; +} + +void +${param_class}::setName(const std::string &name_) +{ + this->name = name_; +} + +bool +${param_class}::setParam(const std::string &name, + const std::string &value, const Flags flags) +{ + bool ret = true; + + if (false) { +''') + +code.indent() +for param in sim_object._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if not is_simobj and not is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + param.ptype.cxx_ini_parse(code, + 'value', 'this->%s' % param.name, 'ret =') + code.dedent() +code.dedent() + +code(''' + } else { + ret = false; + } + + return ret; +} + +bool +${param_class}::setParamVector(const std::string &name, + const std::vector &values, const Flags flags) +{ + bool ret = true; + + if (false) { +''') + +code.indent() +for param in sim_object._params.values(): + is_vector = isinstance(param, m5.params.VectorParamDesc) + is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) + + if not is_simobj and is_vector: + code('} else if (name == "${{param.name}}") {') + code.indent() + code('${{param.name}}.clear();') + code('for (auto i = values.begin(); ' + 'ret && i != values.end(); i ++)') + code('{') + code.indent() + code('${{param.ptype.cxx_type}} elem;') + param.ptype.cxx_ini_parse(code, + '*i', 'elem', 'ret =') + code('if (ret)') + code(' this->${{param.name}}.push_back(elem);') + code.dedent() + code('}') + code.dedent() +code.dedent() + +code(''' + } else { + ret = false; + } + + return ret; +} + +bool +${param_class}::setPortConnectionCount(const std::string &name, + unsigned int count) +{ + bool ret = true; + + if (false) { +''') + +code.indent() +for port in sim_object._ports.values(): + code('} else if (name == "${{port.name}}") {') + code(' this->port_${{port.name}}_connection_count = count;') +code.dedent() + +code(''' + } else { + ret = false; + } + + return ret; +} + +SimObject * +${param_class}::simObjectCreate() +{ +''') + +code.indent() +if hasattr(sim_object, 'abstract') and sim_object.abstract: + code('return nullptr;') +else: + code('return this->create();') +code.dedent() + +code('''} + +} // namespace gem5 +''') + code.write(args.cxx_config_cc) diff --git a/build_tools/cxx_config_hh.py b/build_tools/cxx_config_hh.py index 3cae84b69e..4e47f87d21 100644 --- a/build_tools/cxx_config_hh.py +++ b/build_tools/cxx_config_hh.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -46,5 +59,61 @@ module = importlib.import_module(args.modpath) sim_object = getattr(module, sim_object_name) code = code_formatter() -sim_object.cxx_config_param_file(code, True) + +entry_class = 'CxxConfigDirectoryEntry_%s' % sim_object_name +param_class = '%sCxxConfigParams' % sim_object_name + +code('''#include "params/${sim_object_name}.hh" + +#include "sim/cxx_config.hh" + +namespace gem5 +{ + +class ${param_class} : public CxxConfigParams, public ${sim_object_name}Params +{ + private: + class DirectoryEntry : public CxxConfigDirectoryEntry + { + public: + DirectoryEntry(); + + CxxConfigParams * + makeParamsObject() const + { + return new ${param_class}; + } + }; + + public: + bool setSimObject(const std::string &name, SimObject *simObject); + + bool setSimObjectVector(const std::string &name, + const std::vector &simObjects); + + void setName(const std::string &name_); + + const std::string &getName() { return this->name; } + + bool setParam(const std::string &name, const std::string &value, + const Flags flags); + + bool setParamVector(const std::string &name, + const std::vector &values, const Flags flags); + + bool setPortConnectionCount(const std::string &name, unsigned int count); + + SimObject *simObjectCreate(); + + static CxxConfigDirectoryEntry * + makeDirectoryEntry() + { + return new DirectoryEntry; + } + +}; + +} // namespace gem5 +''') + code.write(args.cxx_config_hh) diff --git a/build_tools/cxx_config_init_cc.py b/build_tools/cxx_config_init_cc.py index d3af795f3e..aab8d29c3b 100644 --- a/build_tools/cxx_config_init_cc.py +++ b/build_tools/cxx_config_init_cc.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -39,20 +52,26 @@ code = code_formatter() for sim_object in args.sim_objects: code('#include "cxx_config/${sim_object}.hh"') -code('') -code('namespace gem5') -code('{') -code('') -code('void') -code('cxxConfigInit()') -code('{') + +code(''' +namespace gem5 +{ + +void +cxxConfigInit() +{ +''') + code.indent() for sim_object in args.sim_objects: code('cxx_config_directory["${sim_object}"] = ' '${sim_object}CxxConfigParams::makeDirectoryEntry();') code.dedent() -code('}') -code('') -code('} // namespace gem5') + +code(''' +} + +} // namespace gem5 +''') code.write(args.cxx_config_init_cc) diff --git a/src/python/m5/SimObject.py b/src/python/m5/SimObject.py index b2ed967d12..26a1227712 100644 --- a/src/python/m5/SimObject.py +++ b/src/python/m5/SimObject.py @@ -116,281 +116,6 @@ def public_value(key, value): isinstance(value, (FunctionType, MethodType, ModuleType, classmethod, type)) -def createCxxConfigDirectoryEntryFile(code, name, simobj, is_header): - entry_class = 'CxxConfigDirectoryEntry_%s' % name - param_class = '%sCxxConfigParams' % name - - code('#include "params/%s.hh"' % name) - - if not is_header: - for param in simobj._params.values(): - if isSimObjectClass(param.ptype): - code('#include "%s"' % param.ptype._value_dict['cxx_header']) - code('#include "params/%s.hh"' % param.ptype.__name__) - else: - param.ptype.cxx_ini_predecls(code) - - if is_header: - member_prefix = '' - end_of_decl = ';' - code('#include "sim/cxx_config.hh"') - code() - code('namespace gem5') - code('{') - code() - code('class ${param_class} : public CxxConfigParams,' - ' public ${name}Params') - code('{') - code(' private:') - code.indent() - code('class DirectoryEntry : public CxxConfigDirectoryEntry') - code('{') - code(' public:') - code.indent() - code('DirectoryEntry();'); - code() - code('CxxConfigParams *makeParamsObject() const') - code('{ return new ${param_class}; }') - code.dedent() - code('};') - code() - code.dedent() - code(' public:') - code.indent() - else: - member_prefix = '%s::' % param_class - end_of_decl = '' - code('#include "%s"' % simobj._value_dict['cxx_header']) - code('#include "base/str.hh"') - code('#include "cxx_config/${name}.hh"') - - code('namespace gem5') - code('{') - code() - code('${member_prefix}DirectoryEntry::DirectoryEntry()'); - code('{') - - def cxx_bool(b): - return 'true' if b else 'false' - - code.indent() - for param in simobj._params.values(): - is_vector = isinstance(param, m5.params.VectorParamDesc) - is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) - - code('parameters["%s"] = new ParamDesc("%s", %s, %s);' % - (param.name, param.name, cxx_bool(is_vector), - cxx_bool(is_simobj))); - - for port in simobj._ports.values(): - is_vector = isinstance(port, m5.params.VectorPort) - is_requestor = port.role == 'GEM5 REQUESTOR' - - code('ports["%s"] = new PortDesc("%s", %s, %s);' % - (port.name, port.name, cxx_bool(is_vector), - cxx_bool(is_requestor))) - - code.dedent() - code('}') - code() - - code('bool ${member_prefix}setSimObject(const std::string &name,') - code(' SimObject *simObject)${end_of_decl}') - - if not is_header: - code('{') - code.indent() - code('bool ret = true;') - code() - code('if (false) {') - for param in simobj._params.values(): - is_vector = isinstance(param, m5.params.VectorParamDesc) - is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) - - if is_simobj and not is_vector: - code('} else if (name == "${{param.name}}") {') - code.indent() - code('this->${{param.name}} = ' - 'dynamic_cast<${{param.ptype.cxx_type}}>(simObject);') - code('if (simObject && !this->${{param.name}})') - code(' ret = false;') - code.dedent() - code('} else {') - code(' ret = false;') - code('}') - code() - code('return ret;') - code.dedent() - code('}') - - code() - code('bool ${member_prefix}setSimObjectVector(' - 'const std::string &name,') - code(' const std::vector &simObjects)${end_of_decl}') - - if not is_header: - code('{') - code.indent() - code('bool ret = true;') - code() - code('if (false) {') - for param in simobj._params.values(): - is_vector = isinstance(param, m5.params.VectorParamDesc) - is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) - - if is_simobj and is_vector: - code('} else if (name == "${{param.name}}") {') - code.indent() - code('this->${{param.name}}.clear();') - code('for (auto i = simObjects.begin(); ' - 'ret && i != simObjects.end(); i ++)') - code('{') - code.indent() - code('${{param.ptype.cxx_type}} object = ' - 'dynamic_cast<${{param.ptype.cxx_type}}>(*i);') - code('if (*i && !object)') - code(' ret = false;') - code('else') - code(' this->${{param.name}}.push_back(object);') - code.dedent() - code('}') - code.dedent() - code('} else {') - code(' ret = false;') - code('}') - code() - code('return ret;') - code.dedent() - code('}') - - code() - code('void ${member_prefix}setName(const std::string &name_)' - '${end_of_decl}') - - if not is_header: - code('{') - code.indent() - code('this->name = name_;') - code.dedent() - code('}') - - if is_header: - code('const std::string &${member_prefix}getName()') - code('{ return this->name; }') - - code() - code('bool ${member_prefix}setParam(const std::string &name,') - code(' const std::string &value, const Flags flags)${end_of_decl}') - - if not is_header: - code('{') - code.indent() - code('bool ret = true;') - code() - code('if (false) {') - for param in simobj._params.values(): - is_vector = isinstance(param, m5.params.VectorParamDesc) - is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) - - if not is_simobj and not is_vector: - code('} else if (name == "${{param.name}}") {') - code.indent() - param.ptype.cxx_ini_parse(code, - 'value', 'this->%s' % param.name, 'ret =') - code.dedent() - code('} else {') - code(' ret = false;') - code('}') - code() - code('return ret;') - code.dedent() - code('}') - - code() - code('bool ${member_prefix}setParamVector(' - 'const std::string &name,') - code(' const std::vector &values,') - code(' const Flags flags)${end_of_decl}') - - if not is_header: - code('{') - code.indent() - code('bool ret = true;') - code() - code('if (false) {') - for param in simobj._params.values(): - is_vector = isinstance(param, m5.params.VectorParamDesc) - is_simobj = issubclass(param.ptype, m5.SimObject.SimObject) - - if not is_simobj and is_vector: - code('} else if (name == "${{param.name}}") {') - code.indent() - code('${{param.name}}.clear();') - code('for (auto i = values.begin(); ' - 'ret && i != values.end(); i ++)') - code('{') - code.indent() - code('${{param.ptype.cxx_type}} elem;') - param.ptype.cxx_ini_parse(code, - '*i', 'elem', 'ret =') - code('if (ret)') - code(' this->${{param.name}}.push_back(elem);') - code.dedent() - code('}') - code.dedent() - code('} else {') - code(' ret = false;') - code('}') - code() - code('return ret;') - code.dedent() - code('}') - - code() - code('bool ${member_prefix}setPortConnectionCount(' - 'const std::string &name,') - code(' unsigned int count)${end_of_decl}') - - if not is_header: - code('{') - code.indent() - code('bool ret = true;') - code() - code('if (false)') - code(' ;') - for port in simobj._ports.values(): - code('else if (name == "${{port.name}}")') - code(' this->port_${{port.name}}_connection_count = count;') - code('else') - code(' ret = false;') - code() - code('return ret;') - code.dedent() - code('}') - - code() - code('SimObject *${member_prefix}simObjectCreate()${end_of_decl}') - - if not is_header: - code('{') - if hasattr(simobj, 'abstract') and simobj.abstract: - code(' return NULL;') - else: - code(' return this->create();') - code('}') - - if is_header: - code() - code('static CxxConfigDirectoryEntry' - ' *${member_prefix}makeDirectoryEntry()') - code('{ return new DirectoryEntry; }') - - if is_header: - code.dedent() - code('};') - - code('} // namespace gem5') - # The metaclass for SimObject. This class controls how new classes # that derive from SimObject are instantiated, and provides inherited # class behavior (just like a class controls how instances of that @@ -708,12 +433,6 @@ class MetaSimObject(type): def pybind_predecls(cls, code): code('#include "${{cls.cxx_header}}"') - # Generate the C++ declaration/definition files for this SimObject's - # param struct to allow C++ initialisation - def cxx_config_param_file(cls, code, is_header): - createCxxConfigDirectoryEntryFile(code, cls.__name__, cls, is_header) - return code - # This *temporary* definition is required to support calls from the # SimObject class definition to the MetaSimObject methods (in # particular _set_param, which gets called for parameters with default From b0f9375377529d3cd61108b074a710d8d5a40e07 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Thu, 19 Aug 2021 23:11:40 -0700 Subject: [PATCH 052/658] python,util: Pull enum hh|cc generation out of the MetaEnum class. Change-Id: Ibfcc2d6916318ffef806f74e57e3f8360489efb6 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49452 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- build_tools/enum_cc.py | 106 +++++++++++++++++++++++++++++- build_tools/enum_hh.py | 68 ++++++++++++++++++- src/python/m5/params.py | 140 ---------------------------------------- 3 files changed, 170 insertions(+), 144 deletions(-) diff --git a/build_tools/enum_cc.py b/build_tools/enum_cc.py index 4a6cda0c14..e05f19fe06 100644 --- a/build_tools/enum_cc.py +++ b/build_tools/enum_cc.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -48,7 +61,94 @@ module = importlib.import_module(args.modpath) enum = getattr(module, enum_name) code = code_formatter() -enum.cxx_def(code) -if args.use_python: - enum.pybind_def(code) + +wrapper_name = enum.wrapper_name +file_name = enum.__name__ +name = enum.__name__ if enum.enum_name is None else enum.enum_name + +code('''#include "base/compiler.hh" +#include "enums/$file_name.hh" + +namespace gem5 +{ + +''') + +if enum.wrapper_is_struct: + code('const char *${wrapper_name}::${name}Strings' + '[Num_${name}] =') +else: + if enum.is_class: + code('''\ +const char *${name}Strings[static_cast(${name}::Num_${name})] = +''') + else: + code('''GEM5_DEPRECATED_NAMESPACE(Enums, enums); +namespace enums +{''') + code.indent(1) + code('const char *${name}Strings[Num_${name}] =') + +code('{') +code.indent(1) +for val in enum.vals: + code('"$val",') +code.dedent(1) +code('};') + +if not enum.wrapper_is_struct and not enum.is_class: + code.dedent(1) + code('} // namespace enums') + +code('} // namespace gem5') + + +if not args.use_python: + code.write(args.enum_cc) + exit(0) + + +name = enum.__name__ +enum_name = enum.__name__ if enum.enum_name is None else enum.enum_name +wrapper_name = enum_name if enum.is_class else enum.wrapper_name + +code('''#include "pybind11/pybind11.h" +#include "pybind11/stl.h" + +#include + +namespace py = pybind11; + +namespace gem5 +{ + +static void +module_init(py::module_ &m_internal) +{ + py::module_ m = m_internal.def_submodule("enum_${name}"); + +''') +if enum.is_class: + code('py::enum_<${enum_name}>(m, "enum_${name}")') +else: + code('py::enum_<${wrapper_name}::${enum_name}>(m, "enum_${name}")') + +code.indent() +code.indent() +for val in enum.vals: + code('.value("${val}", ${wrapper_name}::${val})') +code('.value("Num_${name}", ${wrapper_name}::Num_${enum_name})') +if not enum.is_class: + code('.export_values()') +code(';') +code.dedent() + +code('}') +code.dedent() +code(''' +static EmbeddedPyBind embed_enum("enum_${name}", module_init); + +} // namespace gem5 +''') + code.write(args.enum_cc) diff --git a/build_tools/enum_hh.py b/build_tools/enum_hh.py index 53eaf85357..2c4a7bb2ce 100644 --- a/build_tools/enum_hh.py +++ b/build_tools/enum_hh.py @@ -1,5 +1,18 @@ +# Copyright 2004-2006 The Regents of The University of Michigan +# Copyright 2010-20013 Advanced Micro Devices, Inc. +# Copyright 2013 Mark D. Hill and David A. Wood +# Copyright 2017-2020 ARM Limited # Copyright 2021 Google, Inc. # +# The license below extends only to copyright in the software and shall +# not be construed as granting a license to any other intellectual +# property including but not limited to intellectual property relating +# to a hardware implementation of the functionality of the software +# licensed hereunder. You may use the software subject to the license +# terms below provided that you ensure that this notice is replicated +# unmodified and in its entirety in all distributions of the software, +# modified or unmodified, in source code or in binary form. +# # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are # met: redistributions of source code must retain the above copyright @@ -46,5 +59,58 @@ module = importlib.import_module(args.modpath) enum = getattr(module, enum_name) code = code_formatter() -enum.cxx_decl(code) + +# Generate C++ class declaration for this enum type. +# Note that we wrap the enum in a class/struct to act as a namespace, +# so that the enum strings can be brief w/o worrying about collisions. +wrapper_name = enum.wrapper_name +wrapper = 'struct' if enum.wrapper_is_struct else 'namespace' +name = enum.__name__ if enum.enum_name is None else enum.enum_name +idem_macro = '__ENUM__%s__%s__' % (wrapper_name, name) + +code('''\ +#ifndef $idem_macro +#define $idem_macro + +namespace gem5 +{ +''') +if enum.is_class: + code('''\ +enum class $name +{ +''') +else: + code('''\ +$wrapper $wrapper_name { +enum $name +{ +''') + code.indent(1) +code.indent(1) +for val in enum.vals: + code('$val = ${{enum.map[val]}},') +code('Num_$name = ${{len(enum.vals)}}') +code.dedent(1) +code('};') + +if enum.is_class: + code('''\ +extern const char *${name}Strings[static_cast(${name}::Num_${name})]; +''') +elif enum.wrapper_is_struct: + code('static const char *${name}Strings[Num_${name}];') +else: + code('extern const char *${name}Strings[Num_${name}];') + +if not enum.is_class: + code.dedent(1) + code('}; // $wrapper_name') + +code() +code('} // namespace gem5') + +code() +code('#endif // $idem_macro') + code.write(args.enum_hh) diff --git a/src/python/m5/params.py b/src/python/m5/params.py index 39137c5496..57a3d3e186 100644 --- a/src/python/m5/params.py +++ b/src/python/m5/params.py @@ -1318,146 +1318,6 @@ class MetaEnum(MetaParamValue): super().__init__(name, bases, init_dict) - # Generate C++ class declaration for this enum type. - # Note that we wrap the enum in a class/struct to act as a namespace, - # so that the enum strings can be brief w/o worrying about collisions. - def cxx_decl(cls, code): - wrapper_name = cls.wrapper_name - wrapper = 'struct' if cls.wrapper_is_struct else 'namespace' - name = cls.__name__ if cls.enum_name is None else cls.enum_name - idem_macro = '__ENUM__%s__%s__' % (wrapper_name, name) - - code('''\ -#ifndef $idem_macro -#define $idem_macro - -namespace gem5 -{ -''') - if cls.is_class: - code('''\ -enum class $name -{ -''') - else: - code('''\ -$wrapper $wrapper_name { - enum $name - { -''') - code.indent(1) - code.indent(1) - for val in cls.vals: - code('$val = ${{cls.map[val]}},') - code('Num_$name = ${{len(cls.vals)}}') - code.dedent(1) - code('};') - - if cls.is_class: - code('''\ -extern const char *${name}Strings[static_cast(${name}::Num_${name})]; -''') - elif cls.wrapper_is_struct: - code('static const char *${name}Strings[Num_${name}];') - else: - code('extern const char *${name}Strings[Num_${name}];') - - if not cls.is_class: - code.dedent(1) - code('}; // $wrapper_name') - - code() - code('} // namespace gem5') - - code() - code('#endif // $idem_macro') - - def cxx_def(cls, code): - wrapper_name = cls.wrapper_name - file_name = cls.__name__ - name = cls.__name__ if cls.enum_name is None else cls.enum_name - - code('#include "base/compiler.hh"') - code('#include "enums/$file_name.hh"') - - code() - code('namespace gem5') - code('{') - code() - - if cls.wrapper_is_struct: - code('const char *${wrapper_name}::${name}Strings' - '[Num_${name}] =') - else: - if cls.is_class: - code('''\ -const char *${name}Strings[static_cast(${name}::Num_${name})] = -''') - else: - code('''GEM5_DEPRECATED_NAMESPACE(Enums, enums); -namespace enums -{''') - code.indent(1) - code('const char *${name}Strings[Num_${name}] =') - - code('{') - code.indent(1) - for val in cls.vals: - code('"$val",') - code.dedent(1) - code('};') - - if not cls.wrapper_is_struct and not cls.is_class: - code.dedent(1) - code('} // namespace enums') - - code('} // namespace gem5') - - - def pybind_def(cls, code): - name = cls.__name__ - enum_name = cls.__name__ if cls.enum_name is None else cls.enum_name - wrapper_name = enum_name if cls.is_class else cls.wrapper_name - - code('''#include "pybind11/pybind11.h" -#include "pybind11/stl.h" - -#include - -namespace py = pybind11; - -namespace gem5 -{ - -static void -module_init(py::module_ &m_internal) -{ - py::module_ m = m_internal.def_submodule("enum_${name}"); - -''') - if cls.is_class: - code('py::enum_<${enum_name}>(m, "enum_${name}")') - else: - code('py::enum_<${wrapper_name}::${enum_name}>(m, "enum_${name}")') - - code.indent() - code.indent() - for val in cls.vals: - code('.value("${val}", ${wrapper_name}::${val})') - code('.value("Num_${name}", ${wrapper_name}::Num_${enum_name})') - if not cls.is_class: - code('.export_values()') - code(';') - code.dedent() - - code('}') - code.dedent() - code() - code('static EmbeddedPyBind embed_enum("enum_${name}", module_init);') - code() - code('} // namespace gem5') - - # Base class for enum types. class Enum(ParamValue, metaclass=MetaEnum): vals = [] From 9f5806d44b52a403f6d3fb608765b41af7ff9d7f Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Fri, 20 Aug 2021 03:45:20 -0700 Subject: [PATCH 053/658] scons: Handle most SimObject work right within SimObject(). This (mostly) avoids having to keep around a list of SimObjects to process later. Unfortunately cxx_config/init.cc still depends on a complete list of SimObjects, and so has to be set up after all SimObject types have been accumulated. Change-Id: I440fe7c0d3e9713f2e78332d9255769f3934a0c3 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49454 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- src/SConscript | 166 ++++++++++++++++++++++++------------------------- 1 file changed, 81 insertions(+), 85 deletions(-) diff --git a/src/SConscript b/src/SConscript index 87176d9c72..ff8e5a5974 100644 --- a/src/SConscript +++ b/src/SConscript @@ -135,9 +135,7 @@ class SimObject(PySource): fixed = False - sim_objects = dict() - enums = dict() - tags = dict() + sim_objects = [] def __init__(self, source, *, sim_objects=None, enums=None, tags=None, add_tags=None): @@ -155,9 +153,84 @@ class SimObject(PySource): if self.fixed: error("Too late to call SimObject now.") - SimObject.sim_objects[self.modpath] = sim_objects - SimObject.enums[self.modpath] = enums - SimObject.tags[self.modpath] = self.tags + SimObject.sim_objects.extend(sim_objects) + + build_dir = Dir(env['BUILDDIR']) + module = self.modpath + + # Generate all of the SimObject param C++ files. + for simobj in sim_objects: + # Some helper functions + srcs = [ Value(module), Value(simobj), + "${GEM5PY_M5}", "${PYSCRIPT}" ] + def cmdline(*args): + all_args = [ 'GEM5PY_M5', 'PYSCRIPT', 'MODULE' ] + list(args) + return ' '.join(list('"${%s}"' % arg for arg in all_args)) + + # Params header. + gem5py_env.Command([ "${PARAMS_HH}" ], srcs, + MakeAction(cmdline('PARAMS_HH'), Transform("SO Param", 2)), + MODULE=module, + SIMOBJ=simobj, + PYSCRIPT=build_tools.File('sim_object_param_struct_hh.py'), + PARAMS_HH=build_dir.File(f'params/{simobj}.hh')) + + # Params cc. + cc_file = build_dir.File(f'python/_m5/param_{simobj}.cc') + gem5py_env.Command([ "${PARAMS_CC}" ], srcs, + MakeAction(cmdline('PARAMS_CC', 'USE_PYTHON'), + Transform("SO Param", 2)), + PYSCRIPT=build_tools.File('sim_object_param_struct_cc.py'), + MODULE=module, + SIMOBJ=simobj, + PARAMS_CC=cc_file, + USE_PYTHON=env['USE_PYTHON']) + Source(cc_file, tags=self.tags, add_tags='python') + + # CXX config header. + gem5py_env.Command([ "${CXXCONFIG_HH}" ], srcs, + MakeAction(cmdline('CXXCONFIG_HH'), + Transform("CXXCPRHH", 2)), + PYSCRIPT=build_tools.File('cxx_config_hh.py'), + MODULE=module, + CXXCONFIG_HH=build_dir.File(f'cxx_config/{simobj}.hh')) + + # CXX config cc. + cc_file=build_dir.File(f'cxx_config/{simobj}.cc') + gem5py_env.Command([ "${CXXCONFIG_CC}" ], srcs, + MakeAction(cmdline('CXXCONFIG_CC'), + Transform("CXXCPRCC", 2)), + PYSCRIPT=build_tools.File('cxx_config_cc.py'), + MODULE=module, + CXXCONFIG_CC=cc_file) + if GetOption('with_cxx_config'): + Source(cc_file, tags=self.tags) + + # C++ versions of enum params. + for enum in enums: + gem5py_env.Command([ "${ENUM_HH}" ], + [ Value(module), Value(enum), + "${GEM5PY_M5}", "${ENUMHH_PY}" ], + MakeAction('"${GEM5PY_M5}" "${ENUMHH_PY}" "${MODULE}" ' \ + '"${ENUM_HH}"', + Transform("ENUMDECL", 2)), + MODULE=module, + ENUM=enum, + ENUM_HH=build_dir.File(f'enums/{enum}.hh'), + ENUMHH_PY=build_tools.File('enum_hh.py')) + cc_file = build_dir.File(f'enums/{enum}.cc') + gem5py_env.Command([ "${ENUM_CC}" ], + [ Value(module), Value(enum), + "${GEM5PY_M5}", "${ENUMCC_PY}" ], + MakeAction('"${GEM5PY_M5}" "${ENUMCC_PY}" "${MODULE}" ' \ + '"${ENUM_CC}" "${USE_PYTHON}"', + Transform("ENUM STR", 2)), + MODULE=module, + ENUM=enum, + ENUM_CC=cc_file, + ENUMCC_PY=build_tools.File('enum_cc.py'), + USE_PYTHON='--use-python' if env['USE_PYTHON'] else '') + Source(cc_file, tags=self.tags, add_tags='python') # This regular expression is simplistic and assumes that the import takes up # the entire line, doesn't have the keyword "public", uses double quotes, has @@ -560,61 +633,10 @@ gem5py_env.Program(gem5py_m5, [ 'python/gem5py.cc' ] + m5_module_static) ######################################################################## # -# Create all of the SimObject param headers and enum headers +# Create the CXX config init.cc. # -# Generate all of the SimObject param C++ files. - -for module, simobjs in sorted(SimObject.sim_objects.items()): - tags = SimObject.tags[module] - for simobj in simobjs: - - # Some helper functions - srcs = [ Value(module), Value(simobj), "${GEM5PY_M5}", "${PYSCRIPT}" ] - def cmdline(*args): - all_args = [ 'GEM5PY_M5', 'PYSCRIPT', 'MODULE' ] + list(args) - return ' '.join(list('"${%s}"' % arg for arg in all_args)) - - # Params header. - gem5py_env.Command([ "${PARAMS_HH}" ], srcs, - MakeAction(cmdline('PARAMS_HH'), Transform("SO Param", 2)), - MODULE=module, - SIMOBJ=simobj, - PYSCRIPT=build_tools.File('sim_object_param_struct_hh.py'), - PARAMS_HH=File(f'params/{simobj}.hh')) - - # Params cc. - cc_file = File(f'python/_m5/param_{simobj}.cc') - gem5py_env.Command([ "${PARAMS_CC}" ], srcs, - MakeAction(cmdline('PARAMS_CC', 'USE_PYTHON'), - Transform("SO Param", 2)), - PYSCRIPT=build_tools.File('sim_object_param_struct_cc.py'), - MODULE=module, - SIMOBJ=simobj, - PARAMS_CC=cc_file, - USE_PYTHON=env['USE_PYTHON']) - Source(cc_file, tags=tags, add_tags='python') - - # CXX config header. - gem5py_env.Command([ "${CXXCONFIG_HH}" ], srcs, - MakeAction(cmdline('CXXCONFIG_HH'), Transform("CXXCPRHH", 2)), - PYSCRIPT=build_tools.File('cxx_config_hh.py'), - MODULE=module, - CXXCONFIG_HH=File(f'cxx_config/{simobj}.hh')) - - # CXX config cc. - cc_file=File(f'cxx_config/{simobj}.cc') - gem5py_env.Command([ "${CXXCONFIG_CC}" ], srcs, - MakeAction(cmdline('CXXCONFIG_CC'), Transform("CXXCPRCC", 2)), - PYSCRIPT=build_tools.File('cxx_config_cc.py'), - MODULE=module, - CXXCONFIG_CC=cc_file) - if GetOption('with_cxx_config'): - Source(cc_file) - -# CXX config init.cc -all_sim_objects = sorted(itertools.chain.from_iterable( - SimObject.sim_objects.values())) +all_sim_objects = sorted(SimObject.sim_objects) sim_object_args = list(f'"{sim_object}"' for sim_object in all_sim_objects) cc_file = File('cxx_config/init.cc') gem5py_env.Command([ "${CXXCONFIGINIT_CC}" ], @@ -628,32 +650,6 @@ gem5py_env.Command([ "${CXXCONFIGINIT_CC}" ], if GetOption('with_cxx_config'): Source(cc_file) -# C++ versions of enum params. -for module, enums in sorted(SimObject.enums.items()): - tags = SimObject.tags[module] - for enum in enums: - gem5py_env.Command([ "${ENUM_HH}" ], - [ Value(module), Value(enum), "${GEM5PY_M5}", "${ENUMHH_PY}" ], - MakeAction('"${GEM5PY_M5}" "${ENUMHH_PY}" "${MODULE}" ' \ - '"${ENUM_HH}"', - Transform("ENUMDECL", 2)), - MODULE=module, - ENUM=enum, - ENUM_HH=File(f'enums/{enum}.hh'), - ENUMHH_PY=build_tools.File('enum_hh.py')) - cc_file = File(f'enums/{enum}.cc') - gem5py_env.Command([ "${ENUM_CC}" ], - [ Value(module), Value(enum), "${GEM5PY_M5}", "${ENUMCC_PY}" ], - MakeAction('"${GEM5PY_M5}" "${ENUMCC_PY}" "${MODULE}" ' \ - '"${ENUM_CC}" "${USE_PYTHON}"', - Transform("ENUM STR", 2)), - MODULE=module, - ENUM=enum, - ENUM_CC=cc_file, - ENUMCC_PY=build_tools.File('enum_cc.py'), - USE_PYTHON='--use-python' if env['USE_PYTHON'] else '') - Source(cc_file, tags=tags, add_tags='python') - # version tags tags = \ From 93bebf86ccf632f45e72f428759f79817bb1ddd3 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Fri, 20 Aug 2021 04:18:09 -0700 Subject: [PATCH 054/658] scons,sim: Eliminate the generated cxx_config/init.cc file. This file populated the "cxx_config_directory" map from type names to directory entry generating types. It used a comprehensive list of includes of all SimObject headers, and a comprehensive list of the generating types to fill everything in. Instead, this change creates a new singleton helper class which, when instantiated as a static member of a CxxConfigParams subclass, will install a pointer to a CxxConfigDirectoryEntry to that map during global object construction time. Also, this change renames the map to cxxConfigDirectory which is in compliance with the style guide, and puts it behind an accessor which returns a static variable which is the actual map. This avoids any problems that might come from global object construction order. Change-Id: Iaa913fbe5af1b11d90ca618e29420eeb7cb0faed Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/49455 Reviewed-by: Andreas Sandberg Maintainer: Andreas Sandberg Tested-by: kokoro --- build_tools/cxx_config_hh.py | 10 ++-- build_tools/cxx_config_init_cc.py | 77 ------------------------------- src/SConscript | 34 -------------- src/sim/cxx_config.cc | 7 ++- src/sim/cxx_config.hh | 23 +++++---- src/sim/cxx_manager.cc | 6 +-- 6 files changed, 27 insertions(+), 130 deletions(-) delete mode 100644 build_tools/cxx_config_init_cc.py diff --git a/build_tools/cxx_config_hh.py b/build_tools/cxx_config_hh.py index 4e47f87d21..652c488668 100644 --- a/build_tools/cxx_config_hh.py +++ b/build_tools/cxx_config_hh.py @@ -85,6 +85,9 @@ class ${param_class} : public CxxConfigParams, public ${sim_object_name}Params } }; + static inline AddToConfigDir dirEntry + {"${sim_object_name}", new DirectoryEntry}; + public: bool setSimObject(const std::string &name, SimObject *simObject); @@ -104,13 +107,6 @@ class ${param_class} : public CxxConfigParams, public ${sim_object_name}Params bool setPortConnectionCount(const std::string &name, unsigned int count); SimObject *simObjectCreate(); - - static CxxConfigDirectoryEntry * - makeDirectoryEntry() - { - return new DirectoryEntry; - } - }; } // namespace gem5 diff --git a/build_tools/cxx_config_init_cc.py b/build_tools/cxx_config_init_cc.py deleted file mode 100644 index aab8d29c3b..0000000000 --- a/build_tools/cxx_config_init_cc.py +++ /dev/null @@ -1,77 +0,0 @@ -# Copyright 2004-2006 The Regents of The University of Michigan -# Copyright 2010-20013 Advanced Micro Devices, Inc. -# Copyright 2013 Mark D. Hill and David A. Wood -# Copyright 2017-2020 ARM Limited -# Copyright 2021 Google, Inc. -# -# The license below extends only to copyright in the software and shall -# not be construed as granting a license to any other intellectual -# property including but not limited to intellectual property relating -# to a hardware implementation of the functionality of the software -# licensed hereunder. You may use the software subject to the license -# terms below provided that you ensure that this notice is replicated -# unmodified and in its entirety in all distributions of the software, -# modified or unmodified, in source code or in binary form. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer; -# redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution; -# neither the name of the copyright holders nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -import argparse -import sys - -from code_formatter import code_formatter - -parser = argparse.ArgumentParser() -parser.add_argument('cxx_config_init_cc', - help='cxx config init cc file to generate') -parser.add_argument('sim_objects', help='all simobjects to include', nargs='*') - -args = parser.parse_args() - -code = code_formatter() - -for sim_object in args.sim_objects: - code('#include "cxx_config/${sim_object}.hh"') - -code(''' -namespace gem5 -{ - -void -cxxConfigInit() -{ -''') - -code.indent() -for sim_object in args.sim_objects: - code('cxx_config_directory["${sim_object}"] = ' - '${sim_object}CxxConfigParams::makeDirectoryEntry();') -code.dedent() - -code(''' -} - -} // namespace gem5 -''') - -code.write(args.cxx_config_init_cc) diff --git a/src/SConscript b/src/SConscript index ff8e5a5974..61585ecb93 100644 --- a/src/SConscript +++ b/src/SConscript @@ -133,10 +133,6 @@ class SimObject(PySource): '''Add a SimObject python file as a python source object and add it to a list of sim object modules''' - fixed = False - - sim_objects = [] - def __init__(self, source, *, sim_objects=None, enums=None, tags=None, add_tags=None): '''Specify the source file and any tags (automatically in @@ -150,10 +146,6 @@ class SimObject(PySource): enums = [] super().__init__('m5.objects', source, tags, add_tags) - if self.fixed: - error("Too late to call SimObject now.") - - SimObject.sim_objects.extend(sim_objects) build_dir = Dir(env['BUILDDIR']) module = self.modpath @@ -587,13 +579,6 @@ def makeTheGPUISA(source, target, env): env.Command('config/the_gpu_isa.hh', [], MakeAction(makeTheGPUISA, Transform("CFG ISA", 0))) -######################################################################## -# -# Prevent any SimObjects from being added after this point, they -# should all have been added in the SConscripts above -# -SimObject.fixed = True - ######################################################################## # @@ -631,25 +616,6 @@ m5_module_source = \ m5_module_static = list(map(lambda s: s.static(gem5py_env), m5_module_source)) gem5py_env.Program(gem5py_m5, [ 'python/gem5py.cc' ] + m5_module_static) -######################################################################## -# -# Create the CXX config init.cc. -# - -all_sim_objects = sorted(SimObject.sim_objects) -sim_object_args = list(f'"{sim_object}"' for sim_object in all_sim_objects) -cc_file = File('cxx_config/init.cc') -gem5py_env.Command([ "${CXXCONFIGINIT_CC}" ], - [ "${GEM5PY}", "${CXXCONFIGINITCC_PY}" ], - MakeAction('"${GEM5PY}" "${CXXCONFIGINITCC_PY}" "${TARGET}" ' - '${SIM_OBJECTS}', - Transform("CXXCINIT", 0)), - CXXCONFIGINITCC_PY=build_tools.File('cxx_config_init_cc.py'), - SIM_OBJECTS=' '.join(sim_object_args), - CXXCONFIGINIT_CC=cc_file) -if GetOption('with_cxx_config'): - Source(cc_file) - # version tags tags = \ diff --git a/src/sim/cxx_config.cc b/src/sim/cxx_config.cc index dc2540218c..2f14ae9dab 100644 --- a/src/sim/cxx_config.cc +++ b/src/sim/cxx_config.cc @@ -43,6 +43,11 @@ namespace gem5 const std::string CxxConfigParams::invalidName = ""; /** Directory of all SimObject classes config details */ -std::map cxx_config_directory; +std::map & +cxxConfigDirectory() +{ + static std::map dir; + return dir; +} } // namespace gem5 diff --git a/src/sim/cxx_config.hh b/src/sim/cxx_config.hh index 081860a099..ba34919a3e 100644 --- a/src/sim/cxx_config.hh +++ b/src/sim/cxx_config.hh @@ -119,6 +119,9 @@ class CxxConfigDirectoryEntry virtual ~CxxConfigDirectoryEntry() { } }; +/** Directory of all SimObject classes config details */ +std::map &cxxConfigDirectory(); + /** Base for peer classes of SimObjectParams derived classes with parameter * modifying member functions. C++ configuration will offer objects of * these classes to SimObjects as params rather than SimObjectParams @@ -128,6 +131,18 @@ class CxxConfigParams private: static const std::string invalidName; + protected: + struct AddToConfigDir + { + AddToConfigDir(const std::string &name, CxxConfigDirectoryEntry *entry) + { + auto it_success = cxxConfigDirectory().insert({name, entry}); + panic_if(!it_success.second, + "Failed to insert config directory entry %s (duplicate?).", + name); + } + }; + public: /** Flags passable to setParam... to smooth over any parsing difference * between different config files */ @@ -229,14 +244,6 @@ class CxxConfigFileBase virtual CxxConfigParams::Flags getFlags() const { return 0; } }; -/** Directory of all SimObject classes config details */ -extern std::map - cxx_config_directory; - -/** Initialise cxx_config_directory. This is defined in the - * auto-generated .../cxx_config/init.cc */ -void cxxConfigInit(); - } // namespace gem5 #endif // __SIM_CXX_CONFIG_HH__ diff --git a/src/sim/cxx_manager.cc b/src/sim/cxx_manager.cc index 9c250917e6..609b939515 100644 --- a/src/sim/cxx_manager.cc +++ b/src/sim/cxx_manager.cc @@ -65,14 +65,14 @@ CxxConfigManager::findObjectType(const std::string &object_name, if (!configFile.getParam(object_name, "type", object_type)) throw Exception(object_name, "Sim object has no 'type' field"); - if (cxx_config_directory.find(object_type) == - cxx_config_directory.end()) + if (cxxConfigDirectory().find(object_type) == + cxxConfigDirectory().end()) { throw Exception(object_name, csprintf( "No sim object type %s is available", object_type)); } - const CxxConfigDirectoryEntry *entry = cxx_config_directory[object_type]; + const CxxConfigDirectoryEntry *entry = cxxConfigDirectory()[object_type]; return *entry; } From bd687d48eb4060cb14b64f591c95587a98690018 Mon Sep 17 00:00:00 2001 From: Alex Richardson Date: Tue, 11 Jan 2022 12:24:41 +0000 Subject: [PATCH 055/658] arch-riscv: Add an ostream operator for PrivilegeMode This makes it easier to use the current privilege mode in error messages. Change-Id: I425d45d3957a70d8afb6cbde18955fae1461c960 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55403 Reviewed-by: Jason Lowe-Power Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/arch/riscv/isa.cc | 14 ++++++++++++++ src/arch/riscv/isa.hh | 2 ++ 2 files changed, 16 insertions(+) diff --git a/src/arch/riscv/isa.cc b/src/arch/riscv/isa.cc index c8b752c914..f49a2a87d7 100644 --- a/src/arch/riscv/isa.cc +++ b/src/arch/riscv/isa.cc @@ -575,3 +575,17 @@ ISA::globalClearExclusive() } // namespace RiscvISA } // namespace gem5 + +std::ostream & +operator<<(std::ostream &os, gem5::RiscvISA::PrivilegeMode pm) +{ + switch (pm) { + case gem5::RiscvISA::PRV_U: + return os << "PRV_U"; + case gem5::RiscvISA::PRV_S: + return os << "PRV_S"; + case gem5::RiscvISA::PRV_M: + return os << "PRV_M"; + } + return os << "PRV_"; +} diff --git a/src/arch/riscv/isa.hh b/src/arch/riscv/isa.hh index 143cc698a6..81923b5aef 100644 --- a/src/arch/riscv/isa.hh +++ b/src/arch/riscv/isa.hh @@ -119,4 +119,6 @@ class ISA : public BaseISA } // namespace RiscvISA } // namespace gem5 +std::ostream &operator<<(std::ostream &os, gem5::RiscvISA::PrivilegeMode pm); + #endif // __ARCH_RISCV_ISA_HH__ From f9f86cc36626727f3a09b35e6ad570629787840e Mon Sep 17 00:00:00 2001 From: Alex Richardson Date: Tue, 11 Jan 2022 12:42:47 +0000 Subject: [PATCH 056/658] arch-riscv: Consistently check privilege mode for CSR accesses According to the RISC-V privileged spec (section 2.1), bits 8 and 9 of the CSR number encode the lowest privilege mode that is permitted to access the CSR. Commit 55e7d3e5b6f062659bad5f6fdc8469ce80f102dd added this check for for CSR_MSTATUS but none of the other CSRs. Change-Id: Iecf2e387fa9ee810e8b8471341bfa371693b97c5 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55404 Reviewed-by: Nils Asmussen Maintainer: Jason Lowe-Power Tested-by: kokoro --- src/arch/riscv/isa/formats/standard.isa | 22 +++++++++------------- 1 file changed, 9 insertions(+), 13 deletions(-) diff --git a/src/arch/riscv/isa/formats/standard.isa b/src/arch/riscv/isa/formats/standard.isa index 9345c1ff54..e4bd4d8b09 100644 --- a/src/arch/riscv/isa/formats/standard.isa +++ b/src/arch/riscv/isa/formats/standard.isa @@ -290,23 +290,19 @@ def template CSRExecute {{ %(op_rd)s; RegVal data, olddata; - + auto lowestAllowedMode = (PrivilegeMode)bits(csr, 9, 8); + auto pm = (PrivilegeMode)xc->readMiscReg(MISCREG_PRV); + if (pm < lowestAllowedMode) { + return std::make_shared( + csprintf("%s is not accessible in %s\n", csrName, pm), + machInst); + } switch (csr) { case CSR_SATP: { - auto pm = (PrivilegeMode)xc->readMiscReg(MISCREG_PRV); STATUS status = xc->readMiscReg(MISCREG_STATUS); - if (pm == PRV_U || (pm == PRV_S && status.tvm == 1)) { + if (pm == PRV_S && status.tvm == 1) { return std::make_shared( - "SATP access in user mode or with TVM enabled\n", - machInst); - } - break; - } - case CSR_MSTATUS: { - auto pm = (PrivilegeMode)xc->readMiscReg(MISCREG_PRV); - if (pm != PrivilegeMode::PRV_M) { - return std::make_shared( - "MSTATUS is only accessibly in machine mode\n", + "SATP access with TVM enabled\n", machInst); } break; From 186ba925045abb12c62c16aedf48e51dde091dbf Mon Sep 17 00:00:00 2001 From: Earl Ou Date: Mon, 3 Jan 2022 22:59:33 +0800 Subject: [PATCH 057/658] fastmodel: make gem5 fastmodel build hermetic This CL makes fastmodel RPATH relative to $ORIGIN instead of absolute path. In this way we can move build folder (installing), without breaking gem5 run. Change-Id: I8b16d749252b982e45dfe779a5df931015a0e07d Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55085 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/arm/fastmodel/SConscript | 33 ++++++++++++++++++------ src/arch/arm/fastmodel/arm_fast_model.py | 12 --------- 2 files changed, 25 insertions(+), 20 deletions(-) diff --git a/src/arch/arm/fastmodel/SConscript b/src/arch/arm/fastmodel/SConscript index ccfc6205d0..69749bf0e3 100644 --- a/src/arch/arm/fastmodel/SConscript +++ b/src/arch/arm/fastmodel/SConscript @@ -81,7 +81,16 @@ pvlib_flavor = env['PVLIB_FLAVOR'] pvlib_lib_dir = pvlib_home.Dir('lib').Dir(pvlib_flavor) simulation_engine_name = 'libMAXCOREInitSimulationEngine.3.so' -simulation_engine_lib = pvlib_lib_dir.File(simulation_engine_name) +simulation_engine_lib = env.Command( + Dir(env['BUILDDIR']).File(simulation_engine_name), + pvlib_lib_dir.File(simulation_engine_name), + MakeAction("cp ${SOURCE} ${TARGET}", Transform('COPY'))) + +arm_singleton_registry_name = 'arm_singleton_registry.so' +arm_singleton_registry_lib = env.Command( + Dir(env['BUILDDIR']).File(arm_singleton_registry_name), + pvlib_lib_dir.File(arm_singleton_registry_name), + MakeAction("cp ${SOURCE} ${TARGET}", Transform('COPY'))) def staticify(env, name): @@ -95,9 +104,7 @@ def staticify(env, name): full_name = Dir(path).File(static_name).get_abspath() if os.path.isfile(full_name): return File(full_name) - - return name - + raise BuildError("Failed to find FM static lib: " + name) # Adjust the build environment to support building in Fast Models. @@ -121,16 +128,20 @@ lib_paths = ( pvlib_home.Dir('Iris').Dir(pvlib_flavor), ) env.Append(LIBPATH=lib_paths) -env.Append(RPATH=lib_paths) -fm_libs = ( +# Per ARM's 11.16 release note, a platform build with simgen automatically +# copies libraries into the build target directory along with the other +# dependencies. Therefore, we only need to add each simgen result into rpath and +# no other shared librarires are required here. +fm_static_libs = ( 'components', 'pvbus', 'armctmodel', 'fmruntime', 'IrisSupport', ) -env.Append(LIBS=list(staticify(env, lib) for lib in fm_libs)) +env.Append(LIBS=list(staticify(env, lib) for lib in fm_static_libs)) + system_libs = ( 'atomic', 'dl', @@ -337,7 +348,8 @@ class ArmFastModelComponent(object): self.headerpaths = [gen_dir] self.libs = static_lib_nodes + shared_libs self.libpaths = [simgen_dir] - self.rpaths = [simgen_dir] + # Simgen also puts required share library under the project folder. + self.rpaths = [simgen_dir, project_file_dir] self.log = gen_dir.File('build_%s.log' % tlc) self.simgen_cmd = env.subst('${SIMGEN} -p %s --configuration %s -b ' + '--verbose off --num-build-cpus 100 --build-dir %s >%s') % \ @@ -364,6 +376,11 @@ class ArmFastModelComponent(object): # but the difference is probably not significant. env.SideEffect(next(license_cycle), lib_nodes[0]) + # We need a copy of the simulation engine lib and arm_singleton_registry + # (introduced in 11.16) alongside the executable. + Depends(lib_nodes[0], simulation_engine_lib) + Depends(lib_nodes[0], arm_singleton_registry_lib) + def prepare_env(self, env): env.Append(LIBPATH=self.libpaths) env.AddLocalRPATH(*self.rpaths) diff --git a/src/arch/arm/fastmodel/arm_fast_model.py b/src/arch/arm/fastmodel/arm_fast_model.py index c9d11135d3..f11443de2b 100644 --- a/src/arch/arm/fastmodel/arm_fast_model.py +++ b/src/arch/arm/fastmodel/arm_fast_model.py @@ -42,21 +42,9 @@ def set_armlmd_license_file(force=False): # 7.6 of the Fast Models User Guide. def scx_initialize(id): - # Change our working directory to where the simulation engine library - # is so that the fast model code can find it. It looks in the binary - # directory and in the current working directory, and we can change - # the later. This avoids having to make copies of that library all - # over the place. - cwd = os.getcwd() - os.chdir(os.path.join(buildEnv['PVLIB_HOME'], 'lib', - buildEnv['PVLIB_FLAVOR'])) - # Actually run scx_initialize. _m5.arm_fast_model.scx_initialize(id) - # Restore the previous working directory. - os.chdir(cwd) - def scx_load_application(instance, application): _m5.arm_fast_model.scx_load_application(instance, application) From 01333c73def6f2d3d35f04ad8489bf3271033dc7 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sat, 8 Jan 2022 23:42:03 -0800 Subject: [PATCH 058/658] arch-x86: Fix real mode far jumps with set MSB in the offset. When performing a real mode far jump, we were computing the offset into the segment more or less correctly, but then when we tried to actually set the PC using it, we used the second of the two wrip microop arguments. The first argument is an unsigned value and is intended to be a base to work from when figuring out the new IP, and the second argument is a signed offset which can be used to implement relative jumps/branches. When we used the second operand for our new value, setting the first operand to t0 (the zero register on x86), we would inadvertantly sign extend it since the wrip instruction would treat it as a signed value. Instead, we can just switch the two operands so that the wrip microop treats the desired value as the unsigned base, and then adds a signed t0 to it, which will still be 0 one way or the other. Also, while researching this bug, I found that the size used for computing the new IP is always the operand size, and never the address size. This CL fixes that problem as well by removing the faulty override. Change-Id: I96ac9effd37b40161dd8d0b634c5869e767a8873 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55243 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- .../x86/isa/insts/general_purpose/control_transfer/jump.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/arch/x86/isa/insts/general_purpose/control_transfer/jump.py b/src/arch/x86/isa/insts/general_purpose/control_transfer/jump.py index f39e799f89..b289f18c71 100644 --- a/src/arch/x86/isa/insts/general_purpose/control_transfer/jump.py +++ b/src/arch/x86/isa/insts/general_purpose/control_transfer/jump.py @@ -157,7 +157,8 @@ def macroop JMP_FAR_REAL_M slli t3, t3, 4, dataSize=8 wrsel cs, t1, dataSize=2 wrbase cs, t3, dataSize=8 - wrip t0, t2, dataSize=asz + # Put t2 first so it isn't sign extended. + wrip t2, t0 }; def macroop JMP_FAR_REAL_P @@ -183,6 +184,7 @@ def macroop JMP_FAR_REAL_I slli t3, t1, 4, dataSize=8 wrsel cs, t1, dataSize=2 wrbase cs, t3, dataSize=8 - wrip t0, t2, dataSize=asz + # Put t2 first so it isn't sign extended. + wrip t2, t0 }; ''' From 3a19fa4d8d997e44458988f7ea5b483bb1907ee5 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sun, 9 Jan 2022 03:24:11 -0800 Subject: [PATCH 059/658] arch-x86: Plumb up more of the i8237 DMA controller. The device still can't actually do any DMAing, but now it's interface is plumbed up so that it should work as expected up to the point where it's asked to DMA something. Then it will panic as before. Change-Id: I06a163a9a963bf87405e24fc5ceebe14f186adfd Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55248 Reviewed-by: Gabe Black Reviewed-by: Matt Sinclair Maintainer: Gabe Black Tested-by: kokoro --- src/dev/x86/i8237.cc | 57 +++++++++++++++++++++++++++++++++----------- src/dev/x86/i8237.hh | 13 +++++++++- 2 files changed, 55 insertions(+), 15 deletions(-) diff --git a/src/dev/x86/i8237.cc b/src/dev/x86/i8237.cc index 437a376bfd..e14e91115c 100644 --- a/src/dev/x86/i8237.cc +++ b/src/dev/x86/i8237.cc @@ -99,31 +99,52 @@ I8237::I8237(const Params &p) : BasicPioDevice(p, 16), latency(p.pio_latency), // Add the other registers individually. regs.addRegisters({ statusCommandReg. - reader(readUnimpl("status register")). - writer(writeUnimpl("command register")), + reader([this](auto ®) -> uint8_t { return statusVal; }). + writer([this](auto ®, const uint8_t &value) { + commandVal = value; + }), requestReg. - writer(writeUnimpl("request register")), + writer(this, &I8237::setRequestBit), setMaskBitReg. writer(this, &I8237::setMaskBit), modeReg. - writer(writeUnimpl("mode register")), + writer([this](auto ®, const uint8_t &value) { + channels[bits(value, 1, 0)].mode = value; + }), clearFlipFlopReg. - writer(writeUnimpl("clear LSB/MSB flip-flop register")), + writer([this](auto ®, const uint8_t &value) { + highByte = false; + }), temporaryMasterClearReg. - reader(readUnimpl("temporary register")). - writer(writeUnimpl("master clear register")), + reader([this](auto ®) ->uint8_t { return tempVal; }). + writer([this](auto ®, const uint8_t &value) { reset(); }), clearMaskReg. - writer(writeUnimpl("clear mask register")), + writer([this](auto ®, const uint8_t &value) { maskVal = 0x0; }), writeMaskReg. - writer(writeUnimpl("write all mask register bits")) + writer([this](auto ®, const uint8_t &value) { + maskVal = bits(value, 3, 0); + }) }); + + reset(); +} + +void +I8237::reset() +{ + maskVal = 0xf; + requestVal = 0x0; + commandVal = 0x0; + statusVal = 0x0; + tempVal = 0x0; + highByte = false; } void @@ -131,9 +152,17 @@ I8237::setMaskBit(Register ®, const uint8_t &command) { uint8_t select = bits(command, 1, 0); uint8_t bitVal = bits(command, 2); - if (!bitVal) - panic("Turning on i8237 channels unimplemented."); - replaceBits(maskReg, select, bitVal); + panic_if(!bitVal, "Turning on i8237 channels unimplemented."); + replaceBits(maskVal, select, bitVal); +} + +void +I8237::setRequestBit(Register ®, const uint8_t &command) +{ + uint8_t select = bits(command, 1, 0); + uint8_t bitVal = bits(command, 2); + panic_if(bitVal, "Requesting i8237 DMA transfers is unimplemented."); + replaceBits(requestVal, select, bitVal); } Tick @@ -155,13 +184,13 @@ I8237::write(PacketPtr pkt) void I8237::serialize(CheckpointOut &cp) const { - SERIALIZE_SCALAR(maskReg); + paramOut(cp, "maskReg", maskVal); } void I8237::unserialize(CheckpointIn &cp) { - UNSERIALIZE_SCALAR(maskReg); + paramIn(cp, "maskReg", maskVal); } } // namespace X86ISA diff --git a/src/dev/x86/i8237.hh b/src/dev/x86/i8237.hh index 9fb9b8974a..b80af63d12 100644 --- a/src/dev/x86/i8237.hh +++ b/src/dev/x86/i8237.hh @@ -48,7 +48,13 @@ class I8237 : public BasicPioDevice protected: Tick latency; - uint8_t maskReg = 0; + uint8_t maskVal; + //XXX These should be serialized. + uint8_t requestVal; + uint8_t commandVal; + uint8_t statusVal; + uint8_t tempVal; + bool highByte; RegisterBankLE regs; @@ -68,6 +74,9 @@ class I8237 : public BasicPioDevice int number; + //XXX These should be serialized. + uint8_t mode = 0x0; + ChannelAddrReg addrReg; ChannelRemainingReg remainingReg; @@ -92,7 +101,9 @@ class I8237 : public BasicPioDevice WriteOnlyReg clearMaskReg; WriteOnlyReg writeMaskReg; + void reset(); void setMaskBit(Register ®, const uint8_t &command); + void setRequestBit(Register ®, const uint8_t &command); public: using Params = I8237Params; From 946edc794ff39f8d36c938b90c0d4ae664e3d0fc Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sun, 9 Jan 2022 17:54:38 -0800 Subject: [PATCH 060/658] arch-x86: Implement count latching with the PIT read back command. This command can trigger count latching for any of the PIT channels together with a single command, and can also latch a status byte. The status byte is not implemented here, but there is already functionality for latching the count which this can use. Change-Id: Ic2ad7c73d0c521fdd6fe5f62cb478c6718f3b90c Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55283 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/dev/intel_8254_timer.cc | 20 ++++++++++++++++---- src/dev/intel_8254_timer.hh | 12 ++++++++++++ 2 files changed, 28 insertions(+), 4 deletions(-) diff --git a/src/dev/intel_8254_timer.cc b/src/dev/intel_8254_timer.cc index c0fc773834..f64c0fe9c7 100644 --- a/src/dev/intel_8254_timer.cc +++ b/src/dev/intel_8254_timer.cc @@ -58,12 +58,24 @@ Intel8254Timer::writeControl(const CtrlReg data) { int sel = data.sel; - if (sel == ReadBackCommand) - panic("PITimer Read-Back Command is not implemented.\n"); + if (sel == ReadBackCommand) { + ReadBackCommandVal rb_val = static_cast(data); - if (data.rw == LatchCommand) + panic_if(!rb_val.status, + "Latching the PIT status byte is not implemented."); + + if (!rb_val.count) { + for (auto &cnt: counter) { + if (bits((uint8_t)rb_val.select, cnt->index())) + cnt->latchCount(); + } + } + return; + } + + if (data.rw == LatchCommand) { counter[sel]->latchCount(); - else { + } else { counter[sel]->setRW(data.rw); counter[sel]->setMode(data.mode); counter[sel]->setBCD(data.bcd); diff --git a/src/dev/intel_8254_timer.hh b/src/dev/intel_8254_timer.hh index 9876d139c5..e02a4cc6ab 100644 --- a/src/dev/intel_8254_timer.hh +++ b/src/dev/intel_8254_timer.hh @@ -53,6 +53,16 @@ class Intel8254Timer : public EventManager Bitfield<0> bcd; EndBitUnion(CtrlReg) + BitUnion8(ReadBackCommandVal) + Bitfield<4> status; // Active low. + Bitfield<5> count; // Active low. + SubBitUnion(select, 3, 1) + Bitfield<3> cnt2; + Bitfield<2> cnt1; + Bitfield<1> cnt0; + EndSubBitUnion(select) + EndBitUnion(ReadBackCommandVal) + enum SelectVal { SelectCounter0, @@ -152,6 +162,8 @@ class Intel8254Timer : public EventManager public: Counter(Intel8254Timer *p, const std::string &name, unsigned int num); + unsigned int index() const { return num; } + /** Latch the current count (if one is not already latched) */ void latchCount(); From 864650101bf7ae119800699945edf176d174c08a Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sun, 9 Jan 2022 21:27:42 -0800 Subject: [PATCH 061/658] arch-x86: Handle a special case for MODRM in 16 bit mode. When the address size is 16 bit, the mod field is 0, and the rm is 6, there is no base register, only a displacement. Change-Id: Ib67a6e5ce617d08913b9ca6dee66877f0154ffe1 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55285 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/x86/emulenv.cc | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/arch/x86/emulenv.cc b/src/arch/x86/emulenv.cc index bfca1e513d..44afc5acc9 100644 --- a/src/arch/x86/emulenv.cc +++ b/src/arch/x86/emulenv.cc @@ -82,7 +82,8 @@ void EmulEnv::doModRM(const ExtMachInst & machInst) base = INTREG_RDI; break; case 6: - base = INTREG_RBP; + // There is a special case when mod is 0 and rm is 6. + base = machInst.modRM.mod == 0 ? INTREG_T0 : INTREG_RBP; break; case 7: base = INTREG_RBX; From 25b046f4d432d3a23fb24cc8e33742c7254d9c44 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Mon, 10 Jan 2022 23:11:21 -0800 Subject: [PATCH 062/658] arch-x86: Fix disassembly of fixed register macroops. These are mapped to instruction definitions like MOV_R_R, even though one or more of the Rs might have come from a fixed value. Because MOV_R_R (for instance) is only defined once, using a fixed text constant there won't work because that can only have one value. Instead, use a variable which will have the value of that constant so that the same disassembly code will work no matter what fixed value was used. Change-Id: Ie45181c6becce80ad44fa30fc3323757ef713d7c Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55444 Tested-by: kokoro Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Reviewed-by: Gabe Black --- src/arch/x86/isa/specialize.isa | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/arch/x86/isa/specialize.isa b/src/arch/x86/isa/specialize.isa index 839b66d83d..7afdd2318a 100644 --- a/src/arch/x86/isa/specialize.isa +++ b/src/arch/x86/isa/specialize.isa @@ -141,6 +141,10 @@ let {{ else: regString = "INTREG_R%s" % opType.reg env.addReg(regString) + if env.regmUsed: + regString = "env.regm" + else: + regString = "env.reg" env.addToDisassembly( "printReg(out, RegId(IntRegClass, %s), regSize);\n" % regString) From 10118f751847891a8ef1b4a42b4991233fe28839 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Mon, 10 Jan 2022 23:25:00 -0800 Subject: [PATCH 063/658] arch-x86: Add decoder syntax for fixed segment registers. There is syntax for this already for fixed integer registers, which this is patterned after. Rather than prefixing the operand descriptor with a lower case "r", fixed segment registers are prefixed with a lower case "s". Change-Id: Ic08d323bef732a62de23f77ec805c8b7cd5e2303 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55445 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/x86/isa/specialize.isa | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/src/arch/x86/isa/specialize.isa b/src/arch/x86/isa/specialize.isa index 7afdd2318a..f90aa48473 100644 --- a/src/arch/x86/isa/specialize.isa +++ b/src/arch/x86/isa/specialize.isa @@ -104,17 +104,22 @@ let {{ let {{ class OpType(object): - parser = re.compile(r"(?P[A-Z]+)(?P[a-z]*)|(r(?P[A-Z0-9]+)(?P[a-z]*))") + parser = re.compile(r"(?P[A-Z]+)(?P[a-z]*)|" + "(r(?P[A-Z0-9]+)(?P[a-z]*))|" + "(s(?P[A-Z0-9]+)(?P[a-z]*))") def __init__(self, opTypeString): match = OpType.parser.search(opTypeString) if match == None: raise Exception("Problem parsing operand type {}".format( opTypeString)) self.reg = match.group("reg") + self.seg = match.group("seg") self.tag = match.group("tag") self.size = match.group("size") if not self.size: self.size = match.group("rsize") + if not self.size: + self.size = match.group("ssize") ModRMRegIndex = "(MODRM_REG | (REX_R << 3))" ModRMRMIndex = "(MODRM_RM | (REX_B << 3))" @@ -151,6 +156,16 @@ let {{ Name += "_R" + elif opType.seg: + env.addReg("SEGMENT_REG_%sS" % opType.seg) + if env.regmUsed: + regString = "env.regm" + else: + regString = "env.reg" + env.addToDisassembly("printSegment(out, %s);\n" % regString) + + Name += "_S" + elif opType.tag == "B": # This refers to registers whose index is encoded as part of # the opcode. From 75f77d8fd3b5a3c6b334f8ea9fa256bfd63bc348 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Mon, 10 Jan 2022 23:26:29 -0800 Subject: [PATCH 064/658] arch-x86: Implement the PUSH instruction for segment selectors. The implementation for PUSH is very simple and can be implemented trivially like the other PUSH versions. POP is more complicated since it needs to actually set up the segment being popped into. Change-Id: I4a5a4bcace15aef02186f893ccdd052083e5cb5d Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55446 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro Reviewed-by: Gabe Black --- .../insts/general_purpose/data_transfer/stack_operations.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/src/arch/x86/isa/insts/general_purpose/data_transfer/stack_operations.py b/src/arch/x86/isa/insts/general_purpose/data_transfer/stack_operations.py index c86e0e2415..acd2bb1d36 100644 --- a/src/arch/x86/isa/insts/general_purpose/data_transfer/stack_operations.py +++ b/src/arch/x86/isa/insts/general_purpose/data_transfer/stack_operations.py @@ -100,6 +100,12 @@ def macroop PUSH_P { subi rsp, rsp, ssz }; +def macroop PUSH_S { + rdsel t1, sr + st t1, ss, [1, t0, rsp], "-env.dataSize", addressSize=ssz + subi rsp, rsp, dsz, dataSize=ssz +}; + def macroop PUSHA { # Check all the stack addresses. We'll assume that if the beginning and # end are ok, then the stuff in the middle should be as well. From 2572b85f54136d1c38e4e88b10b6208a2e0494c2 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Mon, 10 Jan 2022 23:27:52 -0800 Subject: [PATCH 065/658] arch-x86: Hook up the PUSH segment selector insts in the decoder. Change-Id: Id4d59ced3f74a593bb6b0774b843f5dc155c49c5 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55447 Tested-by: kokoro Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Reviewed-by: Gabe Black --- src/arch/x86/isa/decoder/one_byte_opcodes.isa | 8 ++++---- src/arch/x86/isa/decoder/two_byte_opcodes.isa | 4 ++-- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/src/arch/x86/isa/decoder/one_byte_opcodes.isa b/src/arch/x86/isa/decoder/one_byte_opcodes.isa index 04b3adce1f..e34b477599 100644 --- a/src/arch/x86/isa/decoder/one_byte_opcodes.isa +++ b/src/arch/x86/isa/decoder/one_byte_opcodes.isa @@ -43,7 +43,7 @@ 0x00: decode OPCODE_OP_BOTTOM3 { 0x6: decode MODE_SUBMODE { 0x0: UD2(); - default: WarnUnimpl::push_ES(); + default: PUSH(sEv); } 0x7: decode MODE_SUBMODE { 0x0: UD2(); @@ -57,7 +57,7 @@ 0x01: decode OPCODE_OP_BOTTOM3 { 0x6: decode MODE_SUBMODE { 0x0: UD2(); - default: WarnUnimpl::push_CS(); + default: PUSH(sCv); } //Any time this is seen, it should generate a two byte opcode 0x7: M5InternalError::error( @@ -70,7 +70,7 @@ 0x02: decode OPCODE_OP_BOTTOM3 { 0x6: decode MODE_SUBMODE { 0x0: UD2(); - default: WarnUnimpl::push_SS(); + default: PUSH(sSv); } 0x7: decode MODE_SUBMODE { 0x0: UD2(); @@ -84,7 +84,7 @@ 0x03: decode OPCODE_OP_BOTTOM3 { 0x6: decode MODE_SUBMODE { 0x0: UD2(); - default: WarnUnimpl::push_DS(); + default: PUSH(sDv); } 0x7: decode MODE_SUBMODE { 0x0: UD2(); diff --git a/src/arch/x86/isa/decoder/two_byte_opcodes.isa b/src/arch/x86/isa/decoder/two_byte_opcodes.isa index 549db4751b..8913ce7c7a 100644 --- a/src/arch/x86/isa/decoder/two_byte_opcodes.isa +++ b/src/arch/x86/isa/decoder/two_byte_opcodes.isa @@ -667,7 +667,7 @@ } } 0x14: decode OPCODE_OP_BOTTOM3 { - 0x0: push_fs(); + 0x0: Inst::PUSH(sFv); 0x1: pop_fs(); 0x2: CPUIDInst::CPUID({{ CpuidResult result; @@ -694,7 +694,7 @@ default: Inst::UD2(); } 0x15: decode OPCODE_OP_BOTTOM3 { - 0x0: push_gs(); + 0x0: Inst::PUSH(sGv); 0x1: pop_gs(); 0x2: rsm_smm(); 0x3: Inst::BTS(Ev,Gv); From cfce0ad8743a7eb5e30a3028f94e816ebed45ccb Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Mon, 10 Jan 2022 23:28:35 -0800 Subject: [PATCH 066/658] arch-x86: Implement IRET for real mode. The IRET instruction is comparitively very simple in real mode. It just pops a few values off the stack into CS, RIP, and RFLAGS, and sets the CS base. Change-Id: I2bc6015209f1beca31253e288dad7c8de5cd22fc Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55448 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- .../interrupts_and_exceptions.py | 32 ++++++++++++++++++- 1 file changed, 31 insertions(+), 1 deletion(-) diff --git a/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py b/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py index cc32b7814a..2b0c5cb025 100644 --- a/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py +++ b/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py @@ -36,7 +36,37 @@ microcode = ''' def macroop IRET_REAL { .serialize_after - panic "Real mode iret isn't implemented!" + + # temp_RIP + ld t1, ss, [1, t0, rsp], "0 * env.dataSize", addressSize=ssz + # temp_CS + ld t2, ss, [1, t0, rsp], "1 * env.dataSize", addressSize=ssz + # temp_RFLAGS + ld t3, ss, [1, t0, rsp], "2 * env.dataSize", addressSize=ssz + + # Update RSP now that all memory accesses have succeeded. + addi rsp, rsp, "3 * env.dataSize", dataSize=ssz + + # Update CS. + wrsel cs, t2 + # Make sure there isn't any junk in the upper bits of the base. + mov t4, t0, t2 + slli t4, t4, 4, dataSize=8 + wrbase cs, t4, dataSize=8 + + # Update RFLAGS + # Get the current RFLAGS + rflags t4 + # Flip flag bits if they should change. + xor t5, t4, t3 + # Don't change VIF, VIP, or VM + limm t6, "~(VIFBit | VIPBit | VMBit)", dataSize=8 + and t5, t5, t6, dataSize=8 + # Write back RFLAGS with flipped bits. + wrflags t4, t5, dataSize=8 + + # Update RIP + wrip t1, t0 }; def macroop IRET_PROT { From c22ec209d801c0a5200c55e03868b124072954dd Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Tue, 11 Jan 2022 00:08:20 -0800 Subject: [PATCH 067/658] arch-x86: Split out and implement INT for real mode. The INT instruction is much simpler in real mode than it is in legacy protected mode. Change-Id: I79f5bc7ebe36726537cd61657f301905085c1199 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55449 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/x86/isa/decoder/one_byte_opcodes.isa | 8 ++- .../interrupts_and_exceptions.py | 61 +++++++++++++++++-- 2 files changed, 63 insertions(+), 6 deletions(-) diff --git a/src/arch/x86/isa/decoder/one_byte_opcodes.isa b/src/arch/x86/isa/decoder/one_byte_opcodes.isa index e34b477599..66cb2c3216 100644 --- a/src/arch/x86/isa/decoder/one_byte_opcodes.isa +++ b/src/arch/x86/isa/decoder/one_byte_opcodes.isa @@ -403,7 +403,13 @@ }}); } - default: Inst::INT(Ib); + default: decode MODE_MODE { + 0x0: Inst::INT_LONG(Ib); + 0x1: decode MODE_SUBMODE { + 0x4: Inst::INT_REAL(Ib); + default: Inst::INT_PROT(Ib); + } + } } 0x6: decode MODE_SUBMODE { 0x0: Inst::UD2(); diff --git a/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py b/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py index 2b0c5cb025..983d95ee7c 100644 --- a/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py +++ b/src/arch/x86/isa/insts/general_purpose/control_transfer/interrupts_and_exceptions.py @@ -263,8 +263,18 @@ def macroop INT3 { br rom_label("legacyModeInterrupt") }; -def macroop INT_I { - +def macroop INT_LONG_I { + #load the byte-sized interrupt vector specified in the instruction + .adjust_imm trimImm(8) + limm t1, imm, dataSize=8 + + rdip t7 + + # Are we in long mode? + br rom_label("longModeSoftInterrupt") +}; + +def macroop INT_PROT_I { #load the byte-sized interrupt vector specified in the instruction .adjust_imm trimImm(8) limm t1, imm, dataSize=8 @@ -272,11 +282,52 @@ def macroop INT_I { rdip t7 # Are we in long mode? - rdm5reg t5 - andi t0, t5, 0x1, flags=(EZF,) - br rom_label("longModeSoftInterrupt"), flags=(CEZF,) br rom_label("legacyModeInterrupt") }; + +def macroop INT_REAL_I { + #load the byte-sized interrupt vector specified in the instruction + .adjust_imm trimImm(8) + limm t1, imm, dataSize=8 + + # temp_RIP + ld t2, idtr, [4, t1, t0], dataSize=2, addressSize=8 + # temp_CS + ld t3, idtr, [4, t1, t0], 2, dataSize=2, addressSize=8 + + cda ss, [1, t0, rsp], -2, dataSize=2, addressSize=ssz + cda ss, [1, t0, rsp], -6, dataSize=2, addressSize=ssz + + rflags t4, dataSize=8 + rdsel t5, cs, dataSize=8 + rdip t6 + + # Push RFLAGS. + st t4, ss, [1, t0, rsp], -2, dataSize=2, addressSize=ssz + # Push CS. + st t5, ss, [1, t0, rsp], -4, dataSize=2, addressSize=ssz + # Push the next RIP. + st t6, ss, [1, t0, rsp], -6, dataSize=2, addressSize=ssz + + # Update RSP + subi rsp, rsp, 6, dataSize=ssz + + # Set the CS selector. + wrsel cs, t3, dataSize=2 + # Make sure there isn't any junk in the upper bits of the base. + mov t3, t0, t3 + # Compute and set CS base. + slli t3, t3, 4, dataSize=8 + wrbase cs, t3, dataSize=8 + + # If AC, TF, IF or RF are set, we want to flip them. + limm t7, "(ACBit | TFBit | IFBit | RFBit)", dataSize=8 + and t7, t4, t7, dataSize=8 + wrflags t4, t7, dataSize=8 + + # Set the new RIP + wrip t2, t0 +}; ''' #let {{ # class INT(Inst): From 7b01dbd926b479e18bda8bf9d70b0a8a9d2edd27 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Tue, 11 Jan 2022 00:21:48 -0800 Subject: [PATCH 068/658] arch-x86: Implement real mode far ret. Change-Id: I4fd3210f30246f19ca03906465f160bcbfbfbccc Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55450 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/x86/isa/decoder/one_byte_opcodes.isa | 2 +- .../control_transfer/xreturn.py | 23 +++++++++++++++++++ 2 files changed, 24 insertions(+), 1 deletion(-) diff --git a/src/arch/x86/isa/decoder/one_byte_opcodes.isa b/src/arch/x86/isa/decoder/one_byte_opcodes.isa index 66cb2c3216..d129f20ef1 100644 --- a/src/arch/x86/isa/decoder/one_byte_opcodes.isa +++ b/src/arch/x86/isa/decoder/one_byte_opcodes.isa @@ -388,7 +388,7 @@ 0x1: Inst::LEAVE(); 0x2: ret_far_Iw(); 0x3: decode MODE_SUBMODE { - 0x3, 0x4: ret_far_real(); + 0x3, 0x4: Inst::RET_FAR_REAL(); default: Inst::RET_FAR(); } 0x4: Inst::INT3(); diff --git a/src/arch/x86/isa/insts/general_purpose/control_transfer/xreturn.py b/src/arch/x86/isa/insts/general_purpose/control_transfer/xreturn.py index 58b6bfd788..b3f09affc9 100644 --- a/src/arch/x86/isa/insts/general_purpose/control_transfer/xreturn.py +++ b/src/arch/x86/isa/insts/general_purpose/control_transfer/xreturn.py @@ -62,6 +62,29 @@ def macroop RET_NEAR_I wripi t1, 0 }; +def macroop RET_FAR_REAL { + .function_return + .control_indirect + + # Pop the return RIP. + ld t1, ss, [1, t0, rsp], addressSize=ssz + # Pop the return CS. + ld t2, ss, [1, t0, rsp], dsz, addressSize=ssz + # Adjust RSP. + addi rsp, rsp, "2 * env.dataSize", dataSize=ssz + + # Set the CS selector. + wrsel cs, t2 + # Make sure there isn't any junk in the upper bits of the base. + mov t2, t0, t2 + # Compute and set CS base. + slli t2, t2, 4, dataSize=8 + wrbase cs, t2, dataSize=8 + + # Set the new RIP. + wrip t1, t0 +}; + def macroop RET_FAR { .adjust_env oszIn64Override .function_return From c17d68f739f94cfe0531874a3fcb80c7a4199b78 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Tue, 11 Jan 2022 02:33:24 -0800 Subject: [PATCH 069/658] arch-x86: In the LVT in the local APIC, start with all entries masked. This is what the APIC is supposed to look like when coming out of reset. Change-Id: Ia9b6e13533692109849e729d9ad3b358f36e2e47 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55451 Reviewed-by: Matt Sinclair Reviewed-by: Gabe Black Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/x86/interrupts.cc | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/src/arch/x86/interrupts.cc b/src/arch/x86/interrupts.cc index 80ed3a6460..8499bfbbfa 100644 --- a/src/arch/x86/interrupts.cc +++ b/src/arch/x86/interrupts.cc @@ -616,6 +616,19 @@ X86ISA::Interrupts::Interrupts(const Params &p) ISRV = 0; IRRV = 0; + // At reset, all LVT entries start out zeroed, except for their mask bit. + LVTEntry masked = 0; + masked.masked = 1; + + regs[APIC_LVT_TIMER] = masked; + regs[APIC_LVT_THERMAL_SENSOR] = masked; + regs[APIC_LVT_PERFORMANCE_MONITORING_COUNTERS] = masked; + regs[APIC_LVT_LINT0] = masked; + regs[APIC_LVT_LINT1] = masked; + regs[APIC_LVT_ERROR] = masked; + + regs[APIC_SPURIOUS_INTERRUPT_VECTOR] = 0xff; + regs[APIC_VERSION] = (5 << 16) | 0x14; } From 69010fd0c950802ef57c95cc74d7831e57fef6b8 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Tue, 11 Jan 2022 02:34:11 -0800 Subject: [PATCH 070/658] arch-x86: Keep all the IOAPIC entries masked at startup. There are two entities setting up the IOAPIC when the simulation is started, the IOAPIC itsef, and the PC platform object. It's probably not a good idea (and definitely confusing) to have this initialization happening in two places. For now at least, lets make the PC platform object mask the IOAPIC lines at startup like the IOAPIC is doing. This will help prevent spurious interrupts from being delivered to the CPU during startup. Change-Id: I10f455d8e0fca28ddaf772c224a32c1f5f2dd37b Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55452 Reviewed-by: Matt Sinclair Reviewed-by: Gabe Black Maintainer: Matt Sinclair Tested-by: kokoro --- src/dev/x86/pc.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dev/x86/pc.cc b/src/dev/x86/pc.cc index 0473aa5b98..71881aa56d 100644 --- a/src/dev/x86/pc.cc +++ b/src/dev/x86/pc.cc @@ -68,6 +68,7 @@ Pc::init() */ X86ISA::I82094AA &ioApic = *southBridge->ioApic; X86ISA::I82094AA::RedirTableEntry entry = 0; + entry.mask = 1; entry.deliveryMode = X86ISA::delivery_mode::ExtInt; entry.vector = 0x20; ioApic.writeReg(0x10, entry.bottomDW); @@ -76,7 +77,6 @@ Pc::init() entry.vector = 0x24; ioApic.writeReg(0x18, entry.bottomDW); ioApic.writeReg(0x19, entry.topDW); - entry.mask = 1; entry.vector = 0x21; ioApic.writeReg(0x12, entry.bottomDW); ioApic.writeReg(0x13, entry.topDW); From c2c4303a07ae20af5268b08f673263102454b97e Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Fri, 14 Jan 2022 00:15:21 -0800 Subject: [PATCH 071/658] arch-x86: Use 16 bit modRM encoding if address size is 16 bit. The modRM byte should be interpreted with 16 bit rules if the address size is 16 bits, whether that's because the address size is that by default, or because it was overridden. It should not be based on the operand size in any case. Change-Id: I8827abe1eea8905b0404f7402fb9531804d63fae Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55503 Maintainer: Gabe Black Reviewed-by: Matt Sinclair Tested-by: kokoro --- src/arch/x86/decoder.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/arch/x86/decoder.cc b/src/arch/x86/decoder.cc index 842e0ad3fb..4c798721b0 100644 --- a/src/arch/x86/decoder.cc +++ b/src/arch/x86/decoder.cc @@ -515,7 +515,7 @@ Decoder::doModRMState(uint8_t nextByte) State nextState = ErrorState; ModRM modRM = nextByte; DPRINTF(Decoder, "Found modrm byte %#x.\n", nextByte); - if (defOp == 1) { + if (emi.addrSize == 2) { // Figure out 16 bit displacement size. if ((modRM.mod == 0 && modRM.rm == 6) || modRM.mod == 2) displacementSize = 2; From 1b0852ed30e39da69e8196434a08d46664adf4d7 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sun, 21 Mar 2021 22:12:11 -0700 Subject: [PATCH 072/658] arch-x86: Bare metal workload. Change-Id: I9ff6f5a9970cc7af2ba639be18f1881748074777 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/45045 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- src/arch/x86/SConscript | 3 +- src/arch/x86/X86FsWorkload.py | 7 ++- src/arch/x86/bare_metal/SConscript | 31 ++++++++++++ src/arch/x86/bare_metal/workload.cc | 71 +++++++++++++++++++++++++++ src/arch/x86/bare_metal/workload.hh | 74 +++++++++++++++++++++++++++++ 5 files changed, 184 insertions(+), 2 deletions(-) create mode 100644 src/arch/x86/bare_metal/SConscript create mode 100644 src/arch/x86/bare_metal/workload.cc create mode 100644 src/arch/x86/bare_metal/workload.hh diff --git a/src/arch/x86/SConscript b/src/arch/x86/SConscript index ad3d698bd7..8c957ddb40 100644 --- a/src/arch/x86/SConscript +++ b/src/arch/x86/SConscript @@ -62,7 +62,8 @@ Source('types.cc', tags='x86 isa') Source('utility.cc', tags='x86 isa') SimObject('X86SeWorkload.py', sim_objects=['X86EmuLinux'], tags='x86 isa') -SimObject('X86FsWorkload.py', sim_objects=['X86FsWorkload', 'X86FsLinux'], +SimObject('X86FsWorkload.py', + sim_objects=['X86BareMetalWorkload', 'X86FsWorkload', 'X86FsLinux'], tags='x86 isa') SimObject('X86Decoder.py', sim_objects=['X86Decoder'], tags='x86 isa') SimObject('X86ISA.py', sim_objects=['X86ISA'], tags='x86 isa') diff --git a/src/arch/x86/X86FsWorkload.py b/src/arch/x86/X86FsWorkload.py index a049203388..52dbadfe55 100644 --- a/src/arch/x86/X86FsWorkload.py +++ b/src/arch/x86/X86FsWorkload.py @@ -39,7 +39,12 @@ from m5.objects.E820 import X86E820Table, X86E820Entry from m5.objects.SMBios import X86SMBiosSMBiosTable from m5.objects.IntelMP import X86IntelMPFloatingPointer, X86IntelMPConfigTable from m5.objects.ACPI import X86ACPIRSDP -from m5.objects.Workload import KernelWorkload +from m5.objects.Workload import KernelWorkload, Workload + +class X86BareMetalWorkload(Workload): + type = 'X86BareMetalWorkload' + cxx_header = 'arch/x86/bare_metal/workload.hh' + cxx_class = 'gem5::X86ISA::BareMetalWorkload' class X86FsWorkload(KernelWorkload): type = 'X86FsWorkload' diff --git a/src/arch/x86/bare_metal/SConscript b/src/arch/x86/bare_metal/SConscript new file mode 100644 index 0000000000..04e8febfdd --- /dev/null +++ b/src/arch/x86/bare_metal/SConscript @@ -0,0 +1,31 @@ +# Copyright 2022 Google, Inc. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Import('*') + +if env['TARGET_ISA'] != 'x86': + Return() + +Source('workload.cc') diff --git a/src/arch/x86/bare_metal/workload.cc b/src/arch/x86/bare_metal/workload.cc new file mode 100644 index 0000000000..068c7e8f1c --- /dev/null +++ b/src/arch/x86/bare_metal/workload.cc @@ -0,0 +1,71 @@ +/* + * Copyright 2022 Google Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "arch/x86/bare_metal/workload.hh" + +#include "arch/x86/faults.hh" +#include "arch/x86/pcstate.hh" +#include "cpu/thread_context.hh" +#include "params/X86BareMetalWorkload.hh" +#include "sim/system.hh" + +namespace gem5 +{ + +namespace X86ISA +{ + +BareMetalWorkload::BareMetalWorkload(const Params &p) : Workload(p) +{} + +void +BareMetalWorkload::initState() +{ + Workload::initState(); + + for (auto *tc: system->threads) { + X86ISA::InitInterrupt(0).invoke(tc); + + if (tc->contextId() == 0) { + PCState pc = tc->pcState().as(); + // Don't start in the microcode ROM which would halt this CPU. + pc.upc(0); + pc.nupc(1); + tc->pcState(pc); + tc->activate(); + } else { + // This is an application processor (AP). It should be initialized + // to look like only the BIOS POST has run on it and put then put + // it into a halted state. + tc->suspend(); + } + } +} + +} // namespace X86ISA + +} // namespace gem5 diff --git a/src/arch/x86/bare_metal/workload.hh b/src/arch/x86/bare_metal/workload.hh new file mode 100644 index 0000000000..5e4838e00d --- /dev/null +++ b/src/arch/x86/bare_metal/workload.hh @@ -0,0 +1,74 @@ +/* + * Copyright 2022 Google Inc. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer; + * redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution; + * neither the name of the copyright holders nor the names of its + * contributors may be used to endorse or promote products derived from + * this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef __ARCH_X86_BARE_METAL_WORKLOAD_HH__ +#define __ARCH_X86_BARE_METAL_WORKLOAD_HH__ + +#include "base/loader/object_file.hh" +#include "base/loader/symtab.hh" +#include "base/types.hh" +#include "cpu/thread_context.hh" +#include "params/X86BareMetalWorkload.hh" +#include "sim/workload.hh" + +namespace gem5 +{ + +namespace X86ISA +{ + +class BareMetalWorkload : public Workload +{ + public: + using Params = X86BareMetalWorkloadParams; + BareMetalWorkload(const Params &p); + + public: + void initState() override; + + Addr getEntry() const override { return 0; } + ByteOrder byteOrder() const override { return ByteOrder::little; } + loader::Arch getArch() const override { return loader::UnknownArch; } + const loader::SymbolTable & + symtab(ThreadContext *tc) override + { + static loader::SymbolTable sym_tab; + return sym_tab; + } + + bool + insertSymbol(const loader::Symbol &symbol) override + { + return false; + } +}; + +} // namespace X86ISA + +} // namespace gem5 + +#endif // __ARCH_X86_BARE_METAL_WORKLOAD_HH__ From d3a323a72c020456dd1d53dde0f8da0fc2245121 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Mon, 1 Nov 2021 22:18:16 -0700 Subject: [PATCH 073/658] arch-x86: Make x86 respect m5op_base in SE mode. In SE mode, we can reasonably hard code what virtual address the m5ops show up at since that's private to the process, but we should respect the external setting of what physical address to use. Change-Id: I2ed9e5ba8c411e22e1d5163cf2ab875f9e2fe387 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/52496 Reviewed-by: Andreas Sandberg Maintainer: Gabe Black Tested-by: kokoro --- src/arch/x86/process.cc | 7 +++++-- src/arch/x86/se_workload.hh | 1 - 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/src/arch/x86/process.cc b/src/arch/x86/process.cc index c646c02148..90d3f7d708 100644 --- a/src/arch/x86/process.cc +++ b/src/arch/x86/process.cc @@ -518,8 +518,11 @@ X86_64Process::initState() /* PF handler */ pTable->map(PFHandlerVirtAddr, pfHandlerPhysAddr, PageBytes, false); /* MMIO region for m5ops */ - pTable->map(MMIORegionVirtAddr, MMIORegionPhysAddr, - 16 * PageBytes, false); + auto m5op_range = system->m5opRange(); + if (m5op_range.size()) { + pTable->map(MMIORegionVirtAddr, m5op_range.start(), + m5op_range.size(), false); + } } else { for (int i = 0; i < contextIds.size(); i++) { ThreadContext * tc = system->threads[contextIds[i]]; diff --git a/src/arch/x86/se_workload.hh b/src/arch/x86/se_workload.hh index 49ddf20dd7..0795a51538 100644 --- a/src/arch/x86/se_workload.hh +++ b/src/arch/x86/se_workload.hh @@ -45,7 +45,6 @@ const Addr TSSPhysAddr = 0x63000; const Addr ISTVirtAddr = 0xffff800000004000; const Addr PFHandlerVirtAddr = 0xffff800000005000; const Addr MMIORegionVirtAddr = 0xffffc90000000000; -const Addr MMIORegionPhysAddr = 0xffff0000; } // namespace X86ISA } // namespace gem5 From 6f843a918b08c6f74054e5126f8dcf09adcfd319 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Fri, 5 Nov 2021 08:00:30 -0700 Subject: [PATCH 074/658] sim,configs: Default m5ops_base to 0 (disabled) on x86. This is already the default for other platforms. This is most important when using KVM, where this mechanism is the only way to trigger pseudo instructions, or in SE mode to also trigger system calls. Change-Id: I0094e6814898ba397c7425e0fe76d84853bb17ad Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/52498 Reviewed-by: Gabe Black Maintainer: Gabe Black Tested-by: kokoro --- configs/common/FSConfig.py | 2 ++ configs/example/apu_se.py | 1 + configs/example/se.py | 1 + src/python/gem5/components/boards/x86_board.py | 2 ++ src/sim/System.py | 6 ++---- 5 files changed, 8 insertions(+), 4 deletions(-) diff --git a/configs/common/FSConfig.py b/configs/common/FSConfig.py index 8b8fb4e649..a7ba815268 100644 --- a/configs/common/FSConfig.py +++ b/configs/common/FSConfig.py @@ -445,6 +445,8 @@ def connectX86RubySystem(x86_sys): def makeX86System(mem_mode, numCPUs=1, mdesc=None, workload=None, Ruby=False): self = System() + self.m5ops_base = 0xffff0000 + if workload is None: workload = X86FsWorkload() self.workload = workload diff --git a/configs/example/apu_se.py b/configs/example/apu_se.py index 882d181062..532fb981f2 100644 --- a/configs/example/apu_se.py +++ b/configs/example/apu_se.py @@ -544,6 +544,7 @@ if fast_forward: have_kvm_support = 'BaseKvmCPU' in globals() if have_kvm_support and buildEnv['TARGET_ISA'] == "x86": system.vm = KvmVM() + system.m5ops_base = 0xffff0000 for i in range(len(host_cpu.workload)): host_cpu.workload[i].useArchPT = True host_cpu.workload[i].kvmInSE = True diff --git a/configs/example/se.py b/configs/example/se.py index a3b5cb9f30..3a8203da2e 100644 --- a/configs/example/se.py +++ b/configs/example/se.py @@ -200,6 +200,7 @@ for cpu in system.cpu: if ObjectList.is_kvm_cpu(CPUClass) or ObjectList.is_kvm_cpu(FutureClass): if buildEnv['TARGET_ISA'] == 'x86': system.kvm_vm = KvmVM() + system.m5ops_base = 0xffff0000 for process in multiprocesses: process.useArchPT = True process.kvmInSE = True diff --git a/src/python/gem5/components/boards/x86_board.py b/src/python/gem5/components/boards/x86_board.py index 6f53001eac..f777392390 100644 --- a/src/python/gem5/components/boards/x86_board.py +++ b/src/python/gem5/components/boards/x86_board.py @@ -99,6 +99,8 @@ class X86Board(AbstractBoard, KernelDiskWorkload): # Set up all of the I/O. self._setup_io_devices() + self.m5ops_base = 0xffff0000 + def _setup_io_devices(self): """ Sets up the x86 IO devices. diff --git a/src/sim/System.py b/src/sim/System.py index 596e25cc70..c5b7a8208b 100644 --- a/src/sim/System.py +++ b/src/sim/System.py @@ -124,10 +124,8 @@ class System(SimObject): # SE mode doesn't use the ISA System subclasses, and so we need to set an # ISA specific value in this class directly. - m5ops_base = Param.Addr( - 0xffff0000 if buildEnv['TARGET_ISA'] == 'x86' else 0, - "Base of the 64KiB PA range used for memory-mapped m5ops. Set to 0 " - "to disable.") + m5ops_base = Param.Addr(0, "Base of the 64KiB PA range used for " + "memory-mapped m5ops. Set to 0 to disable.") if buildEnv['USE_KVM']: kvm_vm = Param.KvmVM(NULL, 'KVM VM (i.e., shared memory domain)') From ef4381aecc2b70b63b0bda5e5fa5ca10c57d4e67 Mon Sep 17 00:00:00 2001 From: Gabe Black Date: Sun, 9 Jan 2022 19:36:23 -0800 Subject: [PATCH 075/658] dev: Refactor how counters are set up in the 8254 timer. Instead of dynamically allocating the channels, statically allocate them in a std::array. Also name them "counters" instead of "counter" so that that variable name can be used for an individual counter. Change-Id: I49614e192c8201b708e71331e7f70182b47546c6 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55284 Tested-by: kokoro Reviewed-by: Gabe Black Maintainer: Gabe Black --- src/dev/intel_8254_timer.cc | 53 +++++++++++++++---------------------- src/dev/intel_8254_timer.hh | 12 ++++----- 2 files changed, 27 insertions(+), 38 deletions(-) diff --git a/src/dev/intel_8254_timer.cc b/src/dev/intel_8254_timer.cc index f64c0fe9c7..df9b4b3d4e 100644 --- a/src/dev/intel_8254_timer.cc +++ b/src/dev/intel_8254_timer.cc @@ -36,22 +36,13 @@ namespace gem5 { -Intel8254Timer::Intel8254Timer(EventManager *em, const std::string &name, - Counter *counter0, Counter *counter1, Counter *counter2) : - EventManager(em), _name(name) -{ - counter[0] = counter0; - counter[1] = counter1; - counter[2] = counter2; -} - Intel8254Timer::Intel8254Timer(EventManager *em, const std::string &name) : - EventManager(em), _name(name) -{ - counter[0] = new Counter(this, name + ".counter0", 0); - counter[1] = new Counter(this, name + ".counter1", 1); - counter[2] = new Counter(this, name + ".counter2", 2); -} + EventManager(em), _name(name), counters{{ + {this, name + ".counter0", 0}, + {this, name + ".counter1", 1}, + {this, name + ".counter2", 2} + }} +{} void Intel8254Timer::writeControl(const CtrlReg data) @@ -65,20 +56,20 @@ Intel8254Timer::writeControl(const CtrlReg data) "Latching the PIT status byte is not implemented."); if (!rb_val.count) { - for (auto &cnt: counter) { - if (bits((uint8_t)rb_val.select, cnt->index())) - cnt->latchCount(); + for (auto &counter: counters) { + if (bits((uint8_t)rb_val.select, counter.index())) + counter.latchCount(); } } return; } if (data.rw == LatchCommand) { - counter[sel]->latchCount(); + counters[sel].latchCount(); } else { - counter[sel]->setRW(data.rw); - counter[sel]->setMode(data.mode); - counter[sel]->setBCD(data.bcd); + counters[sel].setRW(data.rw); + counters[sel].setMode(data.mode); + counters[sel].setBCD(data.bcd); } } @@ -86,26 +77,26 @@ void Intel8254Timer::serialize(const std::string &base, CheckpointOut &cp) const { // serialize the counters - counter[0]->serialize(base + ".counter0", cp); - counter[1]->serialize(base + ".counter1", cp); - counter[2]->serialize(base + ".counter2", cp); + counters[0].serialize(base + ".counter0", cp); + counters[1].serialize(base + ".counter1", cp); + counters[2].serialize(base + ".counter2", cp); } void Intel8254Timer::unserialize(const std::string &base, CheckpointIn &cp) { // unserialze the counters - counter[0]->unserialize(base + ".counter0", cp); - counter[1]->unserialize(base + ".counter1", cp); - counter[2]->unserialize(base + ".counter2", cp); + counters[0].unserialize(base + ".counter0", cp); + counters[1].unserialize(base + ".counter1", cp); + counters[2].unserialize(base + ".counter2", cp); } void Intel8254Timer::startup() { - counter[0]->startup(); - counter[1]->startup(); - counter[2]->startup(); + counters[0].startup(); + counters[1].startup(); + counters[2].startup(); } Intel8254Timer::Counter::Counter(Intel8254Timer *p, diff --git a/src/dev/intel_8254_timer.hh b/src/dev/intel_8254_timer.hh index e02a4cc6ab..7aec0659ec 100644 --- a/src/dev/intel_8254_timer.hh +++ b/src/dev/intel_8254_timer.hh @@ -29,6 +29,7 @@ #ifndef __DEV_8254_HH__ #define __DEV_8254_HH__ +#include #include #include @@ -212,7 +213,7 @@ class Intel8254Timer : public EventManager const std::string &name() const { return _name; } /** PIT has three seperate counters */ - Counter *counter[3]; + std::array counters; virtual void counterInterrupt(unsigned int num) @@ -226,9 +227,6 @@ class Intel8254Timer : public EventManager ~Intel8254Timer() {} - Intel8254Timer(EventManager *em, const std::string &name, - Counter *counter0, Counter *counter1, Counter *counter2); - Intel8254Timer(EventManager *em, const std::string &name); /** Write control word */ @@ -238,21 +236,21 @@ class Intel8254Timer : public EventManager readCounter(unsigned int num) { assert(num < 3); - return counter[num]->read(); + return counters[num].read(); } void writeCounter(unsigned int num, const uint8_t data) { assert(num < 3); - counter[num]->write(data); + counters[num].write(data); } bool outputHigh(unsigned int num) { assert(num < 3); - return counter[num]->outputHigh(); + return counters[num].outputHigh(); } /** From 41ee8ec7d8578b87b4f9b50440f82c57a544cc62 Mon Sep 17 00:00:00 2001 From: Austin Harris Date: Mon, 10 Jan 2022 18:20:52 -0600 Subject: [PATCH 076/658] mem: implement x86 locked accesses in timing-mode classic cache Add LockedRMW(Read|Write)(Req|Resp) commands. In timing mode, use a combination of clearing permission bits and leaving an MSHR in place to prevent accesses & snoops from touching a locked block between the read and write parts of an locked RMW sequence. Based on an old patch by Steve Reinhardt: http://reviews.gem5.org/r/2691/index.html Jira Issue: https://gem5.atlassian.net/browse/GEM5-1105 Change-Id: Ieadda4deb17667ca4a6282f87f6da2af3b011f66 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/52303 Reviewed-by: Nikos Nikoleris Maintainer: Nikos Nikoleris Tested-by: kokoro --- src/mem/cache/base.cc | 164 +++++++++++++++++++++++++---------- src/mem/cache/cache.cc | 58 +++++++++++-- src/mem/cache/mshr.cc | 54 +++++++++--- src/mem/cache/mshr.hh | 16 ++++ src/mem/cache/queue_entry.hh | 2 +- src/mem/packet.cc | 12 +++ src/mem/packet.hh | 11 +++ 7 files changed, 252 insertions(+), 65 deletions(-) diff --git a/src/mem/cache/base.cc b/src/mem/cache/base.cc index dc21151d93..435684a845 100644 --- a/src/mem/cache/base.cc +++ b/src/mem/cache/base.cc @@ -223,6 +223,59 @@ BaseCache::inRange(Addr addr) const void BaseCache::handleTimingReqHit(PacketPtr pkt, CacheBlk *blk, Tick request_time) { + + // handle special cases for LockedRMW transactions + if (pkt->isLockedRMW()) { + Addr blk_addr = pkt->getBlockAddr(blkSize); + + if (pkt->isRead()) { + // Read hit for LockedRMW. Since it requires exclusive + // permissions, there should be no outstanding access. + assert(!mshrQueue.findMatch(blk_addr, pkt->isSecure())); + // The keys to LockedRMW are that (1) we always have an MSHR + // allocated during the RMW interval to catch snoops and + // defer them until after the RMW completes, and (2) we + // clear permissions on the block to turn any upstream + // access other than the matching write into a miss, causing + // it to append to the MSHR as well. + + // Because we hit in the cache, we have to fake an MSHR to + // achieve part (1). If the read had missed, this MSHR + // would get allocated as part of normal miss processing. + // Basically we need to get the MSHR in the same state as if + // we had missed and just received the response. + // Request *req2 = new Request(*(pkt->req)); + RequestPtr req2 = std::make_shared(*(pkt->req)); + PacketPtr pkt2 = new Packet(req2, pkt->cmd); + MSHR *mshr = allocateMissBuffer(pkt2, curTick(), true); + // Mark the MSHR "in service" (even though it's not) to prevent + // the cache from sending out a request. + mshrQueue.markInService(mshr, false); + // Part (2): mark block inaccessible + assert(blk); + blk->clearCoherenceBits(CacheBlk::ReadableBit); + blk->clearCoherenceBits(CacheBlk::WritableBit); + } else { + assert(pkt->isWrite()); + // All LockedRMW writes come here, as they cannot miss. + // Need to undo the two things described above. Block + // permissions were already restored earlier in this + // function, prior to the access() call. Now we just need + // to clear out the MSHR. + + // Read should have already allocated MSHR. + MSHR *mshr = mshrQueue.findMatch(blk_addr, pkt->isSecure()); + assert(mshr); + // Fake up a packet and "respond" to the still-pending + // LockedRMWRead, to process any pending targets and clear + // out the MSHR + PacketPtr resp_pkt = + new Packet(pkt->req, MemCmd::LockedRMWWriteResp); + resp_pkt->senderState = mshr; + recvTimingResp(resp_pkt); + } + } + if (pkt->needsResponse()) { // These delays should have been consumed by now assert(pkt->headerDelay == 0); @@ -353,6 +406,20 @@ BaseCache::recvTimingReq(PacketPtr pkt) // the delay provided by the crossbar Tick forward_time = clockEdge(forwardLatency) + pkt->headerDelay; + if (pkt->cmd == MemCmd::LockedRMWWriteReq) { + // For LockedRMW accesses, we mark the block inaccessible after the + // read (see below), to make sure no one gets in before the write. + // Now that the write is here, mark it accessible again, so the + // write will succeed. LockedRMWReadReq brings the block in in + // exclusive mode, so we know it was previously writable. + CacheBlk *blk = tags->findBlock(pkt->getAddr(), pkt->isSecure()); + assert(blk && blk->isValid()); + assert(!blk->isSet(CacheBlk::WritableBit) && + !blk->isSet(CacheBlk::ReadableBit)); + blk->setCoherenceBits(CacheBlk::ReadableBit); + blk->setCoherenceBits(CacheBlk::WritableBit); + } + Cycles lat; CacheBlk *blk = nullptr; bool satisfied = false; @@ -438,7 +505,7 @@ BaseCache::recvTimingResp(PacketPtr pkt) // if this is a write, we should be looking at an uncacheable // write - if (pkt->isWrite()) { + if (pkt->isWrite() && pkt->cmd != MemCmd::LockedRMWWriteResp) { assert(pkt->req->isUncacheable()); handleUncacheableWriteResp(pkt); return; @@ -491,61 +558,68 @@ BaseCache::recvTimingResp(PacketPtr pkt) ppFill->notify(pkt); } - if (blk && blk->isValid() && pkt->isClean() && !pkt->isInvalidate()) { - // The block was marked not readable while there was a pending - // cache maintenance operation, restore its flag. - blk->setCoherenceBits(CacheBlk::ReadableBit); + // Don't want to promote the Locked RMW Read until + // the locked write comes in + if (!mshr->hasLockedRMWReadTarget()) { + if (blk && blk->isValid() && pkt->isClean() && !pkt->isInvalidate()) { + // The block was marked not readable while there was a pending + // cache maintenance operation, restore its flag. + blk->setCoherenceBits(CacheBlk::ReadableBit); - // This was a cache clean operation (without invalidate) - // and we have a copy of the block already. Since there - // is no invalidation, we can promote targets that don't - // require a writable copy - mshr->promoteReadable(); - } + // This was a cache clean operation (without invalidate) + // and we have a copy of the block already. Since there + // is no invalidation, we can promote targets that don't + // require a writable copy + mshr->promoteReadable(); + } - if (blk && blk->isSet(CacheBlk::WritableBit) && - !pkt->req->isCacheInvalidate()) { - // If at this point the referenced block is writable and the - // response is not a cache invalidate, we promote targets that - // were deferred as we couldn't guarrantee a writable copy - mshr->promoteWritable(); + if (blk && blk->isSet(CacheBlk::WritableBit) && + !pkt->req->isCacheInvalidate()) { + // If at this point the referenced block is writable and the + // response is not a cache invalidate, we promote targets that + // were deferred as we couldn't guarrantee a writable copy + mshr->promoteWritable(); + } } serviceMSHRTargets(mshr, pkt, blk); + // We are stopping servicing targets early for the Locked RMW Read until + // the write comes. + if (!mshr->hasLockedRMWReadTarget()) { + if (mshr->promoteDeferredTargets()) { + // avoid later read getting stale data while write miss is + // outstanding.. see comment in timingAccess() + if (blk) { + blk->clearCoherenceBits(CacheBlk::ReadableBit); + } + mshrQueue.markPending(mshr); + schedMemSideSendEvent(clockEdge() + pkt->payloadDelay); + } else { + // while we deallocate an mshr from the queue we still have to + // check the isFull condition before and after as we might + // have been using the reserved entries already + const bool was_full = mshrQueue.isFull(); + mshrQueue.deallocate(mshr); + if (was_full && !mshrQueue.isFull()) { + clearBlocked(Blocked_NoMSHRs); + } - if (mshr->promoteDeferredTargets()) { - // avoid later read getting stale data while write miss is - // outstanding.. see comment in timingAccess() - if (blk) { - blk->clearCoherenceBits(CacheBlk::ReadableBit); - } - mshrQueue.markPending(mshr); - schedMemSideSendEvent(clockEdge() + pkt->payloadDelay); - } else { - // while we deallocate an mshr from the queue we still have to - // check the isFull condition before and after as we might - // have been using the reserved entries already - const bool was_full = mshrQueue.isFull(); - mshrQueue.deallocate(mshr); - if (was_full && !mshrQueue.isFull()) { - clearBlocked(Blocked_NoMSHRs); + // Request the bus for a prefetch if this deallocation freed enough + // MSHRs for a prefetch to take place + if (prefetcher && mshrQueue.canPrefetch() && !isBlocked()) { + Tick next_pf_time = std::max( + prefetcher->nextPrefetchReadyTime(), clockEdge()); + if (next_pf_time != MaxTick) + schedMemSideSendEvent(next_pf_time); + } } - // Request the bus for a prefetch if this deallocation freed enough - // MSHRs for a prefetch to take place - if (prefetcher && mshrQueue.canPrefetch() && !isBlocked()) { - Tick next_pf_time = std::max(prefetcher->nextPrefetchReadyTime(), - clockEdge()); - if (next_pf_time != MaxTick) - schedMemSideSendEvent(next_pf_time); + // if we used temp block, check to see if its valid and then clear it + if (blk == tempBlock && tempBlock->isValid()) { + evictBlock(blk, writebacks); } } - // if we used temp block, check to see if its valid and then clear it out - if (blk == tempBlock && tempBlock->isValid()) { - evictBlock(blk, writebacks); - } - const Tick forward_time = clockEdge(forwardLatency) + pkt->headerDelay; // copy writebacks to write buffer doWritebacks(writebacks, forward_time); diff --git a/src/mem/cache/cache.cc b/src/mem/cache/cache.cc index 466aeec2b4..24b3fe7219 100644 --- a/src/mem/cache/cache.cc +++ b/src/mem/cache/cache.cc @@ -324,6 +324,9 @@ void Cache::handleTimingReqMiss(PacketPtr pkt, CacheBlk *blk, Tick forward_time, Tick request_time) { + + // These should always hit due to the earlier Locked Read + assert(pkt->cmd != MemCmd::LockedRMWWriteReq); if (pkt->req->isUncacheable()) { // ignore any existing MSHR if we are dealing with an // uncacheable request @@ -696,6 +699,21 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) bool from_core = false; bool from_pref = false; + if (pkt->cmd == MemCmd::LockedRMWWriteResp) { + // This is the fake response generated by the write half of the RMW; + // see comments in recvTimingReq(). The first target on the list + // should be the LockedRMWReadReq which has already been satisfied, + // either because it was a hit (and the MSHR was allocated in + // recvTimingReq()) or because it was left there after the inital + // response in extractServiceableTargets. In either case, we + // don't need to respond now, so pop it off to prevent the loop + // below from generating another response. + assert(initial_tgt->pkt->cmd == MemCmd::LockedRMWReadReq); + mshr->popTarget(); + delete initial_tgt->pkt; + initial_tgt = nullptr; + } + MSHR::TargetList targets = mshr->extractServiceableTargets(pkt); for (auto &target: targets) { Packet *tgt_pkt = target.pkt; @@ -786,6 +804,21 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) stats.cmdStats(tgt_pkt) .missLatency[tgt_pkt->req->requestorId()] += completion_time - target.recvTime; + + if (tgt_pkt->cmd == MemCmd::LockedRMWReadReq) { + // We're going to leave a target in the MSHR until the + // write half of the RMW occurs (see comments above in + // recvTimingReq()). Since we'll be using the current + // request packet (which has the allocated data pointer) + // to form the response, we have to allocate a new dummy + // packet to save in the MSHR target. + mshr->updateLockedRMWReadTarget(tgt_pkt); + // skip the rest of target processing after we + // send the response + // Mark block inaccessible until write arrives + blk->clearCoherenceBits(CacheBlk::WritableBit); + blk->clearCoherenceBits(CacheBlk::ReadableBit); + } } else if (pkt->cmd == MemCmd::UpgradeFailResp) { // failed StoreCond upgrade assert(tgt_pkt->cmd == MemCmd::StoreCondReq || @@ -797,6 +830,11 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) completion_time += clockEdge(responseLatency) + pkt->payloadDelay; tgt_pkt->req->setExtraData(0); + } else if (pkt->cmd == MemCmd::LockedRMWWriteResp) { + // Fake response on LockedRMW completion, see above. + // Since the data is already in the cache, we just use + // responseLatency with no extra penalties. + completion_time = clockEdge(responseLatency); } else { if (is_invalidate && blk && blk->isValid()) { // We are about to send a response to a cache above @@ -891,16 +929,18 @@ Cache::serviceMSHRTargets(MSHR *mshr, const PacketPtr pkt, CacheBlk *blk) blk->setPrefetched(); } - maintainClusivity(targets.hasFromCache, blk); + if (!mshr->hasLockedRMWReadTarget()) { + maintainClusivity(targets.hasFromCache, blk); - if (blk && blk->isValid()) { - // an invalidate response stemming from a write line request - // should not invalidate the block, so check if the - // invalidation should be discarded - if (is_invalidate || mshr->hasPostInvalidate()) { - invalidateBlock(blk); - } else if (mshr->hasPostDowngrade()) { - blk->clearCoherenceBits(CacheBlk::WritableBit); + if (blk && blk->isValid()) { + // an invalidate response stemming from a write line request + // should not invalidate the block, so check if the + // invalidation should be discarded + if (is_invalidate || mshr->hasPostInvalidate()) { + invalidateBlock(blk); + } else if (mshr->hasPostDowngrade()) { + blk->clearCoherenceBits(CacheBlk::WritableBit); + } } } } diff --git a/src/mem/cache/mshr.cc b/src/mem/cache/mshr.cc index 6aaaf9ea28..8477048eb8 100644 --- a/src/mem/cache/mshr.cc +++ b/src/mem/cache/mshr.cc @@ -137,7 +137,7 @@ MSHR::TargetList::updateWriteFlags(PacketPtr pkt) const Request::FlagsType no_merge_flags = Request::UNCACHEABLE | Request::STRICT_ORDER | Request::PRIVILEGED | Request::LLSC | Request::MEM_SWAP | - Request::MEM_SWAP_COND | Request::SECURE; + Request::MEM_SWAP_COND | Request::SECURE | Request::LOCKED_RMW; const auto &req_flags = pkt->req->getFlags(); bool compat_write = !req_flags.isSet(no_merge_flags); @@ -558,19 +558,34 @@ MSHR::extractServiceableTargets(PacketPtr pkt) assert((it->source == Target::FromCPU) || (it->source == Target::FromPrefetcher)); ready_targets.push_back(*it); - it = targets.erase(it); - while (it != targets.end()) { - if (it->source == Target::FromCPU) { - it++; - } else { - assert(it->source == Target::FromSnoop); - ready_targets.push_back(*it); - it = targets.erase(it); + // Leave the Locked RMW Read until the corresponding Locked Write + // request comes in + if (it->pkt->cmd != MemCmd::LockedRMWReadReq) { + it = targets.erase(it); + while (it != targets.end()) { + if (it->source == Target::FromCPU) { + it++; + } else { + assert(it->source == Target::FromSnoop); + ready_targets.push_back(*it); + it = targets.erase(it); + } } } ready_targets.populateFlags(); } else { - std::swap(ready_targets, targets); + auto it = targets.begin(); + while (it != targets.end()) { + ready_targets.push_back(*it); + if (it->pkt->cmd == MemCmd::LockedRMWReadReq) { + // Leave the Locked RMW Read until the corresponding Locked + // Write comes in. Also don't service any later targets as the + // line is now "locked". + break; + } + it = targets.erase(it); + } + ready_targets.populateFlags(); } targets.populateFlags(); @@ -763,4 +778,23 @@ MSHR::conflictAddr(const QueueEntry* entry) const return entry->matchBlockAddr(blkAddr, isSecure); } +void +MSHR::updateLockedRMWReadTarget(PacketPtr pkt) +{ + assert(!targets.empty() && targets.front().pkt == pkt); + RequestPtr r = std::make_shared(*(pkt->req)); + targets.front().pkt = new Packet(r, MemCmd::LockedRMWReadReq); +} + +bool +MSHR::hasLockedRMWReadTarget() +{ + if (!targets.empty() && + targets.front().pkt->cmd == MemCmd::LockedRMWReadReq) { + return true; + } + return false; +} + + } // namespace gem5 diff --git a/src/mem/cache/mshr.hh b/src/mem/cache/mshr.hh index a9deec66bf..4d5c3b6a2c 100644 --- a/src/mem/cache/mshr.hh +++ b/src/mem/cache/mshr.hh @@ -350,6 +350,22 @@ class MSHR : public QueueEntry, public Printable return targets.hasFromCache; } + /** + * Replaces the matching packet in the Targets list with a dummy packet to + * ensure the MSHR remains allocated until the corresponding locked write + * arrives. + * + * @param pkt The LockedRMWRead packet to be updated + */ + void updateLockedRMWReadTarget(PacketPtr pkt); + + /** + * Determine if there are any LockedRMWReads in the Targets list + * + * @return true if Targets list contains a LockedRMWRead + */ + bool hasLockedRMWReadTarget(); + private: /** * Promotes deferred targets that satisfy a predicate diff --git a/src/mem/cache/queue_entry.hh b/src/mem/cache/queue_entry.hh index d8913652ed..55c1928370 100644 --- a/src/mem/cache/queue_entry.hh +++ b/src/mem/cache/queue_entry.hh @@ -90,7 +90,7 @@ class QueueEntry : public Packet::SenderState, public Named const Tick recvTime; //!< Time when request was received (for stats) const Tick readyTime; //!< Time when request is ready to be serviced const Counter order; //!< Global order (for memory consistency mgmt) - const PacketPtr pkt; //!< Pending request packet. + PacketPtr pkt; //!< Pending request packet. /** * Default constructor. Assigns the current tick as the arrival time diff --git a/src/mem/packet.cc b/src/mem/packet.cc index 219bc76ae0..5b23f136d9 100644 --- a/src/mem/packet.cc +++ b/src/mem/packet.cc @@ -164,6 +164,18 @@ MemCmd::commandInfo[] = /* StoreCondResp */ { {IsWrite, IsLlsc, IsResponse}, InvalidCmd, "StoreCondResp" }, + /* LockedRMWReadReq */ + { {IsRead, IsLockedRMW, NeedsWritable, IsRequest, NeedsResponse}, + LockedRMWReadResp, "LockedRMWReadReq" }, + /* LockedRMWReadResp */ + { {IsRead, IsLockedRMW, NeedsWritable, IsResponse, HasData}, + InvalidCmd, "LockedRMWReadResp" }, + /* LockedRMWWriteReq */ + { {IsWrite, IsLockedRMW, NeedsWritable, IsRequest, NeedsResponse, + HasData}, LockedRMWWriteResp, "LockedRMWWriteReq" }, + /* LockedRMWWriteResp */ + { {IsWrite, IsLockedRMW, NeedsWritable, IsResponse}, + InvalidCmd, "LockedRMWWriteResp" }, /* SwapReq -- for Swap ldstub type operations */ { {IsRead, IsWrite, NeedsWritable, IsRequest, HasData, NeedsResponse}, SwapResp, "SwapReq" }, diff --git a/src/mem/packet.hh b/src/mem/packet.hh index 88995f17c4..d42ea27846 100644 --- a/src/mem/packet.hh +++ b/src/mem/packet.hh @@ -112,6 +112,10 @@ class MemCmd StoreCondReq, StoreCondFailReq, // Failed StoreCondReq in MSHR (never sent) StoreCondResp, + LockedRMWReadReq, + LockedRMWReadResp, + LockedRMWWriteReq, + LockedRMWWriteResp, SwapReq, SwapResp, // MessageReq and MessageResp are deprecated. @@ -162,6 +166,7 @@ class MemCmd IsSWPrefetch, IsHWPrefetch, IsLlsc, //!< Alpha/MIPS LL or SC access + IsLockedRMW, //!< x86 locked RMW access HasData, //!< There is an associated payload IsError, //!< Error response IsPrint, //!< Print state matching address (for debugging) @@ -239,6 +244,7 @@ class MemCmd */ bool hasData() const { return testCmdAttrib(HasData); } bool isLLSC() const { return testCmdAttrib(IsLlsc); } + bool isLockedRMW() const { return testCmdAttrib(IsLockedRMW); } bool isSWPrefetch() const { return testCmdAttrib(IsSWPrefetch); } bool isHWPrefetch() const { return testCmdAttrib(IsHWPrefetch); } bool isPrefetch() const { return testCmdAttrib(IsSWPrefetch) || @@ -607,6 +613,7 @@ class Packet : public Printable return resp_cmd.hasData(); } bool isLLSC() const { return cmd.isLLSC(); } + bool isLockedRMW() const { return cmd.isLockedRMW(); } bool isError() const { return cmd.isError(); } bool isPrint() const { return cmd.isPrint(); } bool isFlush() const { return cmd.isFlush(); } @@ -976,6 +983,8 @@ class Packet : public Printable return MemCmd::SoftPFExReq; else if (req->isPrefetch()) return MemCmd::SoftPFReq; + else if (req->isLockedRMW()) + return MemCmd::LockedRMWReadReq; else return MemCmd::ReadReq; } @@ -995,6 +1004,8 @@ class Packet : public Printable MemCmd::InvalidateReq; } else if (req->isCacheClean()) { return MemCmd::CleanSharedReq; + } else if (req->isLockedRMW()) { + return MemCmd::LockedRMWWriteReq; } else return MemCmd::WriteReq; } From 0cb64ce9f02d58525a8db81c9cf9a0eda3e62f10 Mon Sep 17 00:00:00 2001 From: Matthew Poremba Date: Tue, 11 Jan 2022 11:14:12 -0600 Subject: [PATCH 077/658] arch-vega: Free dest registers in non-memory Load DS insts Ported from https://gem5-review.googlesource.com/c/public/gem5/+/48019: Certain DS insts are classfied as Loads, but don't actually go through the memory pipeline. However, any instruction classified as a load marks its destination registers as free in the memory pipeline. Because these instructions didn't use the memory pipeline, they never freed their destination registers, which led to a deadlock. This patch explicitly calls the function used to free the destination registers in the execute() method of those Load instructions that don't use the memory pipeline. Change-Id: I8231217a79661ca6acc837b2ab4931b946049a1a Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55463 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/amdgpu/vega/insts/instructions.cc | 27 ++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/src/arch/amdgpu/vega/insts/instructions.cc b/src/arch/amdgpu/vega/insts/instructions.cc index 7d5562451f..bd7ef7051e 100644 --- a/src/arch/amdgpu/vega/insts/instructions.cc +++ b/src/arch/amdgpu/vega/insts/instructions.cc @@ -35467,6 +35467,15 @@ namespace VegaISA } vdst.write(); + + /** + * This is needed because we treat this instruction as a load + * but it's not an actual memory request. + * Without this, the destination register never gets marked as + * free, leading to a possible deadlock + */ + wf->computeUnit->vrf[wf->simdId]-> + scheduleWriteOperandsFromLoad(wf, gpuDynInst); } // execute // --- Inst_DS__DS_PERMUTE_B32 class methods --- @@ -35541,6 +35550,15 @@ namespace VegaISA } vdst.write(); + + /** + * This is needed because we treat this instruction as a load + * but it's not an actual memory request. + * Without this, the destination register never gets marked as + * free, leading to a possible deadlock + */ + wf->computeUnit->vrf[wf->simdId]-> + scheduleWriteOperandsFromLoad(wf, gpuDynInst); } // execute // --- Inst_DS__DS_BPERMUTE_B32 class methods --- @@ -35615,6 +35633,15 @@ namespace VegaISA } vdst.write(); + + /** + * This is needed because we treat this instruction as a load + * but it's not an actual memory request. + * Without this, the destination register never gets marked as + * free, leading to a possible deadlock + */ + wf->computeUnit->vrf[wf->simdId]-> + scheduleWriteOperandsFromLoad(wf, gpuDynInst); } // execute // --- Inst_DS__DS_ADD_U64 class methods --- From ff17ecc17722eb108132fbb574c1f768afaf4848 Mon Sep 17 00:00:00 2001 From: Matthew Poremba Date: Tue, 11 Jan 2022 11:16:02 -0600 Subject: [PATCH 078/658] arch-vega: Fix MUBUF out-of-bounds case 1 Ported from https://gem5-review.googlesource.com/c/public/gem5/+/51127: This patch updates the out-of-bounds check to properly check against the correct buffer_offset, which is different depending on if the const_swizzle_enable is true or false. Change-Id: I9757226e62c587b679cab2a42f3616a5dca97e60 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55464 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/amdgpu/vega/insts/op_encodings.hh | 81 +++++++++++----------- 1 file changed, 42 insertions(+), 39 deletions(-) diff --git a/src/arch/amdgpu/vega/insts/op_encodings.hh b/src/arch/amdgpu/vega/insts/op_encodings.hh index bb45b749fe..da16dbdb4b 100644 --- a/src/arch/amdgpu/vega/insts/op_encodings.hh +++ b/src/arch/amdgpu/vega/insts/op_encodings.hh @@ -632,6 +632,7 @@ namespace VegaISA Addr stride = 0; Addr buf_idx = 0; Addr buf_off = 0; + Addr buffer_offset = 0; BufferRsrcDescriptor rsrc_desc; std::memcpy((void*)&rsrc_desc, s_rsrc_desc.rawDataPtr(), @@ -654,42 +655,6 @@ namespace VegaISA buf_off = v_off[lane] + inst_offset; - - /** - * Range check behavior causes out of range accesses to - * to be treated differently. Out of range accesses return - * 0 for loads and are ignored for stores. For - * non-formatted accesses, this is done on a per-lane - * basis. - */ - if (stride == 0 || !rsrc_desc.swizzleEn) { - if (buf_off + stride * buf_idx >= - rsrc_desc.numRecords - s_offset.rawData()) { - DPRINTF(VEGA, "mubuf out-of-bounds condition 1: " - "lane = %d, buffer_offset = %llx, " - "const_stride = %llx, " - "const_num_records = %llx\n", - lane, buf_off + stride * buf_idx, - stride, rsrc_desc.numRecords); - oobMask.set(lane); - continue; - } - } - - if (stride != 0 && rsrc_desc.swizzleEn) { - if (buf_idx >= rsrc_desc.numRecords || - buf_off >= stride) { - DPRINTF(VEGA, "mubuf out-of-bounds condition 2: " - "lane = %d, offset = %llx, " - "index = %llx, " - "const_num_records = %llx\n", - lane, buf_off, buf_idx, - rsrc_desc.numRecords); - oobMask.set(lane); - continue; - } - } - if (rsrc_desc.swizzleEn) { Addr idx_stride = 8 << rsrc_desc.idxStride; Addr elem_size = 2 << rsrc_desc.elemSize; @@ -704,12 +669,50 @@ namespace VegaISA lane, idx_stride, elem_size, idx_msb, idx_lsb, off_msb, off_lsb); - vaddr += ((idx_msb * stride + off_msb * elem_size) - * idx_stride + idx_lsb * elem_size + off_lsb); + buffer_offset =(idx_msb * stride + off_msb * elem_size) + * idx_stride + idx_lsb * elem_size + off_lsb; } else { - vaddr += buf_off + stride * buf_idx; + buffer_offset = buf_off + stride * buf_idx; } + + /** + * Range check behavior causes out of range accesses to + * to be treated differently. Out of range accesses return + * 0 for loads and are ignored for stores. For + * non-formatted accesses, this is done on a per-lane + * basis. + */ + if (rsrc_desc.stride == 0 || !rsrc_desc.swizzleEn) { + if (buffer_offset >= + rsrc_desc.numRecords - s_offset.rawData()) { + DPRINTF(VEGA, "mubuf out-of-bounds condition 1: " + "lane = %d, buffer_offset = %llx, " + "const_stride = %llx, " + "const_num_records = %llx\n", + lane, buf_off + stride * buf_idx, + stride, rsrc_desc.numRecords); + oobMask.set(lane); + continue; + } + } + + if (rsrc_desc.stride != 0 && rsrc_desc.swizzleEn) { + if (buf_idx >= rsrc_desc.numRecords || + buf_off >= stride) { + DPRINTF(VEGA, "mubuf out-of-bounds condition 2: " + "lane = %d, offset = %llx, " + "index = %llx, " + "const_num_records = %llx\n", + lane, buf_off, buf_idx, + rsrc_desc.numRecords); + oobMask.set(lane); + continue; + } + } + + vaddr += buffer_offset; + DPRINTF(VEGA, "Calculating mubuf address for lane %d: " "vaddr = %llx, base_addr = %llx, " "stride = %llx, buf_idx = %llx, buf_off = %llx\n", From 3ecd28a222d8548579220980a725e1f94c8fd915 Mon Sep 17 00:00:00 2001 From: Matthew Poremba Date: Wed, 12 Jan 2022 15:52:56 -0600 Subject: [PATCH 079/658] arch-vega: Update FLAT memory access helpers to support LDS This patch ports the changes from a similar patch for arch-gcn3: https://gem5-review.googlesource.com/c/public/gem5/+/48343. Vega already has an helper function to send to the correct pipe depending on the scope, however the initMem helpers currently always assume global scope. In addition the MUBUF WBINVL1 instructions are updated similarly to the GCN3 patch. Change-Id: I612b9198cb56e226721a90e72bba64395c84ebcd Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55465 Reviewed-by: Matt Sinclair Maintainer: Matt Sinclair Tested-by: kokoro --- src/arch/amdgpu/vega/insts/instructions.cc | 16 ++++- src/arch/amdgpu/vega/insts/op_encodings.hh | 82 ++++++++++++++++++++-- 2 files changed, 91 insertions(+), 7 deletions(-) diff --git a/src/arch/amdgpu/vega/insts/instructions.cc b/src/arch/amdgpu/vega/insts/instructions.cc index bd7ef7051e..32d048e327 100644 --- a/src/arch/amdgpu/vega/insts/instructions.cc +++ b/src/arch/amdgpu/vega/insts/instructions.cc @@ -39848,7 +39848,13 @@ namespace VegaISA gpuDynInst->execUnitId = wf->execUnitId; gpuDynInst->latency.init(gpuDynInst->computeUnit()); gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod()); - gpuDynInst->computeUnit()->globalMemoryPipe.issueRequest(gpuDynInst); + + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + gpuDynInst->computeUnit()->globalMemoryPipe. + issueRequest(gpuDynInst); + } else { + fatal("Unsupported scope for flat instruction.\n"); + } } // execute void @@ -39901,7 +39907,13 @@ namespace VegaISA gpuDynInst->execUnitId = wf->execUnitId; gpuDynInst->latency.init(gpuDynInst->computeUnit()); gpuDynInst->latency.set(gpuDynInst->computeUnit()->clockPeriod()); - gpuDynInst->computeUnit()->globalMemoryPipe.issueRequest(gpuDynInst); + + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + gpuDynInst->computeUnit()->globalMemoryPipe. + issueRequest(gpuDynInst); + } else { + fatal("Unsupported scope for flat instruction.\n"); + } } // execute void Inst_MUBUF__BUFFER_WBINVL1_VOL::initiateAcc(GPUDynInstPtr gpuDynInst) diff --git a/src/arch/amdgpu/vega/insts/op_encodings.hh b/src/arch/amdgpu/vega/insts/op_encodings.hh index da16dbdb4b..a6dc58c0d0 100644 --- a/src/arch/amdgpu/vega/insts/op_encodings.hh +++ b/src/arch/amdgpu/vega/insts/op_encodings.hh @@ -800,35 +800,107 @@ namespace VegaISA void initMemRead(GPUDynInstPtr gpuDynInst) { - initMemReqHelper(gpuDynInst, MemCmd::ReadReq); + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + initMemReqHelper(gpuDynInst, MemCmd::ReadReq); + } else if (gpuDynInst->executedAs() == enums::SC_GROUP) { + Wavefront *wf = gpuDynInst->wavefront(); + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane]; + (reinterpret_cast(gpuDynInst->d_data))[lane] + = wf->ldsChunk->read(vaddr); + } + } + } } template void initMemRead(GPUDynInstPtr gpuDynInst) { - initMemReqHelper(gpuDynInst, MemCmd::ReadReq); + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + initMemReqHelper(gpuDynInst, MemCmd::ReadReq); + } else if (gpuDynInst->executedAs() == enums::SC_GROUP) { + Wavefront *wf = gpuDynInst->wavefront(); + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane]; + for (int i = 0; i < N; ++i) { + (reinterpret_cast( + gpuDynInst->d_data))[lane * N + i] + = wf->ldsChunk->read( + vaddr + i*sizeof(VecElemU32)); + } + } + } + } } template void initMemWrite(GPUDynInstPtr gpuDynInst) { - initMemReqHelper(gpuDynInst, MemCmd::WriteReq); + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + initMemReqHelper(gpuDynInst, MemCmd::WriteReq); + } else if (gpuDynInst->executedAs() == enums::SC_GROUP) { + Wavefront *wf = gpuDynInst->wavefront(); + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane]; + wf->ldsChunk->write(vaddr, + (reinterpret_cast(gpuDynInst->d_data))[lane]); + } + } + } } template void initMemWrite(GPUDynInstPtr gpuDynInst) { - initMemReqHelper(gpuDynInst, MemCmd::WriteReq); + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + initMemReqHelper(gpuDynInst, MemCmd::WriteReq); + } else if (gpuDynInst->executedAs() == enums::SC_GROUP) { + Wavefront *wf = gpuDynInst->wavefront(); + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane]; + for (int i = 0; i < N; ++i) { + wf->ldsChunk->write( + vaddr + i*sizeof(VecElemU32), + (reinterpret_cast( + gpuDynInst->d_data))[lane * N + i]); + } + } + } + } } template void initAtomicAccess(GPUDynInstPtr gpuDynInst) { - initMemReqHelper(gpuDynInst, MemCmd::SwapReq, true); + if (gpuDynInst->executedAs() == enums::SC_GLOBAL) { + initMemReqHelper(gpuDynInst, MemCmd::SwapReq, true); + } else if (gpuDynInst->executedAs() == enums::SC_GROUP) { + Wavefront *wf = gpuDynInst->wavefront(); + for (int lane = 0; lane < NumVecElemPerVecReg; ++lane) { + if (gpuDynInst->exec_mask[lane]) { + Addr vaddr = gpuDynInst->addr[lane]; + auto amo_op = + gpuDynInst->makeAtomicOpFunctor( + &(reinterpret_cast( + gpuDynInst->a_data))[lane], + &(reinterpret_cast( + gpuDynInst->x_data))[lane]); + + T tmp = wf->ldsChunk->read(vaddr); + (*amo_op)(reinterpret_cast(&tmp)); + wf->ldsChunk->write(vaddr, tmp); + (reinterpret_cast(gpuDynInst->d_data))[lane] = tmp; + } + } + } } void From 52661838a4ed50532ebd805e894cfa7c6157b04b Mon Sep 17 00:00:00 2001 From: Yu-hsin Wang Date: Tue, 11 Jan 2022 17:25:02 +0800 Subject: [PATCH 080/658] ext: upgrade to googletest 1.11.x Upgrade googletest to 1.11.x upstream commit: 8306020a3e9eceafec65508868d7ab5c63bb41f7 sha1sum df8cdd26ee7cdf2a3d9c05a92d3630a96f406422 generated by command: find . -type f ! -name SConscript ! -path "./.*" -print0 \ | sort -z | xargs -0 sha1sum | sha1sum This upgrade is mainly for providing ConditionalMatcher support. Change-Id: I27d971c02c59a3ad42c3002f1b4e1a8b18269c56 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/55384 Maintainer: Gabe Black Tested-by: kokoro Reviewed-by: Jason Lowe-Power Reviewed-by: Giacomo Travaglini Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce --- ext/googletest/BUILD.bazel | 20 +- ext/googletest/CMakeLists.txt | 12 +- ext/googletest/CONTRIBUTING.md | 18 +- ext/googletest/{googletest => }/CONTRIBUTORS | 27 + ext/googletest/README.md | 138 +- ext/googletest/WORKSPACE | 23 +- ext/googletest/appveyor.yml | 154 - ext/googletest/ci/build-linux-bazel.sh | 37 - ext/googletest/ci/build-platformio.sh | 2 - ext/googletest/ci/env-linux.sh | 41 - ext/googletest/ci/install-linux.sh | 49 - ext/googletest/ci/install-osx.sh | 40 - ext/googletest/ci/install-platformio.sh | 5 - ext/googletest/ci/linux-presubmit.sh | 126 + ...{get-nprocessors.sh => macos-presubmit.sh} | 59 +- ext/googletest/ci/travis.sh | 44 - ext/googletest/docs/_config.yml | 1 + ext/googletest/docs/_data/navigation.yml | 43 + ext/googletest/docs/_layouts/default.html | 58 + ext/googletest/docs/_sass/main.scss | 200 + .../{googletest => }/docs/advanced.md | 865 ++--- ext/googletest/docs/assets/css/style.scss | 5 + .../docs/community_created_documentation.md | 7 + ext/googletest/{googletest => }/docs/faq.md | 170 +- ext/googletest/docs/gmock_cheat_sheet.md | 241 ++ .../cook_book.md => docs/gmock_cook_book.md} | 673 ++-- .../{googlemock => }/docs/gmock_faq.md | 16 +- .../gmock_for_dummies.md} | 96 +- ext/googletest/docs/index.md | 22 + .../{googletest => }/docs/pkgconfig.md | 149 +- ext/googletest/docs/platforms.md | 35 + .../{googletest => }/docs/primer.md | 149 +- ext/googletest/docs/quickstart-bazel.md | 161 + ext/googletest/docs/quickstart-cmake.md | 156 + ext/googletest/docs/reference/actions.md | 115 + ext/googletest/docs/reference/assertions.md | 633 ++++ ext/googletest/docs/reference/matchers.md | 285 ++ ext/googletest/docs/reference/mocking.md | 587 +++ ext/googletest/docs/reference/testing.md | 1431 +++++++ .../{googletest => }/docs/samples.md | 2 +- ext/googletest/googlemock/CMakeLists.txt | 21 +- ext/googletest/googlemock/CONTRIBUTORS | 40 - ext/googletest/googlemock/LICENSE | 28 - ext/googletest/googlemock/README.md | 50 +- ext/googletest/googlemock/cmake/gmock.pc.in | 9 +- .../googlemock/cmake/gmock_main.pc.in | 9 +- ext/googletest/googlemock/docs/README.md | 4 + ext/googletest/googlemock/docs/cheat_sheet.md | 781 ---- .../googlemock/include/gmock/gmock-actions.h | 639 +++- .../include/gmock/gmock-cardinalities.h | 6 +- .../include/gmock/gmock-function-mocker.h | 318 +- .../include/gmock/gmock-generated-actions.h | 1884 ---------- .../gmock/gmock-generated-actions.h.pump | 627 ---- .../gmock/gmock-generated-function-mockers.h | 752 ---- .../gmock-generated-function-mockers.h.pump | 227 -- .../include/gmock/gmock-generated-matchers.h | 1097 ------ .../gmock/gmock-generated-matchers.h.pump | 346 -- .../googlemock/include/gmock/gmock-matchers.h | 1496 ++++++-- .../include/gmock/gmock-more-actions.h | 615 ++- .../include/gmock/gmock-more-matchers.h | 10 +- .../include/gmock/gmock-nice-strict.h | 196 +- .../include/gmock/gmock-spec-builders.h | 177 +- .../googlemock/include/gmock/gmock.h | 9 +- .../internal/custom/gmock-generated-actions.h | 10 +- .../custom/gmock-generated-actions.h.pump | 12 - .../gmock/internal/custom/gmock-matchers.h | 6 +- .../gmock/internal/custom/gmock-port.h | 6 +- .../gmock/internal/gmock-internal-utils.h | 136 +- .../include/gmock/internal/gmock-port.h | 12 +- .../include/gmock/internal/gmock-pp.h | 122 +- ext/googletest/googlemock/scripts/README.md | 5 + .../googlemock/scripts/fuse_gmock_files.py | 126 +- .../googlemock/scripts/generator/cpp/ast.py | 2913 ++++++++------- .../scripts/generator/cpp/gmock_class.py | 154 +- .../scripts/generator/cpp/gmock_class_test.py | 246 +- .../scripts/generator/cpp/keywords.py | 3 - .../scripts/generator/cpp/tokenize.py | 3 - .../googlemock/scripts/generator/cpp/utils.py | 4 - .../googlemock/scripts/generator/gmock_gen.py | 1 - .../googlemock/scripts/gmock-config.in | 303 -- .../googlemock/scripts/gmock_doctor.py | 640 ---- ext/googletest/googlemock/scripts/upload.py | 1387 ------- .../googlemock/scripts/upload_gmock.py | 78 - .../googlemock/src/gmock-matchers.cc | 3 - .../googlemock/src/gmock-spec-builders.cc | 68 +- ext/googletest/googlemock/src/gmock.cc | 2 +- ext/googletest/googlemock/src/gmock_main.cc | 9 +- ext/googletest/googlemock/test/BUILD.bazel | 15 +- .../googlemock/test/gmock-actions_test.cc | 218 +- .../test/gmock-function-mocker_nc.cc | 16 - .../test/gmock-function-mocker_nc_test.py | 43 - .../test/gmock-function-mocker_test.cc | 518 ++- .../test/gmock-generated-actions_test.cc | 1064 ------ .../gmock-generated-function-mockers_test.cc | 659 ---- .../test/gmock-generated-matchers_test.cc | 1324 ------- .../test/gmock-internal-utils_test.cc | 36 +- .../googlemock/test/gmock-matchers_test.cc | 2168 ++++++++++- .../test/gmock-more-actions_test.cc | 945 ++++- .../googlemock/test/gmock-nice-strict_test.cc | 39 + .../googlemock/test/gmock-pp_test.cc | 10 + .../test/gmock-spec-builders_test.cc | 6 +- .../googlemock/test/gmock_all_test.cc | 3 - .../googlemock/test/gmock_link_test.h | 6 +- .../test/gmock_output_test_golden.txt | 10 +- ext/googletest/googletest/CMakeLists.txt | 27 +- ext/googletest/googletest/LICENSE | 28 - ext/googletest/googletest/README.md | 173 +- ext/googletest/googletest/cmake/gtest.pc.in | 7 +- .../googletest/cmake/gtest_main.pc.in | 9 +- .../googletest/cmake/internal_utils.cmake | 66 +- ext/googletest/googletest/docs/README.md | 4 + ext/googletest/googletest/docs/pump_manual.md | 190 - .../include/gtest/gtest-death-test.h | 49 +- .../googletest/include/gtest/gtest-matchers.h | 414 ++- .../googletest/include/gtest/gtest-message.h | 7 +- .../include/gtest/gtest-param-test.h | 30 +- .../googletest/include/gtest/gtest-printers.h | 669 ++-- .../googletest/include/gtest/gtest-spi.h | 6 +- .../include/gtest/gtest-test-part.h | 6 +- .../include/gtest/gtest-typed-test.h | 69 +- .../googletest/include/gtest/gtest.h | 142 +- .../include/gtest/gtest_pred_impl.h | 6 +- .../googletest/include/gtest/gtest_prod.h | 6 +- .../include/gtest/internal/custom/README.md | 2 + .../gtest/internal/custom/gtest-port.h | 6 +- .../gtest/internal/custom/gtest-printers.h | 6 +- .../include/gtest/internal/custom/gtest.h | 6 +- .../internal/gtest-death-test-internal.h | 12 +- .../include/gtest/internal/gtest-filepath.h | 8 +- .../include/gtest/internal/gtest-internal.h | 382 +- .../include/gtest/internal/gtest-param-util.h | 94 +- .../include/gtest/internal/gtest-port-arch.h | 15 +- .../include/gtest/internal/gtest-port.h | 379 +- .../include/gtest/internal/gtest-string.h | 12 +- .../include/gtest/internal/gtest-type-util.h | 3294 +---------------- .../gtest/internal/gtest-type-util.h.pump | 302 -- .../googletest/samples/prime_tables.h | 12 +- ext/googletest/googletest/samples/sample1.h | 6 +- ext/googletest/googletest/samples/sample2.h | 7 +- .../googletest/samples/sample3-inl.h | 6 +- ext/googletest/googletest/samples/sample4.h | 6 +- .../googletest/samples/sample6_unittest.cc | 7 - ext/googletest/googletest/scripts/README.md | 5 + .../googletest/scripts/gen_gtest_pred_impl.py | 39 +- ext/googletest/googletest/scripts/pump.py | 855 ----- .../googletest/scripts/release_docs.py | 2 +- .../googletest/scripts/run_with_path.py | 32 + ext/googletest/googletest/scripts/upload.py | 35 +- .../googletest/src/gtest-death-test.cc | 148 +- .../googletest/src/gtest-filepath.cc | 44 +- .../googletest/src/gtest-internal-inl.h | 185 +- .../googletest/src/gtest-matchers.cc | 28 +- ext/googletest/googletest/src/gtest-port.cc | 74 +- .../googletest/src/gtest-printers.cc | 199 +- .../googletest/src/gtest-test-part.cc | 6 +- .../googletest/src/gtest-typed-test.cc | 21 +- ext/googletest/googletest/src/gtest.cc | 1466 +++++--- ext/googletest/googletest/src/gtest_main.cc | 9 +- ext/googletest/googletest/test/BUILD.bazel | 76 +- .../test/googletest-death-test-test.cc | 90 +- .../test/googletest-death-test_ex_test.cc | 8 +- .../test/googletest-env-var-test.py | 3 + .../test/googletest-env-var-test_.cc | 32 +- .../test/googletest-failfast-unittest.py | 410 ++ .../test/googletest-failfast-unittest_.cc | 167 + .../googletest-global-environment-unittest.py | 128 + ...googletest-global-environment-unittest_.cc | 58 + .../test/googletest-json-output-unittest.py | 104 +- .../test/googletest-listener-test.cc | 2 +- .../test/googletest-options-test.cc | 27 +- .../googletest-output-test-golden-lin.txt | 48 +- .../googletest/test/googletest-output-test.py | 4 +- .../test/googletest-output-test_.cc | 103 +- .../test/googletest-param-test-test.cc | 76 +- .../test/googletest-param-test-test.h | 6 +- .../googletest/test/googletest-port-test.cc | 99 +- .../test/googletest-printers-test.cc | 414 ++- .../test/googletest-setuptestsuite-test.py} | 39 +- ....cc => googletest-setuptestsuite-test_.cc} | 40 +- .../test/googletest-shuffle-test_.cc | 2 +- .../googletest/test/gtest-typed-test2_test.cc | 4 - .../googletest/test/gtest-typed-test_test.cc | 45 +- .../googletest/test/gtest-typed-test_test.h | 11 +- .../test/gtest-unittest-api_test.cc | 30 +- .../googletest/test/gtest_environment_test.cc | 6 +- .../googletest/test/gtest_help_test.py | 5 +- .../test/gtest_list_output_unittest.py | 155 +- .../test/gtest_list_output_unittest_.cc | 26 + .../test/gtest_pred_impl_unittest.cc | 27 +- .../googletest/test/gtest_repeat_test.cc | 30 +- .../test/gtest_skip_check_output_test.py} | 46 +- .../googletest/test/gtest_skip_test.cc | 2 +- .../googletest/test/gtest_test_utils.py | 4 +- .../test/gtest_throw_on_failure_ex_test.cc | 2 +- .../googletest/test/gtest_unittest.cc | 831 +++-- .../test/gtest_xml_outfiles_test.py | 4 +- .../test/gtest_xml_output_unittest.py | 84 +- .../test/gtest_xml_output_unittest_.cc | 13 +- .../googletest/test/gtest_xml_test_utils.py | 9 +- ext/googletest/googletest/test/production.h | 6 +- ext/googletest/library.json | 59 - ext/googletest/platformio.ini | 31 - src/mem/translation_gen.test.cc | 5 +- 203 files changed, 19458 insertions(+), 23096 deletions(-) rename ext/googletest/{googletest => }/CONTRIBUTORS (61%) delete mode 100644 ext/googletest/appveyor.yml delete mode 100755 ext/googletest/ci/build-linux-bazel.sh delete mode 100644 ext/googletest/ci/build-platformio.sh delete mode 100755 ext/googletest/ci/env-linux.sh delete mode 100755 ext/googletest/ci/install-linux.sh delete mode 100755 ext/googletest/ci/install-osx.sh delete mode 100644 ext/googletest/ci/install-platformio.sh create mode 100644 ext/googletest/ci/linux-presubmit.sh rename ext/googletest/ci/{get-nprocessors.sh => macos-presubmit.sh} (57%) mode change 100755 => 100644 delete mode 100755 ext/googletest/ci/travis.sh create mode 100644 ext/googletest/docs/_config.yml create mode 100644 ext/googletest/docs/_data/navigation.yml create mode 100644 ext/googletest/docs/_layouts/default.html create mode 100644 ext/googletest/docs/_sass/main.scss rename ext/googletest/{googletest => }/docs/advanced.md (72%) create mode 100644 ext/googletest/docs/assets/css/style.scss create mode 100644 ext/googletest/docs/community_created_documentation.md rename ext/googletest/{googletest => }/docs/faq.md (85%) create mode 100644 ext/googletest/docs/gmock_cheat_sheet.md rename ext/googletest/{googlemock/docs/cook_book.md => docs/gmock_cook_book.md} (89%) rename ext/googletest/{googlemock => }/docs/gmock_faq.md (97%) rename ext/googletest/{googlemock/docs/for_dummies.md => docs/gmock_for_dummies.md} (92%) create mode 100644 ext/googletest/docs/index.md rename ext/googletest/{googletest => }/docs/pkgconfig.md (52%) create mode 100644 ext/googletest/docs/platforms.md rename ext/googletest/{googletest => }/docs/primer.md (73%) create mode 100644 ext/googletest/docs/quickstart-bazel.md create mode 100644 ext/googletest/docs/quickstart-cmake.md create mode 100644 ext/googletest/docs/reference/actions.md create mode 100644 ext/googletest/docs/reference/assertions.md create mode 100644 ext/googletest/docs/reference/matchers.md create mode 100644 ext/googletest/docs/reference/mocking.md create mode 100644 ext/googletest/docs/reference/testing.md rename ext/googletest/{googletest => }/docs/samples.md (97%) delete mode 100644 ext/googletest/googlemock/CONTRIBUTORS delete mode 100644 ext/googletest/googlemock/LICENSE create mode 100644 ext/googletest/googlemock/docs/README.md delete mode 100644 ext/googletest/googlemock/docs/cheat_sheet.md delete mode 100644 ext/googletest/googlemock/include/gmock/gmock-generated-actions.h delete mode 100644 ext/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump delete mode 100644 ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h delete mode 100644 ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump delete mode 100644 ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h delete mode 100644 ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump delete mode 100644 ext/googletest/googlemock/include/gmock/internal/custom/gmock-generated-actions.h.pump create mode 100644 ext/googletest/googlemock/scripts/README.md delete mode 100755 ext/googletest/googlemock/scripts/gmock-config.in delete mode 100755 ext/googletest/googlemock/scripts/gmock_doctor.py delete mode 100755 ext/googletest/googlemock/scripts/upload.py delete mode 100755 ext/googletest/googlemock/scripts/upload_gmock.py delete mode 100644 ext/googletest/googlemock/test/gmock-function-mocker_nc.cc delete mode 100644 ext/googletest/googlemock/test/gmock-function-mocker_nc_test.py delete mode 100644 ext/googletest/googlemock/test/gmock-generated-actions_test.cc delete mode 100644 ext/googletest/googlemock/test/gmock-generated-function-mockers_test.cc delete mode 100644 ext/googletest/googlemock/test/gmock-generated-matchers_test.cc delete mode 100644 ext/googletest/googletest/LICENSE create mode 100644 ext/googletest/googletest/docs/README.md delete mode 100644 ext/googletest/googletest/docs/pump_manual.md delete mode 100644 ext/googletest/googletest/include/gtest/internal/gtest-type-util.h.pump create mode 100644 ext/googletest/googletest/scripts/README.md delete mode 100755 ext/googletest/googletest/scripts/pump.py create mode 100755 ext/googletest/googletest/scripts/run_with_path.py create mode 100755 ext/googletest/googletest/test/googletest-failfast-unittest.py create mode 100644 ext/googletest/googletest/test/googletest-failfast-unittest_.cc create mode 100644 ext/googletest/googletest/test/googletest-global-environment-unittest.py create mode 100644 ext/googletest/googletest/test/googletest-global-environment-unittest_.cc rename ext/googletest/{ci/log-config.sh => googletest/test/googletest-setuptestsuite-test.py} (66%) rename ext/googletest/googletest/test/{googletest-test2_test.cc => googletest-setuptestsuite-test_.cc} (56%) rename ext/googletest/{ci/env-osx.sh => googletest/test/gtest_skip_check_output_test.py} (61%) delete mode 100644 ext/googletest/library.json delete mode 100644 ext/googletest/platformio.ini diff --git a/ext/googletest/BUILD.bazel b/ext/googletest/BUILD.bazel index 9b48aee530..3c9a228f42 100644 --- a/ext/googletest/BUILD.bazel +++ b/ext/googletest/BUILD.bazel @@ -36,9 +36,24 @@ package(default_visibility = ["//visibility:public"]) licenses(["notice"]) +exports_files(["LICENSE"]) + +config_setting( + name = "qnx", + constraint_values = ["@platforms//os:qnx"], +) + config_setting( name = "windows", - constraint_values = ["@bazel_tools//platforms:windows"], + constraint_values = ["@platforms//os:windows"], +) + +config_setting( + name = "msvc_compiler", + flag_values = { + "@bazel_tools//tools/cpp:compiler": "msvc-cl", + }, + visibility = [":__subpackages__"], ) config_setting( @@ -76,6 +91,7 @@ cc_library( "googlemock/include/gmock/*.h", ]), copts = select({ + ":qnx": [], ":windows": [], "//conditions:default": ["-pthread"], }), @@ -94,6 +110,7 @@ cc_library( "googletest/include", ], linkopts = select({ + ":qnx": [], ":windows": [], "//conditions:default": ["-pthread"], }), @@ -103,6 +120,7 @@ cc_library( "@com_google_absl//absl/debugging:stacktrace", "@com_google_absl//absl/debugging:symbolize", "@com_google_absl//absl/strings", + "@com_google_absl//absl/types:any", "@com_google_absl//absl/types:optional", "@com_google_absl//absl/types:variant", ], diff --git a/ext/googletest/CMakeLists.txt b/ext/googletest/CMakeLists.txt index f11bbb521e..ea81ab1292 100644 --- a/ext/googletest/CMakeLists.txt +++ b/ext/googletest/CMakeLists.txt @@ -1,21 +1,17 @@ # Note: CMake support is community-based. The maintainers do not use CMake # internally. -cmake_minimum_required(VERSION 2.8.8) +cmake_minimum_required(VERSION 2.8.12) if (POLICY CMP0048) cmake_policy(SET CMP0048 NEW) endif (POLICY CMP0048) project(googletest-distribution) -set(GOOGLETEST_VERSION 1.10.0) +set(GOOGLETEST_VERSION 1.11.0) -if (CMAKE_VERSION VERSION_LESS "3.1") - add_definitions(-std=c++11) -else() - set(CMAKE_CXX_STANDARD 11) - set(CMAKE_CXX_STANDARD_REQUIRED ON) - if(NOT CYGWIN) +if (CMAKE_VERSION VERSION_GREATER "3.0.2") + if(NOT CYGWIN AND NOT MSYS AND NOT ${CMAKE_SYSTEM_NAME} STREQUAL QNX) set(CMAKE_CXX_EXTENSIONS OFF) endif() endif() diff --git a/ext/googletest/CONTRIBUTING.md b/ext/googletest/CONTRIBUTING.md index 30c8d8900b..da45e4450c 100644 --- a/ext/googletest/CONTRIBUTING.md +++ b/ext/googletest/CONTRIBUTING.md @@ -28,7 +28,7 @@ PR is acceptable as an alternative. ## Contributing A Patch 1. Submit an issue describing your proposed change to the - [issue tracker](https://github.com/google/googletest). + [issue tracker](https://github.com/google/googletest/issues). 2. Please don't mix more than one logical change per submittal, because it makes the history hard to follow. If you want to make a change that doesn't have a corresponding issue in the issue tracker, please create one. @@ -80,7 +80,7 @@ fairly rigid coding style, as defined by the will be expected to conform to the style outlined [here](https://google.github.io/styleguide/cppguide.html). Use [.clang-format](https://github.com/google/googletest/blob/master/.clang-format) -to check your formatting +to check your formatting. ## Requirements for Contributors @@ -89,7 +89,7 @@ and their own tests from a git checkout, which has further requirements: * [Python](https://www.python.org/) v2.3 or newer (for running some of the tests and re-generating certain source files from templates) -* [CMake](https://cmake.org/) v2.6.4 or newer +* [CMake](https://cmake.org/) v2.8.12 or newer ## Developing Google Test and Google Mock @@ -128,15 +128,3 @@ To run the tests, do make test All tests should pass. - -### Regenerating Source Files - -Some of Google Test's source files are generated from templates (not in the C++ -sense) using a script. For example, the file -include/gtest/internal/gtest-type-util.h.pump is used to generate -gtest-type-util.h in the same directory. - -You don't need to worry about regenerating the source files unless you need to -modify them. You would then modify the corresponding `.pump` files and run the -'[pump.py](googletest/scripts/pump.py)' generator script. See the -[Pump Manual](googletest/docs/pump_manual.md). diff --git a/ext/googletest/googletest/CONTRIBUTORS b/ext/googletest/CONTRIBUTORS similarity index 61% rename from ext/googletest/googletest/CONTRIBUTORS rename to ext/googletest/CONTRIBUTORS index feae2fc044..d9bc587b1b 100644 --- a/ext/googletest/googletest/CONTRIBUTORS +++ b/ext/googletest/CONTRIBUTORS @@ -5,33 +5,60 @@ Ajay Joshi Balázs Dán +Benoit Sigoure Bharat Mediratta +Bogdan Piloca Chandler Carruth Chris Prince Chris Taylor Dan Egnor +Dave MacLachlan +David Anderson +Dean Sturtevant Eric Roman +Gene Volovich Hady Zalek +Hal Burch Jeffrey Yasskin +Jim Keller +Joe Walnes +Jon Wray Jói Sigurðsson Keir Mierle Keith Ray Kenton Varda +Kostya Serebryany +Krystian Kuzniarek +Lev Makhlis Manuel Klimek +Mario Tanev +Mark Paskin Markus Heule +Martijn Vels +Matthew Simmons Mika Raento +Mike Bland Miklós Fazekas +Neal Norwitz +Nermin Ozkiranartli +Owen Carlsen +Paneendra Ba Pasi Valminen Patrick Hanna Patrick Riley +Paul Menage Peter Kaminski +Piotr Kaminski Preston Jackson Rainer Klaffenboeck Russ Cox Russ Rufer Sean Mcafee Sigurður Ásgeirsson +Sverre Sundsdal +Takeshi Yoshino Tracy Bialik Vadim Berman Vlad Losev +Wolfgang Klier Zhanyong Wan diff --git a/ext/googletest/README.md b/ext/googletest/README.md index 5b417fa883..e207d38975 100644 --- a/ext/googletest/README.md +++ b/ext/googletest/README.md @@ -1,48 +1,44 @@ -# Google Test +# GoogleTest -#### OSS Builds Status: +### Announcements -[![Build Status](https://api.travis-ci.org/google/googletest.svg?branch=master)](https://travis-ci.org/google/googletest) -[![Build status](https://ci.appveyor.com/api/projects/status/4o38plt0xbo1ubc8/branch/master?svg=true)](https://ci.appveyor.com/project/GoogleTestAppVeyor/googletest/branch/master) +#### Live at Head -### Future Plans +GoogleTest now follows the +[Abseil Live at Head philosophy](https://abseil.io/about/philosophy#upgrade-support). +We recommend using the latest commit in the `master` branch in your projects. -#### 1.8.x Release: +#### Documentation Updates -[the 1.8.x](https://github.com/google/googletest/releases/tag/release-1.8.1) is -the last release that works with pre-C++11 compilers. The 1.8.x will not accept -any requests for any new features and any bugfix requests will only be accepted -if proven "critical" +Our documentation is now live on GitHub Pages at +https://google.github.io/googletest/. We recommend browsing the documentation on +GitHub Pages rather than directly in the repository. -#### Post 1.8.x: +#### Release 1.11.0 -On-going work to improve/cleanup/pay technical debt. When this work is completed -there will be a 1.9.x tagged release +[Release 1.11.0](https://github.com/google/googletest/releases/tag/release-1.11.0) +is now available. -#### Post 1.9.x +#### Coming Soon -Post 1.9.x googletest will follow -[Abseil Live at Head philosophy](https://abseil.io/about/philosophy) +* We are planning to take a dependency on + [Abseil](https://github.com/abseil/abseil-cpp). +* More documentation improvements are planned. -## Welcome to **Google Test**, Google's C++ test framework! +## Welcome to **GoogleTest**, Google's C++ test framework! This repository is a merger of the formerly separate GoogleTest and GoogleMock projects. These were so closely related that it makes sense to maintain and release them together. -Please subscribe to the mailing list at googletestframework@googlegroups.com for -questions, discussions, and development. +### Getting Started -### Getting started: +See the [GoogleTest User's Guide](https://google.github.io/googletest/) for +documentation. We recommend starting with the +[GoogleTest Primer](https://google.github.io/googletest/primer.html). -The information for **Google Test** is available in the -[Google Test Primer](googletest/docs/primer.md) documentation. - -**Google Mock** is an extension to Google Test for writing and using C++ mock -classes. See the separate [Google Mock documentation](googlemock/README.md). - -More detailed documentation for googletest is in its interior -[googletest/README.md](googletest/README.md) file. +More information about building GoogleTest can be found at +[googletest/README.md](googletest/README.md). ## Features @@ -57,22 +53,45 @@ More detailed documentation for googletest is in its interior * Various options for running the tests. * XML test report generation. -## Platforms +## Supported Platforms -Google test has been used on a variety of platforms: +GoogleTest requires a codebase and compiler compliant with the C++11 standard or +newer. + +The GoogleTest code is officially supported on the following platforms. +Operating systems or tools not listed below are community-supported. For +community-supported platforms, patches that do not complicate the code may be +considered. + +If you notice any problems on your platform, please file an issue on the +[GoogleTest GitHub Issue Tracker](https://github.com/google/googletest/issues). +Pull requests containing fixes are welcome! + +### Operating Systems * Linux -* Mac OS X +* macOS * Windows -* Cygwin -* MinGW -* Windows Mobile -* Symbian -* PlatformIO -## Who Is Using Google Test? +### Compilers -In addition to many internal projects at Google, Google Test is also used by the +* gcc 5.0+ +* clang 5.0+ +* MSVC 2015+ + +**macOS users:** Xcode 9.3+ provides clang 5.0+. + +### Build Systems + +* [Bazel](https://bazel.build/) +* [CMake](https://cmake.org/) + +**Note:** Bazel is the build system used by the team internally and in tests. +CMake is supported on a best-effort basis and by the community. + +## Who Is Using GoogleTest? + +In addition to many internal projects at Google, GoogleTest is also used by the following notable projects: * The [Chromium projects](http://www.chromium.org/) (behind the Chrome browser @@ -81,8 +100,6 @@ following notable projects: * [Protocol Buffers](https://github.com/google/protobuf), Google's data interchange format. * The [OpenCV](http://opencv.org/) computer vision library. -* [tiny-dnn](https://github.com/tiny-dnn/tiny-dnn): header only, - dependency-free deep learning framework in C++11. ## Related Open Source Projects @@ -90,13 +107,13 @@ following notable projects: automated test-runner and Graphical User Interface with powerful features for Windows and Linux platforms. -[Google Test UI](https://github.com/ospector/gtest-gbar) is test runner that +[GoogleTest UI](https://github.com/ospector/gtest-gbar) is a test runner that runs your test binary, allows you to track its progress via a progress bar, and -displays a list of test failures. Clicking on one shows failure text. Google -Test UI is written in C#. +displays a list of test failures. Clicking on one shows failure text. GoogleTest +UI is written in C#. [GTest TAP Listener](https://github.com/kinow/gtest-tap-listener) is an event -listener for Google Test that implements the +listener for GoogleTest that implements the [TAP protocol](https://en.wikipedia.org/wiki/Test_Anything_Protocol) for test result output. If your test runner understands TAP, you may find it useful. @@ -104,31 +121,20 @@ result output. If your test runner understands TAP, you may find it useful. runs tests from your binary in parallel to provide significant speed-up. [GoogleTest Adapter](https://marketplace.visualstudio.com/items?itemName=DavidSchuldenfrei.gtest-adapter) -is a VS Code extension allowing to view Google Tests in a tree view, and -run/debug your tests. +is a VS Code extension allowing to view GoogleTest in a tree view, and run/debug +your tests. -## Requirements +[C++ TestMate](https://github.com/matepek/vscode-catch2-test-adapter) is a VS +Code extension allowing to view GoogleTest in a tree view, and run/debug your +tests. -Google Test is designed to have fairly minimal requirements to build and use -with your projects, but there are some. If you notice any problems on your -platform, please notify -[googletestframework@googlegroups.com](https://groups.google.com/forum/#!forum/googletestframework). -Patches for fixing them are welcome! +[Cornichon](https://pypi.org/project/cornichon/) is a small Gherkin DSL parser +that generates stub code for GoogleTest. -### Build Requirements +## Contributing Changes -These are the base requirements to build and use Google Test from a source -package: - -* [Bazel](https://bazel.build/) or [CMake](https://cmake.org/). NOTE: Bazel is - the build system that googletest is using internally and tests against. - CMake is community-supported. - -* a C++11-standard-compliant compiler - -## Contributing change - -Please read the [`CONTRIBUTING.md`](CONTRIBUTING.md) for details on how to -contribute to this project. +Please read +[`CONTRIBUTING.md`](https://github.com/google/googletest/blob/master/CONTRIBUTING.md) +for details on how to contribute to this project. Happy testing! diff --git a/ext/googletest/WORKSPACE b/ext/googletest/WORKSPACE index 2289bdb7e8..614f55778e 100644 --- a/ext/googletest/WORKSPACE +++ b/ext/googletest/WORKSPACE @@ -2,22 +2,23 @@ workspace(name = "com_google_googletest") load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") -# Abseil http_archive( - name = "com_google_absl", - urls = ["https://github.com/abseil/abseil-cpp/archive/master.zip"], - strip_prefix = "abseil-cpp-master", + name = "com_google_absl", + urls = ["https://github.com/abseil/abseil-cpp/archive/7971fb358ae376e016d2d4fc9327aad95659b25e.zip"], # 2021-05-20T02:59:16Z + strip_prefix = "abseil-cpp-7971fb358ae376e016d2d4fc9327aad95659b25e", + sha256 = "aeba534f7307e36fe084b452299e49b97420667a8d28102cf9a0daeed340b859", ) http_archive( - name = "rules_cc", - strip_prefix = "rules_cc-master", - urls = ["https://github.com/bazelbuild/rules_cc/archive/master.zip"], + name = "rules_cc", + urls = ["https://github.com/bazelbuild/rules_cc/archive/68cb652a71e7e7e2858c50593e5a9e3b94e5b9a9.zip"], # 2021-05-14T14:51:14Z + strip_prefix = "rules_cc-68cb652a71e7e7e2858c50593e5a9e3b94e5b9a9", + sha256 = "1e19e9a3bc3d4ee91d7fcad00653485ee6c798efbbf9588d40b34cbfbded143d", ) http_archive( - name = "rules_python", - strip_prefix = "rules_python-master", - urls = ["https://github.com/bazelbuild/rules_python/archive/master.zip"], + name = "rules_python", + urls = ["https://github.com/bazelbuild/rules_python/archive/ed6cc8f2c3692a6a7f013ff8bc185ba77eb9b4d2.zip"], # 2021-05-17T00:24:16Z + strip_prefix = "rules_python-ed6cc8f2c3692a6a7f013ff8bc185ba77eb9b4d2", + sha256 = "98b3c592faea9636ac8444bfd9de7f3fb4c60590932d6e6ac5946e3f8dbd5ff6", ) - diff --git a/ext/googletest/appveyor.yml b/ext/googletest/appveyor.yml deleted file mode 100644 index a58b7687d7..0000000000 --- a/ext/googletest/appveyor.yml +++ /dev/null @@ -1,154 +0,0 @@ -version: '{build}' - -os: Visual Studio 2015 - -environment: - matrix: - - compiler: msvc-15-seh - generator: "Visual Studio 15 2017" - build_system: cmake - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - - - compiler: msvc-15-seh - generator: "Visual Studio 15 2017 Win64" - build_system: cmake - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - enabled_on_pr: yes - - - compiler: msvc-15-seh - build_system: bazel - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 - enabled_on_pr: yes - - - compiler: msvc-14-seh - build_system: cmake - generator: "Visual Studio 14 2015" - enabled_on_pr: yes - - - compiler: msvc-14-seh - build_system: cmake - generator: "Visual Studio 14 2015 Win64" - - - compiler: gcc-6.3.0-posix - build_system: cmake - generator: "MinGW Makefiles" - cxx_path: 'C:\mingw-w64\i686-6.3.0-posix-dwarf-rt_v5-rev1\mingw32\bin' - enabled_on_pr: yes - -configuration: - - Debug - -build: - verbosity: minimal - -install: -- ps: | - Write-Output "Compiler: $env:compiler" - Write-Output "Generator: $env:generator" - Write-Output "Env:Configuation: $env:configuration" - Write-Output "Env: $env" - if (-not (Test-Path env:APPVEYOR_PULL_REQUEST_NUMBER)) { - Write-Output "This is *NOT* a pull request build" - } else { - Write-Output "This is a pull request build" - if (-not (Test-Path env:enabled_on_pr) -or $env:enabled_on_pr -ne "yes") { - Write-Output "PR builds are *NOT* explicitly enabled" - } - } - - # install Bazel - if ($env:build_system -eq "bazel") { - appveyor DownloadFile https://github.com/bazelbuild/bazel/releases/download/0.28.1/bazel-0.28.1-windows-x86_64.exe -FileName bazel.exe - } - - if ($env:build_system -eq "cmake") { - # git bash conflicts with MinGW makefiles - if ($env:generator -eq "MinGW Makefiles") { - $env:path = $env:path.replace("C:\Program Files\Git\usr\bin;", "") - if ($env:cxx_path -ne "") { - $env:path += ";$env:cxx_path" - } - } - } - -before_build: -- ps: | - $env:root=$env:APPVEYOR_BUILD_FOLDER - Write-Output "env:root: $env:root" - -build_script: -- ps: | - # Only enable some builds for pull requests, the AppVeyor queue is too long. - if ((Test-Path env:APPVEYOR_PULL_REQUEST_NUMBER) -And (-not (Test-Path env:enabled_on_pr) -or $env:enabled_on_pr -ne "yes")) { - return - } else { - # special case - build with Bazel - if ($env:build_system -eq "bazel") { - & $env:root\bazel.exe build -c opt //:gtest_samples - if ($LastExitCode -eq 0) { # bazel writes to StdErr and PowerShell interprets it as an error - $host.SetShouldExit(0) - } else { # a real error - throw "Exec: $ErrorMessage" - } - return - } - } - # by default build with CMake - md _build -Force | Out-Null - cd _build - - $conf = if ($env:generator -eq "MinGW Makefiles") {"-DCMAKE_BUILD_TYPE=$env:configuration"} else {"-DCMAKE_CONFIGURATION_TYPES=Debug;Release"} - # Disable test for MinGW (gtest tests fail, gmock tests can not build) - $gtest_build_tests = if ($env:generator -eq "MinGW Makefiles") {"-Dgtest_build_tests=OFF"} else {"-Dgtest_build_tests=ON"} - $gmock_build_tests = if ($env:generator -eq "MinGW Makefiles") {"-Dgmock_build_tests=OFF"} else {"-Dgmock_build_tests=ON"} - & cmake -G "$env:generator" $conf -Dgtest_build_samples=ON $gtest_build_tests $gmock_build_tests .. - if ($LastExitCode -ne 0) { - throw "Exec: $ErrorMessage" - } - $cmake_parallel = if ($env:generator -eq "MinGW Makefiles") {"-j2"} else {"/m"} - & cmake --build . --config $env:configuration -- $cmake_parallel - if ($LastExitCode -ne 0) { - throw "Exec: $ErrorMessage" - } - - -skip_commits: - files: - - '**/*.md' - -test_script: -- ps: | - # Only enable some builds for pull requests, the AppVeyor queue is too long. - if ((Test-Path env:APPVEYOR_PULL_REQUEST_NUMBER) -And (-not (Test-Path env:enabled_on_pr) -or $env:enabled_on_pr -ne "yes")) { - return - } - if ($env:build_system -eq "bazel") { - # special case - testing with Bazel - & $env:root\bazel.exe test //:gtest_samples - if ($LastExitCode -eq 0) { # bazel writes to StdErr and PowerShell interprets it as an error - $host.SetShouldExit(0) - } else { # a real error - throw "Exec: $ErrorMessage" - } - } - if ($env:build_system -eq "cmake") { - # built with CMake - test with CTest - if ($env:generator -eq "MinGW Makefiles") { - return # No test available for MinGW - } - - & ctest -C $env:configuration --timeout 600 --output-on-failure - if ($LastExitCode -ne 0) { - throw "Exec: $ErrorMessage" - } - } - -artifacts: - - path: '_build/CMakeFiles/*.log' - name: logs - - path: '_build/Testing/**/*.xml' - name: test_results - - path: 'bazel-testlogs/**/test.log' - name: test_logs - - path: 'bazel-testlogs/**/test.xml' - name: test_results diff --git a/ext/googletest/ci/build-linux-bazel.sh b/ext/googletest/ci/build-linux-bazel.sh deleted file mode 100755 index ae8fb75816..0000000000 --- a/ext/googletest/ci/build-linux-bazel.sh +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env bash -# Copyright 2017 Google Inc. -# All Rights Reserved. -# -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following disclaimer -# in the documentation and/or other materials provided with the -# distribution. -# * Neither the name of Google Inc. nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -set -e - -bazel version -bazel build --curses=no //...:all -bazel test --curses=no //...:all -bazel test --curses=no //...:all --define absl=1 diff --git a/ext/googletest/ci/build-platformio.sh b/ext/googletest/ci/build-platformio.sh deleted file mode 100644 index 1d7658d873..0000000000 --- a/ext/googletest/ci/build-platformio.sh +++ /dev/null @@ -1,2 +0,0 @@ -# run PlatformIO builds -platformio run diff --git a/ext/googletest/ci/env-linux.sh b/ext/googletest/ci/env-linux.sh deleted file mode 100755 index 37800d6a35..0000000000 --- a/ext/googletest/ci/env-linux.sh +++ /dev/null @@ -1,41 +0,0 @@ -#!/usr/bin/env bash -# Copyright 2017 Google Inc. -# All Rights Reserved. -# -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following disclaimer -# in the documentation and/or other materials provided with the -# distribution. -# * Neither the name of Google Inc. nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -# -# This file should be sourced, and not executed as a standalone script. -# - -# TODO() - we can check if this is being sourced using $BASH_VERSION and $BASH_SOURCE[0] != ${0}. - -if [ "${TRAVIS_OS_NAME}" = "linux" ]; then - if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi - if [ "$CXX" = "clang++" ]; then export CXX="clang++-3.9" CC="clang-3.9"; fi -fi diff --git a/ext/googletest/ci/install-linux.sh b/ext/googletest/ci/install-linux.sh deleted file mode 100755 index 05e2cb2803..0000000000 --- a/ext/googletest/ci/install-linux.sh +++ /dev/null @@ -1,49 +0,0 @@ -#!/usr/bin/env bash -# Copyright 2017 Google Inc. -# All Rights Reserved. -# -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following disclaimer -# in the documentation and/or other materials provided with the -# distribution. -# * Neither the name of Google Inc. nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -set -eu - -if [ "${TRAVIS_OS_NAME}" != linux ]; then - echo "Not a Linux build; skipping installation" - exit 0 -fi - - -if [ "${TRAVIS_SUDO}" = "true" ]; then - echo "deb [arch=amd64] http://storage.googleapis.com/bazel-apt stable jdk1.8" | \ - sudo tee /etc/apt/sources.list.d/bazel.list - curl https://bazel.build/bazel-release.pub.gpg | sudo apt-key add - - sudo apt-get update && sudo apt-get install -y bazel gcc-4.9 g++-4.9 clang-3.9 -elif [ "${CXX}" = "clang++" ]; then - # Use ccache, assuming $HOME/bin is in the path, which is true in the Travis build environment. - ln -sf /usr/bin/ccache $HOME/bin/${CXX}; - ln -sf /usr/bin/ccache $HOME/bin/${CC}; -fi diff --git a/ext/googletest/ci/install-osx.sh b/ext/googletest/ci/install-osx.sh deleted file mode 100755 index cc4750829c..0000000000 --- a/ext/googletest/ci/install-osx.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env bash -# Copyright 2017 Google Inc. -# All Rights Reserved. -# -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# * Redistributions of source code must retain the above copyright -# notice, this list of conditions and the following disclaimer. -# * Redistributions in binary form must reproduce the above -# copyright notice, this list of conditions and the following disclaimer -# in the documentation and/or other materials provided with the -# distribution. -# * Neither the name of Google Inc. nor the names of its -# contributors may be used to endorse or promote products derived from -# this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -set -eu - -if [ "${TRAVIS_OS_NAME}" != "osx" ]; then - echo "Not a macOS build; skipping installation" - exit 0 -fi - -brew update -brew install ccache gcc@4.9 diff --git a/ext/googletest/ci/install-platformio.sh b/ext/googletest/ci/install-platformio.sh deleted file mode 100644 index 4d7860a560..0000000000 --- a/ext/googletest/ci/install-platformio.sh +++ /dev/null @@ -1,5 +0,0 @@ -# install PlatformIO -sudo pip install -U platformio - -# update PlatformIO -platformio update diff --git a/ext/googletest/ci/linux-presubmit.sh b/ext/googletest/ci/linux-presubmit.sh new file mode 100644 index 0000000000..6bea1cde26 --- /dev/null +++ b/ext/googletest/ci/linux-presubmit.sh @@ -0,0 +1,126 @@ +#!/bin/bash +# +# Copyright 2020, Google Inc. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following disclaimer +# in the documentation and/or other materials provided with the +# distribution. +# * Neither the name of Google Inc. nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +set -euox pipefail + +readonly LINUX_LATEST_CONTAINER="gcr.io/google.com/absl-177019/linux_hybrid-latest:20210525" +readonly LINUX_GCC_FLOOR_CONTAINER="gcr.io/google.com/absl-177019/linux_gcc-floor:20201015" + +if [[ -z ${GTEST_ROOT:-} ]]; then + GTEST_ROOT="$(realpath $(dirname ${0})/..)" +fi + +if [[ -z ${STD:-} ]]; then + STD="c++11 c++14 c++17 c++20" +fi + +# Test the CMake build +for cc in /usr/local/bin/gcc /opt/llvm/clang/bin/clang; do + for cmake_off_on in OFF ON; do + time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --tmpfs="/build:exec" \ + --workdir="/build" \ + --rm \ + --env="CC=${cc}" \ + --env="CXX_FLAGS=\"-Werror -Wdeprecated\"" \ + ${LINUX_LATEST_CONTAINER} \ + /bin/bash -c " + cmake /src \ + -DCMAKE_CXX_STANDARD=11 \ + -Dgtest_build_samples=ON \ + -Dgtest_build_tests=ON \ + -Dgmock_build_tests=ON \ + -Dcxx_no_exception=${cmake_off_on} \ + -Dcxx_no_rtti=${cmake_off_on} && \ + make -j$(nproc) && \ + ctest -j$(nproc) --output-on-failure" + done +done + +# Do one test with an older version of GCC +time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --workdir="/src" \ + --rm \ + --env="CC=/usr/local/bin/gcc" \ + ${LINUX_GCC_FLOOR_CONTAINER} \ + /usr/local/bin/bazel test ... \ + --copt="-Wall" \ + --copt="-Werror" \ + --copt="-Wno-error=pragmas" \ + --keep_going \ + --show_timestamps \ + --test_output=errors + +# Test GCC +for std in ${STD}; do + for absl in 0 1; do + time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --workdir="/src" \ + --rm \ + --env="CC=/usr/local/bin/gcc" \ + --env="BAZEL_CXXOPTS=-std=${std}" \ + ${LINUX_LATEST_CONTAINER} \ + /usr/local/bin/bazel test ... \ + --copt="-Wall" \ + --copt="-Werror" \ + --define="absl=${absl}" \ + --distdir="/bazel-distdir" \ + --keep_going \ + --show_timestamps \ + --test_output=errors + done +done + +# Test Clang +for std in ${STD}; do + for absl in 0 1; do + time docker run \ + --volume="${GTEST_ROOT}:/src:ro" \ + --workdir="/src" \ + --rm \ + --env="CC=/opt/llvm/clang/bin/clang" \ + --env="BAZEL_CXXOPTS=-std=${std}" \ + ${LINUX_LATEST_CONTAINER} \ + /usr/local/bin/bazel test ... \ + --copt="--gcc-toolchain=/usr/local" \ + --copt="-Wall" \ + --copt="-Werror" \ + --define="absl=${absl}" \ + --distdir="/bazel-distdir" \ + --keep_going \ + --linkopt="--gcc-toolchain=/usr/local" \ + --show_timestamps \ + --test_output=errors + done +done diff --git a/ext/googletest/ci/get-nprocessors.sh b/ext/googletest/ci/macos-presubmit.sh old mode 100755 new mode 100644 similarity index 57% rename from ext/googletest/ci/get-nprocessors.sh rename to ext/googletest/ci/macos-presubmit.sh index 43635e761e..d6423faacc --- a/ext/googletest/ci/get-nprocessors.sh +++ b/ext/googletest/ci/macos-presubmit.sh @@ -1,7 +1,7 @@ -#!/usr/bin/env bash -# Copyright 2017 Google Inc. -# All Rights Reserved. +#!/bin/bash # +# Copyright 2020, Google Inc. +# All rights reserved. # # Redistribution and use in source and binary forms, with or without # modification, are permitted provided that the following conditions are @@ -29,20 +29,45 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# This file is typically sourced by another script. -# if possible, ask for the precise number of processors, -# otherwise take 2 processors as reasonable default; see -# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization -if [ -x /usr/bin/getconf ]; then - NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN) -else - NPROCESSORS=2 +set -euox pipefail + +if [[ -z ${GTEST_ROOT:-} ]]; then + GTEST_ROOT="$(realpath $(dirname ${0})/..)" fi -# as of 2017-09-04 Travis CI reports 32 processors, but GCC build -# crashes if parallelized too much (maybe memory consumption problem), -# so limit to 4 processors for the time being. -if [ $NPROCESSORS -gt 4 ] ; then - echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4." - NPROCESSORS=4 +# Test the CMake build +for cmake_off_on in OFF ON; do + BUILD_DIR=$(mktemp -d build_dir.XXXXXXXX) + cd ${BUILD_DIR} + time cmake ${GTEST_ROOT} \ + -DCMAKE_CXX_STANDARD=11 \ + -Dgtest_build_samples=ON \ + -Dgtest_build_tests=ON \ + -Dgmock_build_tests=ON \ + -Dcxx_no_exception=${cmake_off_on} \ + -Dcxx_no_rtti=${cmake_off_on} + time make + time ctest -j$(nproc) --output-on-failure +done + +# Test the Bazel build + +# If we are running on Kokoro, check for a versioned Bazel binary. +KOKORO_GFILE_BAZEL_BIN="bazel-3.7.0-darwin-x86_64" +if [[ ${KOKORO_GFILE_DIR:-} ]] && [[ -f ${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN} ]]; then + BAZEL_BIN="${KOKORO_GFILE_DIR}/${KOKORO_GFILE_BAZEL_BIN}" + chmod +x ${BAZEL_BIN} +else + BAZEL_BIN="bazel" fi + +cd ${GTEST_ROOT} +for absl in 0 1; do + ${BAZEL_BIN} test ... \ + --copt="-Wall" \ + --copt="-Werror" \ + --define="absl=${absl}" \ + --keep_going \ + --show_timestamps \ + --test_output=errors +done diff --git a/ext/googletest/ci/travis.sh b/ext/googletest/ci/travis.sh deleted file mode 100755 index 9ff3bad3ee..0000000000 --- a/ext/googletest/ci/travis.sh +++ /dev/null @@ -1,44 +0,0 @@ -#!/usr/bin/env sh -set -evx - -. ci/get-nprocessors.sh - -# if possible, ask for the precise number of processors, -# otherwise take 2 processors as reasonable default; see -# https://docs.travis-ci.com/user/speeding-up-the-build/#Makefile-optimization -if [ -x /usr/bin/getconf ]; then - NPROCESSORS=$(/usr/bin/getconf _NPROCESSORS_ONLN) -else - NPROCESSORS=2 -fi -# as of 2017-09-04 Travis CI reports 32 processors, but GCC build -# crashes if parallelized too much (maybe memory consumption problem), -# so limit to 4 processors for the time being. -if [ $NPROCESSORS -gt 4 ] ; then - echo "$0:Note: Limiting processors to use by make from $NPROCESSORS to 4." - NPROCESSORS=4 -fi -# Tell make to use the processors. No preceding '-' required. -MAKEFLAGS="j${NPROCESSORS}" -export MAKEFLAGS - -env | sort - -# Set default values to OFF for these variables if not specified. -: "${NO_EXCEPTION:=OFF}" -: "${NO_RTTI:=OFF}" -: "${COMPILER_IS_GNUCXX:=OFF}" - -mkdir build || true -cd build -cmake -Dgtest_build_samples=ON \ - -Dgtest_build_tests=ON \ - -Dgmock_build_tests=ON \ - -Dcxx_no_exception=$NO_EXCEPTION \ - -Dcxx_no_rtti=$NO_RTTI \ - -DCMAKE_COMPILER_IS_GNUCXX=$COMPILER_IS_GNUCXX \ - -DCMAKE_CXX_FLAGS=$CXX_FLAGS \ - -DCMAKE_BUILD_TYPE=$BUILD_TYPE \ - .. -make -CTEST_OUTPUT_ON_FAILURE=1 make test diff --git a/ext/googletest/docs/_config.yml b/ext/googletest/docs/_config.yml new file mode 100644 index 0000000000..d12867eab6 --- /dev/null +++ b/ext/googletest/docs/_config.yml @@ -0,0 +1 @@ +title: GoogleTest diff --git a/ext/googletest/docs/_data/navigation.yml b/ext/googletest/docs/_data/navigation.yml new file mode 100644 index 0000000000..9f3332708e --- /dev/null +++ b/ext/googletest/docs/_data/navigation.yml @@ -0,0 +1,43 @@ +nav: +- section: "Get Started" + items: + - title: "Supported Platforms" + url: "/platforms.html" + - title: "Quickstart: Bazel" + url: "/quickstart-bazel.html" + - title: "Quickstart: CMake" + url: "/quickstart-cmake.html" +- section: "Guides" + items: + - title: "GoogleTest Primer" + url: "/primer.html" + - title: "Advanced Topics" + url: "/advanced.html" + - title: "Mocking for Dummies" + url: "/gmock_for_dummies.html" + - title: "Mocking Cookbook" + url: "/gmock_cook_book.html" + - title: "Mocking Cheat Sheet" + url: "/gmock_cheat_sheet.html" +- section: "References" + items: + - title: "Testing Reference" + url: "/reference/testing.html" + - title: "Mocking Reference" + url: "/reference/mocking.html" + - title: "Assertions" + url: "/reference/assertions.html" + - title: "Matchers" + url: "/reference/matchers.html" + - title: "Actions" + url: "/reference/actions.html" + - title: "Testing FAQ" + url: "/faq.html" + - title: "Mocking FAQ" + url: "/gmock_faq.html" + - title: "Code Samples" + url: "/samples.html" + - title: "Using pkg-config" + url: "/pkgconfig.html" + - title: "Community Documentation" + url: "/community_created_documentation.html" diff --git a/ext/googletest/docs/_layouts/default.html b/ext/googletest/docs/_layouts/default.html new file mode 100644 index 0000000000..dcb42d9191 --- /dev/null +++ b/ext/googletest/docs/_layouts/default.html @@ -0,0 +1,58 @@ + + + + + + + +{% seo %} + + + + + +
+
+

{{ site.title | default: "Documentation" }}

+
+ + + +
+
+
+ {{ content }} +
+
+ GoogleTest · + GitHub Repository · + License · + Privacy Policy +
+
+ + + + diff --git a/ext/googletest/docs/_sass/main.scss b/ext/googletest/docs/_sass/main.scss new file mode 100644 index 0000000000..92edc877a5 --- /dev/null +++ b/ext/googletest/docs/_sass/main.scss @@ -0,0 +1,200 @@ +// Styles for GoogleTest docs website on GitHub Pages. +// Color variables are defined in +// https://github.com/pages-themes/primer/tree/master/_sass/primer-support/lib/variables + +$sidebar-width: 260px; + +body { + display: flex; + margin: 0; +} + +.sidebar { + background: $black; + color: $text-white; + flex-shrink: 0; + height: 100vh; + overflow: auto; + position: sticky; + top: 0; + width: $sidebar-width; +} + +.sidebar h1 { + font-size: 1.5em; +} + +.sidebar h2 { + color: $gray-light; + font-size: 0.8em; + font-weight: normal; + margin-bottom: 0.8em; + padding-left: 2.5em; + text-transform: uppercase; +} + +.sidebar .header { + background: $black; + padding: 2em; + position: sticky; + top: 0; + width: 100%; +} + +.sidebar .header a { + color: $text-white; + text-decoration: none; +} + +.sidebar .nav-toggle { + display: none; +} + +.sidebar .expander { + cursor: pointer; + display: none; + height: 3em; + position: absolute; + right: 1em; + top: 1.5em; + width: 3em; +} + +.sidebar .expander .arrow { + border: solid $white; + border-width: 0 3px 3px 0; + display: block; + height: 0.7em; + margin: 1em auto; + transform: rotate(45deg); + transition: transform 0.5s; + width: 0.7em; +} + +.sidebar nav { + width: 100%; +} + +.sidebar nav ul { + list-style-type: none; + margin-bottom: 1em; + padding: 0; + + &:last-child { + margin-bottom: 2em; + } + + a { + text-decoration: none; + } + + li { + color: $text-white; + padding-left: 2em; + text-decoration: none; + } + + li.active { + background: $border-gray-darker; + font-weight: bold; + } + + li:hover { + background: $border-gray-darker; + } +} + +.main { + background-color: $bg-gray; + width: calc(100% - #{$sidebar-width}); +} + +.main .main-inner { + background-color: $white; + padding: 2em; +} + +.main .footer { + margin: 0; + padding: 2em; +} + +.main table th { + text-align: left; +} + +.main .callout { + border-left: 0.25em solid $white; + padding: 1em; + + a { + text-decoration: underline; + } + + &.important { + background-color: $bg-yellow-light; + border-color: $bg-yellow; + color: $black; + } + + &.note { + background-color: $bg-blue-light; + border-color: $text-blue; + color: $text-blue; + } + + &.tip { + background-color: $green-000; + border-color: $green-700; + color: $green-700; + } + + &.warning { + background-color: $red-000; + border-color: $text-red; + color: $text-red; + } +} + +.main .good pre { + background-color: $bg-green-light; +} + +.main .bad pre { + background-color: $red-000; +} + +@media all and (max-width: 768px) { + body { + flex-direction: column; + } + + .sidebar { + height: auto; + position: relative; + width: 100%; + } + + .sidebar .expander { + display: block; + } + + .sidebar nav { + height: 0; + overflow: hidden; + } + + .sidebar .nav-toggle:checked { + & ~ nav { + height: auto; + } + + & + .expander .arrow { + transform: rotate(-135deg); + } + } + + .main { + width: 100%; + } +} diff --git a/ext/googletest/googletest/docs/advanced.md b/ext/googletest/docs/advanced.md similarity index 72% rename from ext/googletest/googletest/docs/advanced.md rename to ext/googletest/docs/advanced.md index 3e5f779d0a..8dff5ba150 100644 --- a/ext/googletest/googletest/docs/advanced.md +++ b/ext/googletest/docs/advanced.md @@ -1,7 +1,5 @@ # Advanced googletest Topics - - ## Introduction Now that you have read the [googletest Primer](primer.md) and learned how to @@ -17,69 +15,13 @@ assertions. ### Explicit Success and Failure -These three assertions do not actually test a value or expression. Instead, they -generate a success or failure directly. Like the macros that actually perform a -test, you may stream a custom failure message into them. - -```c++ -SUCCEED(); -``` - -Generates a success. This does **NOT** make the overall test succeed. A test is -considered successful only if none of its assertions fail during its execution. - -NOTE: `SUCCEED()` is purely documentary and currently doesn't generate any -user-visible output. However, we may add `SUCCEED()` messages to googletest's -output in the future. - -```c++ -FAIL(); -ADD_FAILURE(); -ADD_FAILURE_AT("file_path", line_number); -``` - -`FAIL()` generates a fatal failure, while `ADD_FAILURE()` and `ADD_FAILURE_AT()` -generate a nonfatal failure. These are useful when control flow, rather than a -Boolean expression, determines the test's success or failure. For example, you -might want to write something like: - -```c++ -switch(expression) { - case 1: - ... some checks ... - case 2: - ... some other checks ... - default: - FAIL() << "We shouldn't get here."; -} -``` - -NOTE: you can only use `FAIL()` in functions that return `void`. See the -[Assertion Placement section](#assertion-placement) for more information. +See [Explicit Success and Failure](reference/assertions.md#success-failure) in +the Assertions Reference. ### Exception Assertions -These are for verifying that a piece of code throws (or does not throw) an -exception of the given type: - -Fatal assertion | Nonfatal assertion | Verifies ------------------------------------------- | ------------------------------------------ | -------- -`ASSERT_THROW(statement, exception_type);` | `EXPECT_THROW(statement, exception_type);` | `statement` throws an exception of the given type -`ASSERT_ANY_THROW(statement);` | `EXPECT_ANY_THROW(statement);` | `statement` throws an exception of any type -`ASSERT_NO_THROW(statement);` | `EXPECT_NO_THROW(statement);` | `statement` doesn't throw any exception - -Examples: - -```c++ -ASSERT_THROW(Foo(5), bar_exception); - -EXPECT_NO_THROW({ - int n = 5; - Bar(&n); -}); -``` - -**Availability**: requires exceptions to be enabled in the build environment +See [Exception Assertions](reference/assertions.md#exceptions) in the Assertions +Reference. ### Predicate Assertions for Better Error Messages @@ -99,60 +41,9 @@ googletest gives you three different options to solve this problem: If you already have a function or functor that returns `bool` (or a type that can be implicitly converted to `bool`), you can use it in a *predicate -assertion* to get the function arguments printed for free: - - - -| Fatal assertion | Nonfatal assertion | Verifies | -| --------------------------------- | --------------------------------- | --------------------------- | -| `ASSERT_PRED1(pred1, val1)` | `EXPECT_PRED1(pred1, val1)` | `pred1(val1)` is true | -| `ASSERT_PRED2(pred2, val1, val2)` | `EXPECT_PRED2(pred2, val1, val2)` | `pred1(val1, val2)` is true | -| `...` | `...` | `...` | - - -In the above, `predn` is an `n`-ary predicate function or functor, where `val1`, -`val2`, ..., and `valn` are its arguments. The assertion succeeds if the -predicate returns `true` when applied to the given arguments, and fails -otherwise. When the assertion fails, it prints the value of each argument. In -either case, the arguments are evaluated exactly once. - -Here's an example. Given - -```c++ -// Returns true if m and n have no common divisors except 1. -bool MutuallyPrime(int m, int n) { ... } - -const int a = 3; -const int b = 4; -const int c = 10; -``` - -the assertion - -```c++ - EXPECT_PRED2(MutuallyPrime, a, b); -``` - -will succeed, while the assertion - -```c++ - EXPECT_PRED2(MutuallyPrime, b, c); -``` - -will fail with the message - -```none -MutuallyPrime(b, c) is false, where -b is 4 -c is 10 -``` - -> NOTE: -> -> 1. If you see a compiler error "no matching function to call" when using -> `ASSERT_PRED*` or `EXPECT_PRED*`, please see -> [this](faq.md#the-compiler-complains-no-matching-function-to-call-when-i-use-assert-pred-how-do-i-fix-it) -> for how to resolve it. +assertion* to get the function arguments printed for free. See +[`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) in the Assertions +Reference for details. #### Using a Function That Returns an AssertionResult @@ -187,11 +78,11 @@ write a predicate function that returns `AssertionResult` instead of `bool`. For example, if you define `IsEven()` as: ```c++ -::testing::AssertionResult IsEven(int n) { +testing::AssertionResult IsEven(int n) { if ((n % 2) == 0) - return ::testing::AssertionSuccess(); + return testing::AssertionSuccess(); else - return ::testing::AssertionFailure() << n << " is odd"; + return testing::AssertionFailure() << n << " is odd"; } ``` @@ -225,11 +116,11 @@ are fine with making the predicate slower in the success case, you can supply a success message: ```c++ -::testing::AssertionResult IsEven(int n) { +testing::AssertionResult IsEven(int n) { if ((n % 2) == 0) - return ::testing::AssertionSuccess() << n << " is even"; + return testing::AssertionSuccess() << n << " is even"; else - return ::testing::AssertionFailure() << n << " is odd"; + return testing::AssertionFailure() << n << " is odd"; } ``` @@ -243,176 +134,50 @@ Then the statement `EXPECT_FALSE(IsEven(Fib(6)))` will print #### Using a Predicate-Formatter -If you find the default message generated by `(ASSERT|EXPECT)_PRED*` and -`(ASSERT|EXPECT)_(TRUE|FALSE)` unsatisfactory, or some arguments to your -predicate do not support streaming to `ostream`, you can instead use the -following *predicate-formatter assertions* to *fully* customize how the message -is formatted: - -Fatal assertion | Nonfatal assertion | Verifies ------------------------------------------------- | ------------------------------------------------ | -------- -`ASSERT_PRED_FORMAT1(pred_format1, val1);` | `EXPECT_PRED_FORMAT1(pred_format1, val1);` | `pred_format1(val1)` is successful -`ASSERT_PRED_FORMAT2(pred_format2, val1, val2);` | `EXPECT_PRED_FORMAT2(pred_format2, val1, val2);` | `pred_format2(val1, val2)` is successful -`...` | `...` | ... - -The difference between this and the previous group of macros is that instead of -a predicate, `(ASSERT|EXPECT)_PRED_FORMAT*` take a *predicate-formatter* -(`pred_formatn`), which is a function or functor with the signature: - -```c++ -::testing::AssertionResult PredicateFormattern(const char* expr1, - const char* expr2, - ... - const char* exprn, - T1 val1, - T2 val2, - ... - Tn valn); -``` - -where `val1`, `val2`, ..., and `valn` are the values of the predicate arguments, -and `expr1`, `expr2`, ..., and `exprn` are the corresponding expressions as they -appear in the source code. The types `T1`, `T2`, ..., and `Tn` can be either -value types or reference types. For example, if an argument has type `Foo`, you -can declare it as either `Foo` or `const Foo&`, whichever is appropriate. - -As an example, let's improve the failure message in `MutuallyPrime()`, which was -used with `EXPECT_PRED2()`: - -```c++ -// Returns the smallest prime common divisor of m and n, -// or 1 when m and n are mutually prime. -int SmallestPrimeCommonDivisor(int m, int n) { ... } - -// A predicate-formatter for asserting that two integers are mutually prime. -::testing::AssertionResult AssertMutuallyPrime(const char* m_expr, - const char* n_expr, - int m, - int n) { - if (MutuallyPrime(m, n)) return ::testing::AssertionSuccess(); - - return ::testing::AssertionFailure() << m_expr << " and " << n_expr - << " (" << m << " and " << n << ") are not mutually prime, " - << "as they have a common divisor " << SmallestPrimeCommonDivisor(m, n); -} -``` - -With this predicate-formatter, we can use - -```c++ - EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c); -``` - -to generate the message - -```none -b and c (4 and 10) are not mutually prime, as they have a common divisor 2. -``` - -As you may have realized, many of the built-in assertions we introduced earlier -are special cases of `(EXPECT|ASSERT)_PRED_FORMAT*`. In fact, most of them are -indeed defined using `(EXPECT|ASSERT)_PRED_FORMAT*`. +If you find the default message generated by +[`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) and +[`EXPECT_TRUE`](reference/assertions.md#EXPECT_TRUE) unsatisfactory, or some +arguments to your predicate do not support streaming to `ostream`, you can +instead use *predicate-formatter assertions* to *fully* customize how the +message is formatted. See +[`EXPECT_PRED_FORMAT*`](reference/assertions.md#EXPECT_PRED_FORMAT) in the +Assertions Reference for details. ### Floating-Point Comparison -Comparing floating-point numbers is tricky. Due to round-off errors, it is very -unlikely that two floating-points will match exactly. Therefore, `ASSERT_EQ` 's -naive comparison usually doesn't work. And since floating-points can have a wide -value range, no single fixed error bound works. It's better to compare by a -fixed relative error bound, except for values close to 0 due to the loss of -precision there. - -In general, for floating-point comparison to make sense, the user needs to -carefully choose the error bound. If they don't want or care to, comparing in -terms of Units in the Last Place (ULPs) is a good default, and googletest -provides assertions to do this. Full details about ULPs are quite long; if you -want to learn more, see -[here](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). - -#### Floating-Point Macros - - - -| Fatal assertion | Nonfatal assertion | Verifies | -| ------------------------------- | ------------------------------- | ---------------------------------------- | -| `ASSERT_FLOAT_EQ(val1, val2);` | `EXPECT_FLOAT_EQ(val1, val2);` | the two `float` values are almost equal | -| `ASSERT_DOUBLE_EQ(val1, val2);` | `EXPECT_DOUBLE_EQ(val1, val2);` | the two `double` values are almost equal | - - - -By "almost equal" we mean the values are within 4 ULP's from each other. - -The following assertions allow you to choose the acceptable error bound: - - - -| Fatal assertion | Nonfatal assertion | Verifies | -| ------------------------------------- | ------------------------------------- | -------------------------------------------------------------------------------- | -| `ASSERT_NEAR(val1, val2, abs_error);` | `EXPECT_NEAR(val1, val2, abs_error);` | the difference between `val1` and `val2` doesn't exceed the given absolute error | - - +See [Floating-Point Comparison](reference/assertions.md#floating-point) in the +Assertions Reference. #### Floating-Point Predicate-Format Functions Some floating-point operations are useful, but not that often used. In order to avoid an explosion of new macros, we provide them as predicate-format functions -that can be used in predicate assertion macros (e.g. `EXPECT_PRED_FORMAT2`, -etc). +that can be used in the predicate assertion macro +[`EXPECT_PRED_FORMAT2`](reference/assertions.md#EXPECT_PRED_FORMAT), for +example: ```c++ -EXPECT_PRED_FORMAT2(::testing::FloatLE, val1, val2); -EXPECT_PRED_FORMAT2(::testing::DoubleLE, val1, val2); +EXPECT_PRED_FORMAT2(testing::FloatLE, val1, val2); +EXPECT_PRED_FORMAT2(testing::DoubleLE, val1, val2); ``` -Verifies that `val1` is less than, or almost equal to, `val2`. You can replace -`EXPECT_PRED_FORMAT2` in the above table with `ASSERT_PRED_FORMAT2`. +The above code verifies that `val1` is less than, or approximately equal to, +`val2`. ### Asserting Using gMock Matchers -[gMock](../../googlemock) comes with a library of matchers for validating -arguments passed to mock objects. A gMock *matcher* is basically a predicate -that knows how to describe itself. It can be used in these assertion macros: - - - -| Fatal assertion | Nonfatal assertion | Verifies | -| ------------------------------ | ------------------------------ | --------------------- | -| `ASSERT_THAT(value, matcher);` | `EXPECT_THAT(value, matcher);` | value matches matcher | - - - -For example, `StartsWith(prefix)` is a matcher that matches a string starting -with `prefix`, and you can write: - -```c++ -using ::testing::StartsWith; -... - // Verifies that Foo() returns a string starting with "Hello". - EXPECT_THAT(Foo(), StartsWith("Hello")); -``` - -Read this -[recipe](../../googlemock/docs/cook_book.md#using-matchers-in-googletest-assertions) -in the gMock Cookbook for more details. - -gMock has a rich set of matchers. You can do many things googletest cannot do -alone with them. For a list of matchers gMock provides, read -[this](../../googlemock/docs/cook_book.md##using-matchers). It's easy to write -your [own matchers](../../googlemock/docs/cook_book.md#NewMatchers) too. - -gMock is bundled with googletest, so you don't need to add any build dependency -in order to take advantage of this. Just include `"testing/base/public/gmock.h"` -and you're ready to go. +See [`EXPECT_THAT`](reference/assertions.md#EXPECT_THAT) in the Assertions +Reference. ### More String Assertions (Please read the [previous](#asserting-using-gmock-matchers) section first if you haven't.) -You can use the gMock -[string matchers](../../googlemock/docs/cheat_sheet.md#string-matchers) with -`EXPECT_THAT()` or `ASSERT_THAT()` to do more string comparison tricks -(sub-string, prefix, suffix, regular expression, and etc). For example, +You can use the gMock [string matchers](reference/matchers.md#string-matchers) +with [`EXPECT_THAT`](reference/assertions.md#EXPECT_THAT) to do more string +comparison tricks (sub-string, prefix, suffix, regular expression, and etc). For +example, ```c++ using ::testing::HasSubstr; @@ -422,37 +187,10 @@ using ::testing::MatchesRegex; EXPECT_THAT(bar_string, MatchesRegex("\\w*\\d+")); ``` -If the string contains a well-formed HTML or XML document, you can check whether -its DOM tree matches an -[XPath expression](http://www.w3.org/TR/xpath/#contents): - -```c++ -// Currently still in //template/prototemplate/testing:xpath_matcher -#include "template/prototemplate/testing/xpath_matcher.h" -using prototemplate::testing::MatchesXPath; -EXPECT_THAT(html_string, MatchesXPath("//a[text()='click here']")); -``` - ### Windows HRESULT assertions -These assertions test for `HRESULT` success or failure. - -Fatal assertion | Nonfatal assertion | Verifies --------------------------------------- | -------------------------------------- | -------- -`ASSERT_HRESULT_SUCCEEDED(expression)` | `EXPECT_HRESULT_SUCCEEDED(expression)` | `expression` is a success `HRESULT` -`ASSERT_HRESULT_FAILED(expression)` | `EXPECT_HRESULT_FAILED(expression)` | `expression` is a failure `HRESULT` - -The generated output contains the human-readable error message associated with -the `HRESULT` code returned by `expression`. - -You might use them like this: - -```c++ -CComPtr shell; -ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application")); -CComVariant empty; -ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty)); -``` +See [Windows HRESULT Assertions](reference/assertions.md#HRESULT) in the +Assertions Reference. ### Type Assertions @@ -465,7 +203,7 @@ You can call the function to assert that types `T1` and `T2` are the same. The function does nothing if the assertion is satisfied. If the types are different, the function call will fail to compile, the compiler error message will say that -`type1 and type2 are not the same type` and most likely (depending on the compiler) +`T1 and T2 are not the same type` and most likely (depending on the compiler) show you the actual values of `T1` and `T2`. This is mainly useful inside template code. @@ -476,7 +214,7 @@ instantiated. For example, given: ```c++ template class Foo { public: - void Bar() { ::testing::StaticAssertTypeEq(); } + void Bar() { testing::StaticAssertTypeEq(); } }; ``` @@ -516,6 +254,7 @@ any assertion inside of it. If changing the function's type is not an option, you should just use assertions that generate non-fatal failures, such as `ADD_FAILURE*` and `EXPECT_*`. +{: .callout .note} NOTE: Constructors and destructors are not considered void-returning functions, according to the C++ language specification, and so you may not use fatal assertions in them; you'll get a compilation error if you try. Instead, either @@ -523,13 +262,46 @@ call `abort` and crash the entire test executable, or put the fatal assertion in a `SetUp`/`TearDown` function; see [constructor/destructor vs. `SetUp`/`TearDown`](faq.md#CtorVsSetUp) +{: .callout .warning} WARNING: A fatal assertion in a helper function (private void-returning method) -called from a constructor or destructor does not does not terminate the current -test, as your intuition might suggest: it merely returns from the constructor or +called from a constructor or destructor does not terminate the current test, as +your intuition might suggest: it merely returns from the constructor or destructor early, possibly leaving your object in a partially-constructed or partially-destructed state! You almost certainly want to `abort` or use `SetUp`/`TearDown` instead. +## Skipping test execution + +Related to the assertions `SUCCEED()` and `FAIL()`, you can prevent further test +execution at runtime with the `GTEST_SKIP()` macro. This is useful when you need +to check for preconditions of the system under test during runtime and skip +tests in a meaningful way. + +`GTEST_SKIP()` can be used in individual test cases or in the `SetUp()` methods +of classes derived from either `::testing::Environment` or `::testing::Test`. +For example: + +```c++ +TEST(SkipTest, DoesSkip) { + GTEST_SKIP() << "Skipping single test"; + EXPECT_EQ(0, 1); // Won't fail; it won't be executed +} + +class SkipFixture : public ::testing::Test { + protected: + void SetUp() override { + GTEST_SKIP() << "Skipping all tests for this fixture"; + } +}; + +// Tests for SkipFixture won't be executed. +TEST_F(SkipFixture, SkipsOneTest) { + EXPECT_EQ(5, 7); // Won't fail +} +``` + +As with assertion macros, you can stream a custom message into `GTEST_SKIP()`. + ## Teaching googletest How to Print Your Values When a test assertion such as `EXPECT_EQ` fails, googletest prints the argument @@ -605,7 +377,7 @@ call `::testing::PrintToString(x)`, which returns an `std::string`: vector > bar_ints = GetBarIntVector(); EXPECT_TRUE(IsCorrectBarIntVector(bar_ints)) - << "bar_ints = " << ::testing::PrintToString(bar_ints); + << "bar_ints = " << testing::PrintToString(bar_ints); ``` ## Death Tests @@ -628,73 +400,16 @@ exception and avoid the crash. If you want to verify exceptions thrown by your code, see [Exception Assertions](#ExceptionAssertions). If you want to test `EXPECT_*()/ASSERT_*()` failures in your test code, see -Catching Failures +["Catching" Failures](#catching-failures). ### How to Write a Death Test -googletest has the following macros to support death tests: +GoogleTest provides assertion macros to support death tests. See +[Death Assertions](reference/assertions.md#death) in the Assertions Reference +for details. -Fatal assertion | Nonfatal assertion | Verifies ------------------------------------------------- | ------------------------------------------------ | -------- -`ASSERT_DEATH(statement, matcher);` | `EXPECT_DEATH(statement, matcher);` | `statement` crashes with the given error -`ASSERT_DEATH_IF_SUPPORTED(statement, matcher);` | `EXPECT_DEATH_IF_SUPPORTED(statement, matcher);` | if death tests are supported, verifies that `statement` crashes with the given error; otherwise verifies nothing -`ASSERT_EXIT(statement, predicate, matcher);` | `EXPECT_EXIT(statement, predicate, matcher);` | `statement` exits with the given error, and its exit code matches `predicate` - -where `statement` is a statement that is expected to cause the process to die, -`predicate` is a function or function object that evaluates an integer exit -status, and `matcher` is either a GMock matcher matching a `const std::string&` -or a (Perl) regular expression - either of which is matched against the stderr -output of `statement`. For legacy reasons, a bare string (i.e. with no matcher) -is interpreted as `ContainsRegex(str)`, **not** `Eq(str)`. Note that `statement` -can be *any valid statement* (including *compound statement*) and doesn't have -to be an expression. - -As usual, the `ASSERT` variants abort the current test function, while the -`EXPECT` variants do not. - -> NOTE: We use the word "crash" here to mean that the process terminates with a -> *non-zero* exit status code. There are two possibilities: either the process -> has called `exit()` or `_exit()` with a non-zero value, or it may be killed by -> a signal. -> -> This means that if `*statement*` terminates the process with a 0 exit code, it -> is *not* considered a crash by `EXPECT_DEATH`. Use `EXPECT_EXIT` instead if -> this is the case, or if you want to restrict the exit code more precisely. - -A predicate here must accept an `int` and return a `bool`. The death test -succeeds only if the predicate returns `true`. googletest defines a few -predicates that handle the most common cases: - -```c++ -::testing::ExitedWithCode(exit_code) -``` - -This expression is `true` if the program exited normally with the given exit -code. - -```c++ -::testing::KilledBySignal(signal_number) // Not available on Windows. -``` - -This expression is `true` if the program was killed by the given signal. - -The `*_DEATH` macros are convenient wrappers for `*_EXIT` that use a predicate -that verifies the process' exit code is non-zero. - -Note that a death test only cares about three things: - -1. does `statement` abort or exit the process? -2. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status - satisfy `predicate`? Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) - is the exit status non-zero? And -3. does the stderr output match `regex`? - -In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it -will **not** cause the death test to fail, as googletest assertions don't abort -the process. - -To write a death test, simply use one of the above macros inside your test -function. For example, +To write a death test, simply use one of the macros inside your test function. +For example, ```c++ TEST(MyDeathTest, Foo) { @@ -706,11 +421,11 @@ TEST(MyDeathTest, Foo) { } TEST(MyDeathTest, NormalExit) { - EXPECT_EXIT(NormalExit(), ::testing::ExitedWithCode(0), "Success"); + EXPECT_EXIT(NormalExit(), testing::ExitedWithCode(0), "Success"); } -TEST(MyDeathTest, KillMyself) { - EXPECT_EXIT(KillMyself(), ::testing::KilledBySignal(SIGKILL), +TEST(MyDeathTest, KillProcess) { + EXPECT_EXIT(KillProcess(), testing::KilledBySignal(SIGKILL), "Sending myself unblockable signal"); } ``` @@ -720,13 +435,26 @@ verifies that: * calling `Foo(5)` causes the process to die with the given error message, * calling `NormalExit()` causes the process to print `"Success"` to stderr and exit with exit code 0, and -* calling `KillMyself()` kills the process with signal `SIGKILL`. +* calling `KillProcess()` kills the process with signal `SIGKILL`. The test function body may contain other assertions and statements as well, if necessary. +Note that a death test only cares about three things: + +1. does `statement` abort or exit the process? +2. (in the case of `ASSERT_EXIT` and `EXPECT_EXIT`) does the exit status + satisfy `predicate`? Or (in the case of `ASSERT_DEATH` and `EXPECT_DEATH`) + is the exit status non-zero? And +3. does the stderr output match `matcher`? + +In particular, if `statement` generates an `ASSERT_*` or `EXPECT_*` failure, it +will **not** cause the death test to fail, as googletest assertions don't abort +the process. + ### Death Test Naming +{: .callout .important} IMPORTANT: We strongly recommend you to follow the convention of naming your **test suite** (not test) `*DeathTest` when it contains a death test, as demonstrated in the above example. The @@ -737,7 +465,7 @@ If a test fixture class is shared by normal tests and death tests, you can use duplicating its code: ```c++ -class FooTest : public ::testing::Test { ... }; +class FooTest : public testing::Test { ... }; using FooDeathTest = FooTest; @@ -795,31 +523,8 @@ limited syntax only. ### How It Works -Under the hood, `ASSERT_EXIT()` spawns a new process and executes the death test -statement in that process. The details of how precisely that happens depend on -the platform and the variable ::testing::GTEST_FLAG(death_test_style) (which is -initialized from the command-line flag `--gtest_death_test_style`). - -* On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the - child, after which: - * If the variable's value is `"fast"`, the death test statement is - immediately executed. - * If the variable's value is `"threadsafe"`, the child process re-executes - the unit test binary just as it was originally invoked, but with some - extra flags to cause just the single death test under consideration to - be run. -* On Windows, the child is spawned using the `CreateProcess()` API, and - re-executes the binary to cause just the single death test under - consideration to be run - much like the `threadsafe` mode on POSIX. - -Other values for the variable are illegal and will cause the death test to fail. -Currently, the flag's default value is **"fast"** - -1. the child's exit status satisfies the predicate, and -2. the child's stderr matches the regular expression. - -If the death test statement runs to completion without dying, the child process -will nonetheless terminate, and the assertion fails. +See [Death Assertions](reference/assertions.md#death) in the Assertions +Reference. ### Death Tests And Threads @@ -862,13 +567,13 @@ restored afterwards, so you need not do that yourself. For example: ```c++ int main(int argc, char** argv) { - InitGoogle(argv[0], &argc, &argv, true); - ::testing::FLAGS_gtest_death_test_style = "fast"; + testing::InitGoogleTest(&argc, argv); + testing::FLAGS_gtest_death_test_style = "fast"; return RUN_ALL_TESTS(); } TEST(MyDeathTest, TestOne) { - ::testing::FLAGS_gtest_death_test_style = "threadsafe"; + testing::FLAGS_gtest_death_test_style = "threadsafe"; // This test is run in the "threadsafe" style: ASSERT_DEATH(ThisShouldDie(), ""); } @@ -908,6 +613,13 @@ handlers registered with `pthread_atfork(3)`. ## Using Assertions in Sub-routines +{: .callout .note} +Note: If you want to put a series of test assertions in a subroutine to check +for a complex condition, consider using +[a custom GMock matcher](gmock_cook_book.md#NewMatchers) +instead. This lets you provide a more readable error message in case of failure +and avoid all of the issues described below. + ### Adding Traces to Assertions If a test sub-routine is called from several places, when an assertion inside it @@ -918,6 +630,8 @@ the `SCOPED_TRACE` macro or the `ScopedTrace` utility: ```c++ SCOPED_TRACE(message); +``` +```c++ ScopedTrace trace("file_path", line_number, message); ``` @@ -953,7 +667,7 @@ path/to/foo_test.cc:11: Failure Value of: Bar(n) Expected: 1 Actual: 2 - Trace: +Google Test trace: path/to/foo_test.cc:17: A path/to/foo_test.cc:12: Failure @@ -1003,7 +717,7 @@ TEST(FooTest, Bar) { // in Subroutine() to abort the entire test. // The actual behavior: the function goes on after Subroutine() returns. - int* p = NULL; + int* p = nullptr; *p = 3; // Segfault! } ``` @@ -1097,7 +811,7 @@ If `HasFatalFailure()` is used outside of `TEST()` , `TEST_F()` , or a test fixture, you must add the `::testing::Test::` prefix, as in: ```c++ -if (::testing::Test::HasFatalFailure()) return; +if (testing::Test::HasFatalFailure()) return; ``` Similarly, `HasNonfatalFailure()` returns `true` if the current test has at @@ -1127,12 +841,13 @@ will output XML like this: ... ``` +{: .callout .note} > NOTE: > > * `RecordProperty()` is a static member of the `Test` class. Therefore it > needs to be prefixed with `::testing::Test::` if used outside of the > `TEST` body and the test fixture class. -> * `*key*` must be a valid XML attribute name, and cannot conflict with the +> * *`key`* must be a valid XML attribute name, and cannot conflict with the > ones already used by googletest (`name`, `status`, `time`, `classname`, > `type_param`, and `value_param`). > * Calling `RecordProperty()` outside of the lifespan of a test is allowed. @@ -1176,7 +891,7 @@ state to its original value before passing control to the next test. Here's an example of per-test-suite set-up and tear-down: ```c++ -class FooTest : public ::testing::Test { +class FooTest : public testing::Test { protected: // Per-test-suite set-up. // Called before the first test in this test suite. @@ -1190,20 +905,20 @@ class FooTest : public ::testing::Test { // Can be omitted if not needed. static void TearDownTestSuite() { delete shared_resource_; - shared_resource_ = NULL; + shared_resource_ = nullptr; } // You can define per-test set-up logic as usual. - virtual void SetUp() { ... } + void SetUp() override { ... } // You can define per-test tear-down logic as usual. - virtual void TearDown() { ... } + void TearDown() override { ... } // Some expensive resource shared by all tests. static T* shared_resource_; }; -T* FooTest::shared_resource_ = NULL; +T* FooTest::shared_resource_ = nullptr; TEST_F(FooTest, Test1) { ... you can refer to shared_resource_ here ... @@ -1214,6 +929,7 @@ TEST_F(FooTest, Test2) { } ``` +{: .callout .note} NOTE: Though the above code declares `SetUpTestSuite()` protected, it may sometimes be necessary to declare it public, such as when using it with `TEST_P`. @@ -1229,7 +945,7 @@ environment, which knows how to set-up and tear-down: ```c++ class Environment : public ::testing::Environment { public: - virtual ~Environment() {} + ~Environment() override {} // Override this to define how to set up the environment. void SetUp() override {} @@ -1265,8 +981,8 @@ probably in `main()`. If you use `gtest_main`, you need to call this before variable like this: ```c++ -::testing::Environment* const foo_env = - ::testing::AddGlobalTestEnvironment(new FooEnvironment); +testing::Environment* const foo_env = + testing::AddGlobalTestEnvironment(new FooEnvironment); ``` However, we strongly recommend you to write your own `main()` and call @@ -1301,6 +1017,7 @@ and `testing::WithParamInterface`. `T` can be any copyable type. If it's a raw pointer, you are responsible for managing the lifespan of the pointed values. +{: .callout .note} NOTE: If your test fixture defines `SetUpTestSuite()` or `TearDownTestSuite()` they must be declared **public** rather than **protected** in order to use `TEST_P`. @@ -1340,80 +1057,80 @@ TEST_P(FooTest, HasBlahBlah) { } ``` -Finally, you can use `INSTANTIATE_TEST_SUITE_P` to instantiate the test suite -with any set of parameters you want. googletest defines a number of functions -for generating test parameters. They return what we call (surprise!) *parameter -generators*. Here is a summary of them, which are all in the `testing` -namespace: +Finally, you can use the `INSTANTIATE_TEST_SUITE_P` macro to instantiate the +test suite with any set of parameters you want. GoogleTest defines a number of +functions for generating test parameters—see details at +[`INSTANTIATE_TEST_SUITE_P`](reference/testing.md#INSTANTIATE_TEST_SUITE_P) in +the Testing Reference. - - -| Parameter Generator | Behavior | -| ----------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | -| `Range(begin, end [, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. | -| `Values(v1, v2, ..., vN)` | Yields values `{v1, v2, ..., vN}`. | -| `ValuesIn(container)` and `ValuesIn(begin,end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)` | -| `Bool()` | Yields sequence `{false, true}`. | -| `Combine(g1, g2, ..., gN)` | Yields all combinations (Cartesian product) as std\:\:tuples of the values generated by the `N` generators. | - - - -For more details, see the comments at the definitions of these functions. - -The following statement will instantiate tests from the `FooTest` test suite -each with parameter values `"meeny"`, `"miny"`, and `"moe"`. +For example, the following statement will instantiate tests from the `FooTest` +test suite each with parameter values `"meeny"`, `"miny"`, and `"moe"` using the +[`Values`](reference/testing.md#param-generators) parameter generator: ```c++ -INSTANTIATE_TEST_SUITE_P(InstantiationName, +INSTANTIATE_TEST_SUITE_P(MeenyMinyMoe, FooTest, testing::Values("meeny", "miny", "moe")); ``` +{: .callout .note} NOTE: The code above must be placed at global or namespace scope, not at function scope. -NOTE: Don't forget this step! If you do your test will silently pass, but none -of its suites will ever run! +The first argument to `INSTANTIATE_TEST_SUITE_P` is a unique name for the +instantiation of the test suite. The next argument is the name of the test +pattern, and the last is the +[parameter generator](reference/testing.md#param-generators). -To distinguish different instances of the pattern (yes, you can instantiate it -more than once), the first argument to `INSTANTIATE_TEST_SUITE_P` is a prefix -that will be added to the actual test suite name. Remember to pick unique -prefixes for different instantiations. The tests from the instantiation above -will have these names: +You can instantiate a test pattern more than once, so to distinguish different +instances of the pattern, the instantiation name is added as a prefix to the +actual test suite name. Remember to pick unique prefixes for different +instantiations. The tests from the instantiation above will have these names: -* `InstantiationName/FooTest.DoesBlah/0` for `"meeny"` -* `InstantiationName/FooTest.DoesBlah/1` for `"miny"` -* `InstantiationName/FooTest.DoesBlah/2` for `"moe"` -* `InstantiationName/FooTest.HasBlahBlah/0` for `"meeny"` -* `InstantiationName/FooTest.HasBlahBlah/1` for `"miny"` -* `InstantiationName/FooTest.HasBlahBlah/2` for `"moe"` +* `MeenyMinyMoe/FooTest.DoesBlah/0` for `"meeny"` +* `MeenyMinyMoe/FooTest.DoesBlah/1` for `"miny"` +* `MeenyMinyMoe/FooTest.DoesBlah/2` for `"moe"` +* `MeenyMinyMoe/FooTest.HasBlahBlah/0` for `"meeny"` +* `MeenyMinyMoe/FooTest.HasBlahBlah/1` for `"miny"` +* `MeenyMinyMoe/FooTest.HasBlahBlah/2` for `"moe"` You can use these names in [`--gtest_filter`](#running-a-subset-of-the-tests). -This statement will instantiate all tests from `FooTest` again, each with -parameter values `"cat"` and `"dog"`: +The following statement will instantiate all tests from `FooTest` again, each +with parameter values `"cat"` and `"dog"` using the +[`ValuesIn`](reference/testing.md#param-generators) parameter generator: ```c++ const char* pets[] = {"cat", "dog"}; -INSTANTIATE_TEST_SUITE_P(AnotherInstantiationName, FooTest, - testing::ValuesIn(pets)); +INSTANTIATE_TEST_SUITE_P(Pets, FooTest, testing::ValuesIn(pets)); ``` The tests from the instantiation above will have these names: -* `AnotherInstantiationName/FooTest.DoesBlah/0` for `"cat"` -* `AnotherInstantiationName/FooTest.DoesBlah/1` for `"dog"` -* `AnotherInstantiationName/FooTest.HasBlahBlah/0` for `"cat"` -* `AnotherInstantiationName/FooTest.HasBlahBlah/1` for `"dog"` +* `Pets/FooTest.DoesBlah/0` for `"cat"` +* `Pets/FooTest.DoesBlah/1` for `"dog"` +* `Pets/FooTest.HasBlahBlah/0` for `"cat"` +* `Pets/FooTest.HasBlahBlah/1` for `"dog"` Please note that `INSTANTIATE_TEST_SUITE_P` will instantiate *all* tests in the given test suite, whether their definitions come before or *after* the `INSTANTIATE_TEST_SUITE_P` statement. +Additionally, by default, every `TEST_P` without a corresponding +`INSTANTIATE_TEST_SUITE_P` causes a failing test in test suite +`GoogleTestVerification`. If you have a test suite where that omission is not an +error, for example it is in a library that may be linked in for other reasons or +where the list of test cases is dynamic and may be empty, then this check can be +suppressed by tagging the test suite: + +```c++ +GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FooTest); +``` + You can see [sample7_unittest.cc] and [sample8_unittest.cc] for more examples. -[sample7_unittest.cc]: ../samples/sample7_unittest.cc "Parameterized Test example" -[sample8_unittest.cc]: ../samples/sample8_unittest.cc "Parameterized Test example with multiple parameters" +[sample7_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample7_unittest.cc "Parameterized Test example" +[sample8_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample8_unittest.cc "Parameterized Test example with multiple parameters" ### Creating Value-Parameterized Abstract Tests @@ -1450,6 +1167,7 @@ the test parameters. The function should accept one argument of type returns the value of `testing::PrintToString(GetParam())`. It does not work for `std::string` or C strings. +{: .callout .note} NOTE: test names must be non-empty, unique, and may only contain ASCII alphanumeric characters. In particular, they [should not contain underscores](faq.md#why-should-test-suite-names-and-test-names-not-contain-underscore) @@ -1476,17 +1194,17 @@ for conciseness: ```c++ enum class MyType { MY_FOO = 0, MY_BAR = 1 }; -class MyTestSuite : public testing::TestWithParam> { +class MyTestSuite : public testing::TestWithParam> { }; INSTANTIATE_TEST_SUITE_P( MyGroup, MyTestSuite, testing::Combine( - testing::Values(MyType::VALUE_0, MyType::VALUE_1), - testing::ValuesIn("", "")), + testing::Values(MyType::MY_FOO, MyType::MY_BAR), + testing::Values("A", "B")), [](const testing::TestParamInfo& info) { - string name = absl::StrCat( - std::get<0>(info.param) == MY_FOO ? "Foo" : "Bar", "_", + std::string name = absl::StrCat( + std::get<0>(info.param) == MyType::MY_FOO ? "Foo" : "Bar", std::get<1>(info.param)); absl::c_replace_if(name, [](char c) { return !std::isalnum(c); }, '_'); return name; @@ -1515,10 +1233,10 @@ Remember to derive it from `::testing::Test`: ```c++ template -class FooTest : public ::testing::Test { +class FooTest : public testing::Test { public: ... - typedef std::list List; + using List = std::list; static T shared_; T value_; }; @@ -1563,7 +1281,7 @@ TYPED_TEST(FooTest, HasPropertyA) { ... } You can see [sample6_unittest.cc] for a complete example. -[sample6_unittest.cc]: ../samples/sample6_unittest.cc "Typed Test example" +[sample6_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample6_unittest.cc "Typed Test example" ## Type-Parameterized Tests @@ -1583,7 +1301,7 @@ First, define a fixture class template, as we did with typed tests: ```c++ template -class FooTest : public ::testing::Test { +class FooTest : public testing::Test { ... }; ``` @@ -1622,7 +1340,7 @@ put the above code in a header file, you can `#include` it in multiple C++ source files and instantiate it multiple times. ```c++ -typedef ::testing::Types MyTypes; +using MyTypes = ::testing::Types; INSTANTIATE_TYPED_TEST_SUITE_P(My, FooTest, MyTypes); ``` @@ -1718,10 +1436,11 @@ To test them, we use the following special techniques: } ``` - Pay special attention when your class is defined in a namespace, as you - should define your test fixtures and tests in the same namespace if you want - them to be friends of your class. For example, if the code to be tested - looks like: + Pay special attention when your class is defined in a namespace. If you want + your test fixtures and tests to be friends of your class, then they must be + defined in the exact same namespace (no anonymous or inline namespaces). + + For example, if the code to be tested looks like: ```c++ namespace my_namespace { @@ -1741,7 +1460,7 @@ To test them, we use the following special techniques: ```c++ namespace my_namespace { - class FooTest : public ::testing::Test { + class FooTest : public testing::Test { protected: ... }; @@ -1762,7 +1481,7 @@ In frameworks that report a failure by throwing an exception, you could catch the exception and assert on it. But googletest doesn't use exceptions, so how do we test that a piece of code generates an expected failure? -gunit-spi.h contains some constructs to do this. After #including this header, +`"gtest/gtest-spi.h"` contains some constructs to do this. After #including this header, you can use ```c++ @@ -1788,6 +1507,7 @@ well, use one of the following macros instead: EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substring); ``` +{: .callout .note} NOTE: Assertions from multiple threads are currently not supported on Windows. For technical reasons, there are some caveats: @@ -1803,7 +1523,7 @@ For technical reasons, there are some caveats: ## Registering tests programmatically The `TEST` macros handle the vast majority of all use cases, but there are few -were runtime registration logic is required. For those cases, the framework +where runtime registration logic is required. For those cases, the framework provides the `::testing::RegisterTest` that allows callers to register arbitrary tests dynamically. @@ -1836,7 +1556,7 @@ undefined. Use case example: ```c++ -class MyFixture : public ::testing::Test { +class MyFixture : public testing::Test { public: // All of these optional, just like in regular macro usage. static void SetUpTestSuite() { ... } @@ -1856,7 +1576,7 @@ class MyTest : public MyFixture { void RegisterMyTests(const std::vector& values) { for (int v : values) { - ::testing::RegisterTest( + testing::RegisterTest( "MyFixture", ("Test" + std::to_string(v)).c_str(), nullptr, std::to_string(v).c_str(), __FILE__, __LINE__, @@ -1876,35 +1596,18 @@ int main(int argc, char** argv) { Sometimes a function may need to know the name of the currently running test. For example, you may be using the `SetUp()` method of your test fixture to set -the golden file name based on which test is running. The `::testing::TestInfo` -class has this information: - -```c++ -namespace testing { - -class TestInfo { - public: - // Returns the test suite name and the test name, respectively. - // - // Do NOT delete or free the return value - it's managed by the - // TestInfo class. - const char* test_suite_name() const; - const char* name() const; -}; - -} -``` +the golden file name based on which test is running. The +[`TestInfo`](reference/testing.md#TestInfo) class has this information. To obtain a `TestInfo` object for the currently running test, call -`current_test_info()` on the `UnitTest` singleton object: +`current_test_info()` on the [`UnitTest`](reference/testing.md#UnitTest) +singleton object: ```c++ // Gets information about the currently running test. // Do NOT delete the returned object - it's managed by the UnitTest class. - const ::testing::TestInfo* const test_info = - ::testing::UnitTest::GetInstance()->current_test_info(); - - + const testing::TestInfo* const test_info = + testing::UnitTest::GetInstance()->current_test_info(); printf("We are in test %s of test suite %s.\n", test_info->name(), @@ -1912,8 +1615,8 @@ To obtain a `TestInfo` object for the currently running test, call ``` `current_test_info()` returns a null pointer if no test is running. In -particular, you cannot find the test suite name in `TestSuiteSetUp()`, -`TestSuiteTearDown()` (where you know the test suite name implicitly), or +particular, you cannot find the test suite name in `SetUpTestSuite()`, +`TearDownTestSuite()` (where you know the test suite name implicitly), or functions called from them. ## Extending googletest by Handling Test Events @@ -1928,12 +1631,14 @@ checkpoints to implement a resource leak checker, for example. ### Defining Event Listeners -To define a event listener, you subclass either testing::TestEventListener or -testing::EmptyTestEventListener The former is an (abstract) interface, where -*each pure virtual method can be overridden to handle a test event* (For -example, when a test starts, the `OnTestStart()` method will be called.). The -latter provides an empty implementation of all methods in the interface, such -that a subclass only needs to override the methods it cares about. +To define a event listener, you subclass either +[`testing::TestEventListener`](reference/testing.md#TestEventListener) or +[`testing::EmptyTestEventListener`](reference/testing.md#EmptyTestEventListener) +The former is an (abstract) interface, where *each pure virtual method can be +overridden to handle a test event* (For example, when a test starts, the +`OnTestStart()` method will be called.). The latter provides an empty +implementation of all methods in the interface, such that a subclass only needs +to override the methods it cares about. When an event is fired, its context is passed to the handler function as an argument. The following argument types are used: @@ -1950,15 +1655,15 @@ interesting information about the event and the test program's state. Here's an example: ```c++ - class MinimalistPrinter : public ::testing::EmptyTestEventListener { + class MinimalistPrinter : public testing::EmptyTestEventListener { // Called before a test starts. - virtual void OnTestStart(const ::testing::TestInfo& test_info) { + void OnTestStart(const testing::TestInfo& test_info) override { printf("*** Test %s.%s starting.\n", test_info.test_suite_name(), test_info.name()); } // Called after a failed assertion or a SUCCESS(). - virtual void OnTestPartResult(const ::testing::TestPartResult& test_part_result) { + void OnTestPartResult(const testing::TestPartResult& test_part_result) override { printf("%s in %s:%d\n%s\n", test_part_result.failed() ? "*** Failure" : "Success", test_part_result.file_name(), @@ -1967,7 +1672,7 @@ Here's an example: } // Called after a test ends. - virtual void OnTestEnd(const ::testing::TestInfo& test_info) { + void OnTestEnd(const testing::TestInfo& test_info) override { printf("*** Test %s.%s ending.\n", test_info.test_suite_name(), test_info.name()); } @@ -1977,16 +1682,17 @@ Here's an example: ### Using Event Listeners To use the event listener you have defined, add an instance of it to the -googletest event listener list (represented by class TestEventListeners - note -the "s" at the end of the name) in your `main()` function, before calling +googletest event listener list (represented by class +[`TestEventListeners`](reference/testing.md#TestEventListeners) - note the "s" +at the end of the name) in your `main()` function, before calling `RUN_ALL_TESTS()`: ```c++ int main(int argc, char** argv) { - ::testing::InitGoogleTest(&argc, argv); + testing::InitGoogleTest(&argc, argv); // Gets hold of the event listener list. - ::testing::TestEventListeners& listeners = - ::testing::UnitTest::GetInstance()->listeners(); + testing::TestEventListeners& listeners = + testing::UnitTest::GetInstance()->listeners(); // Adds a listener to the end. googletest takes the ownership. listeners.Append(new MinimalistPrinter); return RUN_ALL_TESTS(); @@ -2008,7 +1714,7 @@ You can do so by adding one line: Now, sit back and enjoy a completely different output from your tests. For more details, see [sample9_unittest.cc]. -[sample9_unittest.cc]: ../samples/sample9_unittest.cc "Event listener example" +[sample9_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample9_unittest.cc "Event listener example" You may append more than one listener to the list. When an `On*Start()` or `OnTestPartResult()` event is fired, the listeners will receive it in the order @@ -2035,7 +1741,7 @@ by the former. See [sample10_unittest.cc] for an example of a failure-raising listener. -[sample10_unittest.cc]: ../samples/sample10_unittest.cc "Failure-raising listener example" +[sample10_unittest.cc]: https://github.com/google/googletest/blob/master/googletest/samples/sample10_unittest.cc "Failure-raising listener example" ## Running Test Programs: Advanced Options @@ -2104,6 +1810,15 @@ For example: everything in test suite `FooTest` except `FooTest.Bar` and everything in test suite `BarTest` except `BarTest.Foo`. +#### Stop test execution upon first failure + +By default, a googletest program runs all tests the user has defined. In some +cases (e.g. iterative test development & execution) it may be desirable stop +test execution upon first failure (trading improved latency for completeness). +If `GTEST_FAIL_FAST` environment variable or `--gtest_fail_fast` flag is set, +the test runner will stop execution as soon as the first test failure is +found. + #### Temporarily Disabling Tests If you have a broken test that you cannot fix right away, you can add the @@ -2122,19 +1837,21 @@ will still be compiled: // Tests that Foo does Abc. TEST(FooTest, DISABLED_DoesAbc) { ... } -class DISABLED_BarTest : public ::testing::Test { ... }; +class DISABLED_BarTest : public testing::Test { ... }; // Tests that Bar does Xyz. TEST_F(DISABLED_BarTest, DoesXyz) { ... } ``` +{: .callout .note} NOTE: This feature should only be used for temporary pain-relief. You still have to fix the disabled tests at a later date. As a reminder, googletest will print a banner warning you if a test program contains any disabled tests. -TIP: You can easily count the number of disabled tests you have using `gsearch` -and/or `grep`. This number can be used as a metric for improving your test -quality. +{: .callout .tip} +TIP: You can easily count the number of disabled tests you have using +`grep`. This number can be used as a metric for +improving your test quality. #### Temporarily Enabling Disabled Tests @@ -2201,38 +1918,25 @@ random seed and re-shuffle the tests in each iteration. googletest can use colors in its terminal output to make it easier to spot the important information: - -...
- [----------] 1 test from - FooTest
- [ RUN      ] - FooTest.DoesAbc
- [       OK ] - FooTest.DoesAbc
- [----------] - 2 tests from BarTest
- [ RUN      ] - BarTest.HasXyzProperty
- [       OK ] - BarTest.HasXyzProperty
- [ RUN      ] - BarTest.ReturnsTrueOnSuccess ... some error messages ...
- [   FAILED ] - BarTest.ReturnsTrueOnSuccess ...
- [==========] - 30 tests from 14 test suites ran.
- [   PASSED ] - 28 tests.
- [   FAILED ] - 2 tests, listed below:
- [   FAILED ] - BarTest.ReturnsTrueOnSuccess
- [   FAILED ] - AnotherTest.DoesXyz
-
- 2 FAILED TESTS - - +
...
+[----------] 1 test from FooTest
+[ RUN      ] FooTest.DoesAbc
+[       OK ] FooTest.DoesAbc
+[----------] 2 tests from BarTest
+[ RUN      ] BarTest.HasXyzProperty
+[       OK ] BarTest.HasXyzProperty
+[ RUN      ] BarTest.ReturnsTrueOnSuccess
+... some error messages ...
+[   FAILED ] BarTest.ReturnsTrueOnSuccess
+...
+[==========] 30 tests from 14 test suites ran.
+[   PASSED ] 28 tests.
+[   FAILED ] 2 tests, listed below:
+[   FAILED ] BarTest.ReturnsTrueOnSuccess
+[   FAILED ] AnotherTest.DoesXyz
+
+ 2 FAILED TESTS
+
You can set the `GTEST_COLOR` environment variable or the `--gtest_color` command line flag to `yes`, `no`, or `auto` (the default) to enable colors, @@ -2240,6 +1944,12 @@ disable colors, or let googletest decide. When the value is `auto`, googletest will use colors if and only if the output goes to a terminal and (on non-Windows platforms) the `TERM` environment variable is set to `xterm` or `xterm-color`. +#### Suppressing test passes + +By default, googletest prints 1 line of output for each test, indicating if it +passed or failed. To show only test failures, run the test program with +`--gtest_brief=1`, or set the GTEST_BRIEF environment variable to `1`. + #### Suppressing the Elapsed Time By default, googletest prints the time it takes to run each test. To disable @@ -2261,8 +1971,7 @@ environment variable to `0`. googletest can emit a detailed XML report to a file in addition to its normal textual output. The report contains the duration of each test, and thus can help -you identify slow tests. The report is also used by the http://unittest -dashboard to show per-test-method error messages. +you identify slow tests. To generate the XML report, set the `GTEST_OUTPUT` environment variable or the `--gtest_output` flag to the string `"xml:path_to_output_file"`, which will @@ -2537,10 +2246,23 @@ could generate this report: } ``` +{: .callout .important} IMPORTANT: The exact format of the JSON document is subject to change. ### Controlling How Failures Are Reported +#### Detecting Test Premature Exit + +Google Test implements the _premature-exit-file_ protocol for test runners +to catch any kind of unexpected exits of test programs. Upon start, +Google Test creates the file which will be automatically deleted after +all work has been finished. Then, the test runner can check if this file +exists. In case the file remains undeleted, the inspected test has exited +prematurely. + +This feature is enabled only if the `TEST_PREMATURE_EXIT_FILE` environment +variable has been set. + #### Turning Assertion Failures into Break-Points When running test programs under a debugger, it's very convenient if the @@ -2565,3 +2287,32 @@ to be handled by the debugger, such that you can examine the call stack when an exception is thrown. To achieve that, set the `GTEST_CATCH_EXCEPTIONS` environment variable to `0`, or use the `--gtest_catch_exceptions=0` flag when running the tests. + +### Sanitizer Integration + +The +[Undefined Behavior Sanitizer](https://clang.llvm.org/docs/UndefinedBehaviorSanitizer.html), +[Address Sanitizer](https://github.com/google/sanitizers/wiki/AddressSanitizer), +and +[Thread Sanitizer](https://github.com/google/sanitizers/wiki/ThreadSanitizerCppManual) +all provide weak functions that you can override to trigger explicit failures +when they detect sanitizer errors, such as creating a reference from `nullptr`. +To override these functions, place definitions for them in a source file that +you compile as part of your main binary: + +``` +extern "C" { +void __ubsan_on_report() { + FAIL() << "Encountered an undefined behavior sanitizer error"; +} +void __asan_on_error() { + FAIL() << "Encountered an address sanitizer error"; +} +void __tsan_on_report() { + FAIL() << "Encountered a thread sanitizer error"; +} +} // extern "C" +``` + +After compiling your project with one of the sanitizers enabled, if a particular +test triggers a sanitizer error, googletest will report that it failed. diff --git a/ext/googletest/docs/assets/css/style.scss b/ext/googletest/docs/assets/css/style.scss new file mode 100644 index 0000000000..bb30f418da --- /dev/null +++ b/ext/googletest/docs/assets/css/style.scss @@ -0,0 +1,5 @@ +--- +--- + +@import "jekyll-theme-primer"; +@import "main"; diff --git a/ext/googletest/docs/community_created_documentation.md b/ext/googletest/docs/community_created_documentation.md new file mode 100644 index 0000000000..4569075ff2 --- /dev/null +++ b/ext/googletest/docs/community_created_documentation.md @@ -0,0 +1,7 @@ +# Community-Created Documentation + +The following is a list, in no particular order, of links to documentation +created by the Googletest community. + +* [Googlemock Insights](https://github.com/ElectricRCAircraftGuy/eRCaGuy_dotfiles/blob/master/googletest/insights.md), + by [ElectricRCAircraftGuy](https://github.com/ElectricRCAircraftGuy) diff --git a/ext/googletest/googletest/docs/faq.md b/ext/googletest/docs/faq.md similarity index 85% rename from ext/googletest/googletest/docs/faq.md rename to ext/googletest/docs/faq.md index 960a827989..9042da1efb 100644 --- a/ext/googletest/googletest/docs/faq.md +++ b/ext/googletest/docs/faq.md @@ -1,9 +1,12 @@ # Googletest FAQ - - ## Why should test suite names and test names not contain underscore? +{: .callout .note} +Note: Googletest reserves underscore (`_`) for special purpose keywords, such as +[the `DISABLED_` prefix](advanced.md#temporarily-disabling-tests), in addition +to the following rationale. + Underscore (`_`) is special, as C++ reserves the following to be used by the compiler and the standard library: @@ -57,9 +60,10 @@ the rule. ## Why does googletest support `EXPECT_EQ(NULL, ptr)` and `ASSERT_EQ(NULL, ptr)` but not `EXPECT_NE(NULL, ptr)` and `ASSERT_NE(NULL, ptr)`? -First of all you can use `EXPECT_NE(nullptr, ptr)` and `ASSERT_NE(nullptr, -ptr)`. This is the preferred syntax in the style guide because nullptr does not -have the type problems that NULL does. Which is why NULL does not work. +First of all, you can use `nullptr` with each of these macros, e.g. +`EXPECT_EQ(ptr, nullptr)`, `EXPECT_NE(ptr, nullptr)`, `ASSERT_EQ(ptr, nullptr)`, +`ASSERT_NE(ptr, nullptr)`. This is the preferred syntax in the style guide +because `nullptr` does not have the type problems that `NULL` does. Due to some peculiarity of C++, it requires some non-trivial template meta programming tricks to support using `NULL` as an argument of the `EXPECT_XX()` @@ -67,22 +71,21 @@ and `ASSERT_XX()` macros. Therefore we only do it where it's most needed (otherwise we make the implementation of googletest harder to maintain and more error-prone than necessary). -The `EXPECT_EQ()` macro takes the *expected* value as its first argument and the -*actual* value as the second. It's reasonable that someone wants to write -`EXPECT_EQ(NULL, some_expression)`, and this indeed was requested several times. -Therefore we implemented it. +Historically, the `EXPECT_EQ()` macro took the *expected* value as its first +argument and the *actual* value as the second, though this argument order is now +discouraged. It was reasonable that someone wanted +to write `EXPECT_EQ(NULL, some_expression)`, and this indeed was requested +several times. Therefore we implemented it. -The need for `EXPECT_NE(NULL, ptr)` isn't nearly as strong. When the assertion +The need for `EXPECT_NE(NULL, ptr)` wasn't nearly as strong. When the assertion fails, you already know that `ptr` must be `NULL`, so it doesn't add any information to print `ptr` in this case. That means `EXPECT_TRUE(ptr != NULL)` works just as well. -If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'll have to -support `EXPECT_NE(ptr, NULL)` as well, as unlike `EXPECT_EQ`, we don't have a -convention on the order of the two arguments for `EXPECT_NE`. This means using -the template meta programming tricks twice in the implementation, making it even -harder to understand and maintain. We believe the benefit doesn't justify the -cost. +If we were to support `EXPECT_NE(NULL, ptr)`, for consistency we'd have to +support `EXPECT_NE(ptr, NULL)` as well. This means using the template meta +programming tricks twice in the implementation, making it even harder to +understand and maintain. We believe the benefit doesn't justify the cost. Finally, with the growth of the gMock matcher library, we are encouraging people to use the unified `EXPECT_THAT(value, matcher)` syntax more often in tests. One @@ -127,6 +130,7 @@ can much more easily decide which one to use the next time. ## I got some run-time errors about invalid proto descriptors when using `ProtocolMessageEquals`. Help! +{: .callout .note} **Note:** `ProtocolMessageEquals` and `ProtocolMessageEquiv` are *deprecated* now. Please use `EqualsProto`, etc instead. @@ -176,18 +180,6 @@ template argument, and thus doesn't compile in opt mode when `a` contains a call to `htonl()`. It is difficult to make `EXPECT_EQ` bypass the `htonl()` bug, as the solution must work with different compilers on various platforms. -`htonl()` has some other problems as described in `//util/endian/endian.h`, -which defines `ghtonl()` to replace it. `ghtonl()` does the same thing `htonl()` -does, only without its problems. We suggest you to use `ghtonl()` instead of -`htonl()`, both in your tests and production code. - -`//util/endian/endian.h` also defines `ghtons()`, which solves similar problems -in `htons()`. - -Don't forget to add `//util/endian` to the list of dependencies in the `BUILD` -file wherever `ghtonl()` and `ghtons()` are used. The library consists of a -single header file and will not bloat your binary. - ## The compiler complains about "undefined references" to some static const member variables, but I did define them in the class body. What's wrong? If your class has a static data member: @@ -211,6 +203,18 @@ particular, using it in googletest comparison assertions (`EXPECT_EQ`, etc) will generate an "undefined reference" linker error. The fact that "it used to work" doesn't mean it's valid. It just means that you were lucky. :-) +If the declaration of the static data member is `constexpr` then it is +implicitly an `inline` definition, and a separate definition in `foo.cc` is not +needed: + +```c++ +// foo.h +class Foo { + ... + static constexpr int kBar = 100; // Defines kBar, no need to do it in foo.cc. +}; +``` + ## Can I derive a test fixture from another? Yes. @@ -263,7 +267,7 @@ If necessary, you can continue to derive test fixtures from a derived fixture. googletest has no limit on how deep the hierarchy can be. For a complete example using derived test fixtures, see -[sample5_unittest.cc](../samples/sample5_unittest.cc). +[sample5_unittest.cc](https://github.com/google/googletest/blob/master/googletest/samples/sample5_unittest.cc). ## My compiler complains "void value not ignored as it ought to be." What does this mean? @@ -275,8 +279,9 @@ disabled by our build system. Please see more details ## My death test hangs (or seg-faults). How do I fix it? In googletest, death tests are run in a child process and the way they work is -delicate. To write death tests you really need to understand how they work. -Please make sure you have read [this](advanced.md#how-it-works). +delicate. To write death tests you really need to understand how they work—see +the details at [Death Assertions](reference/assertions.md#death) in the +Assertions Reference. In particular, death tests don't like having multiple threads in the parent process. So the first thing you can try is to eliminate creating threads outside @@ -295,7 +300,7 @@ program from the beginning in the child process. Therefore make sure your program can run side-by-side with itself and is deterministic. In the end, this boils down to good concurrent programming. You have to make -sure that there is no race conditions or dead locks in your program. No silver +sure that there are no race conditions or deadlocks in your program. No silver bullet - sorry! ## Should I use the constructor/destructor of the test fixture or SetUp()/TearDown()? {#CtorVsSetUp} @@ -332,8 +337,8 @@ You may still want to use `SetUp()/TearDown()` in the following cases: * In the body of a constructor (or destructor), it's not possible to use the `ASSERT_xx` macros. Therefore, if the set-up operation could cause a fatal test failure that should prevent the test from running, it's necessary to - use `abort` and abort the whole test executable, - or to use `SetUp()` instead of a constructor. + use `abort` and abort the whole test + executable, or to use `SetUp()` instead of a constructor. * If the tear-down operation could throw an exception, you must use `TearDown()` as opposed to the destructor, as throwing in a destructor leads to undefined behavior and usually will kill your program right away. Note @@ -349,72 +354,8 @@ You may still want to use `SetUp()/TearDown()` in the following cases: ## The compiler complains "no matching function to call" when I use ASSERT_PRED*. How do I fix it? -If the predicate function you use in `ASSERT_PRED*` or `EXPECT_PRED*` is -overloaded or a template, the compiler will have trouble figuring out which -overloaded version it should use. `ASSERT_PRED_FORMAT*` and -`EXPECT_PRED_FORMAT*` don't have this problem. - -If you see this error, you might want to switch to -`(ASSERT|EXPECT)_PRED_FORMAT*`, which will also give you a better failure -message. If, however, that is not an option, you can resolve the problem by -explicitly telling the compiler which version to pick. - -For example, suppose you have - -```c++ -bool IsPositive(int n) { - return n > 0; -} - -bool IsPositive(double x) { - return x > 0; -} -``` - -you will get a compiler error if you write - -```c++ -EXPECT_PRED1(IsPositive, 5); -``` - -However, this will work: - -```c++ -EXPECT_PRED1(static_cast(IsPositive), 5); -``` - -(The stuff inside the angled brackets for the `static_cast` operator is the type -of the function pointer for the `int`-version of `IsPositive()`.) - -As another example, when you have a template function - -```c++ -template -bool IsNegative(T x) { - return x < 0; -} -``` - -you can use it in a predicate assertion like this: - -```c++ -ASSERT_PRED1(IsNegative, -5); -``` - -Things are more interesting if your template has more than one parameters. The -following won't compile: - -```c++ -ASSERT_PRED2(GreaterThan, 5, 0); -``` - -as the C++ pre-processor thinks you are giving `ASSERT_PRED2` 4 arguments, which -is one more than expected. The workaround is to wrap the predicate function in -parentheses: - -```c++ -ASSERT_PRED2((GreaterThan), 5, 0); -``` +See details for [`EXPECT_PRED*`](reference/assertions.md#EXPECT_PRED) in the +Assertions Reference. ## My compiler complains about "ignoring return value" when I call RUN_ALL_TESTS(). Why? @@ -531,8 +472,8 @@ There are several good reasons: ## What can the statement argument in ASSERT_DEATH() be? -`ASSERT_DEATH(*statement*, *regex*)` (or any death assertion macro) can be used -wherever `*statement*` is valid. So basically `*statement*` can be any C++ +`ASSERT_DEATH(statement, matcher)` (or any death assertion macro) can be used +wherever *`statement`* is valid. So basically *`statement`* can be any C++ statement that makes sense in the current context. In particular, it can reference global and/or local variables, and can be: @@ -555,7 +496,7 @@ TEST(MyDeathTest, ComplexExpression) { "(Func1|Method) failed"); } -// Death assertions can be used any where in a function. In +// Death assertions can be used anywhere in a function. In // particular, they can be inside a loop. TEST(MyDeathTest, InsideLoop) { // Verifies that Foo(0), Foo(1), ..., and Foo(4) all die. @@ -578,8 +519,6 @@ TEST(MyDeathTest, CompoundStatement) { } ``` -gtest-death-test_test.cc contains more examples if you are interested. - ## I have a fixture class `FooTest`, but `TEST_F(FooTest, Bar)` gives me error ``"no matching function for call to `FooTest::FooTest()'"``. Why? Googletest needs to be able to create objects of your test fixture class, so it @@ -597,7 +536,7 @@ However, there are cases where you have to define your own: ## Why does ASSERT_DEATH complain about previous threads that were already joined? With the Linux pthread library, there is no turning back once you cross the line -from single thread to multiple threads. The first time you create a thread, a +from a single thread to multiple threads. The first time you create a thread, a manager thread is created in addition, so you get 3, not 2, threads. Later when the thread you create joins the main thread, the thread count decrements by 1, but the manager thread will never be killed, so you still have 2 threads, which @@ -612,7 +551,7 @@ runs on, you shouldn't depend on this. googletest does not interleave tests from different test suites. That is, it runs all tests in one test suite first, and then runs all tests in the next test suite, and so on. googletest does this because it needs to set up a test suite -before the first test in it is run, and tear it down afterwords. Splitting up +before the first test in it is run, and tear it down afterwards. Splitting up the test case would require multiple set-up and tear-down processes, which is inefficient and makes the semantics unclean. @@ -661,14 +600,15 @@ break the death test (e.g. by changing the regex pattern it is expected to match). Admittedly, this is a hack. We'll consider a more permanent solution after the fork-and-exec-style death tests are implemented. -## The compiler complains about "no match for 'operator<<'" when I use an assertion. What gives? +## The compiler complains about `no match for 'operator<<'` when I use an assertion. What gives? If you use a user-defined type `FooType` in an assertion, you must make sure there is an `std::ostream& operator<<(std::ostream&, const FooType&)` function defined such that we can print a value of `FooType`. In addition, if `FooType` is declared in a name space, the `<<` operator also -needs to be defined in the *same* name space. See https://abseil.io/tips/49 for details. +needs to be defined in the *same* name space. See +[Tip of the Week #49](http://abseil.io/tips/49) for details. ## How do I suppress the memory leak messages on Windows? @@ -689,10 +629,10 @@ mistake in production. Such cleverness also leads to advise against the practice, and googletest doesn't provide a way to do it. In general, the recommended way to cause the code to behave differently under -test is [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection). You can inject +test is [Dependency Injection](http://en.wikipedia.org/wiki/Dependency_injection). You can inject different functionality from the test and from the production code. Since your production code doesn't link in the for-test logic at all (the -[`testonly`](https://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly) attribute for BUILD targets helps to ensure +[`testonly`](http://docs.bazel.build/versions/master/be/common-definitions.html#common.testonly) attribute for BUILD targets helps to ensure that), there is no danger in accidentally running it. However, if you *really*, *really*, *really* have no choice, and if you follow @@ -703,12 +643,12 @@ whether the code is under test. ## How do I temporarily disable a test? If you have a broken test that you cannot fix right away, you can add the -DISABLED_ prefix to its name. This will exclude it from execution. This is -better than commenting out the code or using #if 0, as disabled tests are still -compiled (and thus won't rot). +`DISABLED_` prefix to its name. This will exclude it from execution. This is +better than commenting out the code or using `#if 0`, as disabled tests are +still compiled (and thus won't rot). To include disabled tests in test execution, just invoke the test program with -the --gtest_also_run_disabled_tests flag. +the `--gtest_also_run_disabled_tests` flag. ## Is it OK if I have two separate `TEST(Foo, Bar)` test methods defined in different namespaces? diff --git a/ext/googletest/docs/gmock_cheat_sheet.md b/ext/googletest/docs/gmock_cheat_sheet.md new file mode 100644 index 0000000000..3d164ad629 --- /dev/null +++ b/ext/googletest/docs/gmock_cheat_sheet.md @@ -0,0 +1,241 @@ +# gMock Cheat Sheet + +## Defining a Mock Class + +### Mocking a Normal Class {#MockClass} + +Given + +```cpp +class Foo { + ... + virtual ~Foo(); + virtual int GetSize() const = 0; + virtual string Describe(const char* name) = 0; + virtual string Describe(int type) = 0; + virtual bool Process(Bar elem, int count) = 0; +}; +``` + +(note that `~Foo()` **must** be virtual) we can define its mock as + +```cpp +#include "gmock/gmock.h" + +class MockFoo : public Foo { + ... + MOCK_METHOD(int, GetSize, (), (const, override)); + MOCK_METHOD(string, Describe, (const char* name), (override)); + MOCK_METHOD(string, Describe, (int type), (override)); + MOCK_METHOD(bool, Process, (Bar elem, int count), (override)); +}; +``` + +To create a "nice" mock, which ignores all uninteresting calls, a "naggy" mock, +which warns on all uninteresting calls, or a "strict" mock, which treats them as +failures: + +```cpp +using ::testing::NiceMock; +using ::testing::NaggyMock; +using ::testing::StrictMock; + +NiceMock nice_foo; // The type is a subclass of MockFoo. +NaggyMock naggy_foo; // The type is a subclass of MockFoo. +StrictMock strict_foo; // The type is a subclass of MockFoo. +``` + +{: .callout .note} +**Note:** A mock object is currently naggy by default. We may make it nice by +default in the future. + +### Mocking a Class Template {#MockTemplate} + +Class templates can be mocked just like any class. + +To mock + +```cpp +template +class StackInterface { + ... + virtual ~StackInterface(); + virtual int GetSize() const = 0; + virtual void Push(const Elem& x) = 0; +}; +``` + +(note that all member functions that are mocked, including `~StackInterface()` +**must** be virtual). + +```cpp +template +class MockStack : public StackInterface { + ... + MOCK_METHOD(int, GetSize, (), (const, override)); + MOCK_METHOD(void, Push, (const Elem& x), (override)); +}; +``` + +### Specifying Calling Conventions for Mock Functions + +If your mock function doesn't use the default calling convention, you can +specify it by adding `Calltype(convention)` to `MOCK_METHOD`'s 4th parameter. +For example, + +```cpp + MOCK_METHOD(bool, Foo, (int n), (Calltype(STDMETHODCALLTYPE))); + MOCK_METHOD(int, Bar, (double x, double y), + (const, Calltype(STDMETHODCALLTYPE))); +``` + +where `STDMETHODCALLTYPE` is defined by `` on Windows. + +## Using Mocks in Tests {#UsingMocks} + +The typical work flow is: + +1. Import the gMock names you need to use. All gMock symbols are in the + `testing` namespace unless they are macros or otherwise noted. +2. Create the mock objects. +3. Optionally, set the default actions of the mock objects. +4. Set your expectations on the mock objects (How will they be called? What + will they do?). +5. Exercise code that uses the mock objects; if necessary, check the result + using googletest assertions. +6. When a mock object is destructed, gMock automatically verifies that all + expectations on it have been satisfied. + +Here's an example: + +```cpp +using ::testing::Return; // #1 + +TEST(BarTest, DoesThis) { + MockFoo foo; // #2 + + ON_CALL(foo, GetSize()) // #3 + .WillByDefault(Return(1)); + // ... other default actions ... + + EXPECT_CALL(foo, Describe(5)) // #4 + .Times(3) + .WillRepeatedly(Return("Category 5")); + // ... other expectations ... + + EXPECT_EQ(MyProductionFunction(&foo), "good"); // #5 +} // #6 +``` + +## Setting Default Actions {#OnCall} + +gMock has a **built-in default action** for any function that returns `void`, +`bool`, a numeric value, or a pointer. In C++11, it will additionally returns +the default-constructed value, if one exists for the given type. + +To customize the default action for functions with return type `T`, use +[`DefaultValue`](reference/mocking.md#DefaultValue). For example: + +```cpp + // Sets the default action for return type std::unique_ptr to + // creating a new Buzz every time. + DefaultValue>::SetFactory( + [] { return MakeUnique(AccessLevel::kInternal); }); + + // When this fires, the default action of MakeBuzz() will run, which + // will return a new Buzz object. + EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")).Times(AnyNumber()); + + auto buzz1 = mock_buzzer_.MakeBuzz("hello"); + auto buzz2 = mock_buzzer_.MakeBuzz("hello"); + EXPECT_NE(buzz1, nullptr); + EXPECT_NE(buzz2, nullptr); + EXPECT_NE(buzz1, buzz2); + + // Resets the default action for return type std::unique_ptr, + // to avoid interfere with other tests. + DefaultValue>::Clear(); +``` + +To customize the default action for a particular method of a specific mock +object, use [`ON_CALL`](reference/mocking.md#ON_CALL). `ON_CALL` has a similar +syntax to `EXPECT_CALL`, but it is used for setting default behaviors when you +do not require that the mock method is called. See +[Knowing When to Expect](gmock_cook_book.md#UseOnCall) for a more detailed +discussion. + +## Setting Expectations {#ExpectCall} + +See [`EXPECT_CALL`](reference/mocking.md#EXPECT_CALL) in the Mocking Reference. + +## Matchers {#MatcherList} + +See the [Matchers Reference](reference/matchers.md). + +## Actions {#ActionList} + +See the [Actions Reference](reference/actions.md). + +## Cardinalities {#CardinalityList} + +See the [`Times` clause](reference/mocking.md#EXPECT_CALL.Times) of +`EXPECT_CALL` in the Mocking Reference. + +## Expectation Order + +By default, expectations can be matched in *any* order. If some or all +expectations must be matched in a given order, you can use the +[`After` clause](reference/mocking.md#EXPECT_CALL.After) or +[`InSequence` clause](reference/mocking.md#EXPECT_CALL.InSequence) of +`EXPECT_CALL`, or use an [`InSequence` object](reference/mocking.md#InSequence). + +## Verifying and Resetting a Mock + +gMock will verify the expectations on a mock object when it is destructed, or +you can do it earlier: + +```cpp +using ::testing::Mock; +... +// Verifies and removes the expectations on mock_obj; +// returns true if and only if successful. +Mock::VerifyAndClearExpectations(&mock_obj); +... +// Verifies and removes the expectations on mock_obj; +// also removes the default actions set by ON_CALL(); +// returns true if and only if successful. +Mock::VerifyAndClear(&mock_obj); +``` + +Do not set new expectations after verifying and clearing a mock after its use. +Setting expectations after code that exercises the mock has undefined behavior. +See [Using Mocks in Tests](gmock_for_dummies.md#using-mocks-in-tests) for more +information. + +You can also tell gMock that a mock object can be leaked and doesn't need to be +verified: + +```cpp +Mock::AllowLeak(&mock_obj); +``` + +## Mock Classes + +gMock defines a convenient mock class template + +```cpp +class MockFunction { + public: + MOCK_METHOD(R, Call, (A1, ..., An)); +}; +``` + +See this [recipe](gmock_cook_book.md#UsingCheckPoints) for one application of +it. + +## Flags + +| Flag | Description | +| :----------------------------- | :---------------------------------------- | +| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. | +| `--gmock_verbose=LEVEL` | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. | diff --git a/ext/googletest/googlemock/docs/cook_book.md b/ext/googletest/docs/gmock_cook_book.md similarity index 89% rename from ext/googletest/googlemock/docs/cook_book.md rename to ext/googletest/docs/gmock_cook_book.md index ea55ab3583..c08958eb16 100644 --- a/ext/googletest/googlemock/docs/cook_book.md +++ b/ext/googletest/docs/gmock_cook_book.md @@ -1,10 +1,10 @@ # gMock Cookbook - - You can find recipes for using gMock here. If you haven't yet, please read -[this](for_dummies.md) first to make sure you understand the basics. +[the dummy guide](gmock_for_dummies.md) first to make sure you understand the +basics. +{: .callout .note} **Note:** gMock lives in the `testing` name space. For readability, it is recommended to write `using ::testing::Foo;` once in your file before using the name `Foo` defined by gMock. We omit such `using` statements in this section for @@ -35,13 +35,17 @@ generated method: `noexcept` method. * **`Calltype(...)`** - Sets the call type for the method (e.g. to `STDMETHODCALLTYPE`), useful in Windows. +* **`ref(...)`** - Marks the method with the reference qualification + specified. Required if overriding a method that has reference + qualifications. Eg `ref(&)` or `ref(&&)`. ### Dealing with unprotected commas Unprotected commas, i.e. commas which are not surrounded by parentheses, prevent `MOCK_METHOD` from parsing its arguments correctly: -```cpp {.bad} +{: .bad} +```cpp class MockFoo { public: MOCK_METHOD(std::pair, GetPair, ()); // Won't compile! @@ -51,7 +55,8 @@ class MockFoo { Solution 1 - wrap with parentheses: -```cpp {.good} +{: .good} +```cpp class MockFoo { public: MOCK_METHOD((std::pair), GetPair, ()); @@ -64,7 +69,8 @@ invalid C++. `MOCK_METHOD` removes the parentheses. Solution 2 - define an alias: -```cpp {.good} +{: .good} +```cpp class MockFoo { public: using BoolAndInt = std::pair; @@ -138,6 +144,7 @@ class MockFoo : public Foo { }; ``` +{: .callout .note} **Note:** if you don't mock all versions of the overloaded method, the compiler will give you a warning about some methods in the base class being hidden. To fix that, use `using` to bring them in scope: @@ -177,8 +184,7 @@ class MockStack : public StackInterface { ### Mocking Non-virtual Methods {#MockingNonVirtualMethods} -gMock can mock non-virtual functions to be used in Hi-perf dependency -injection. +gMock can mock non-virtual functions to be used in Hi-perf dependency injection. In this case, instead of sharing a common base class with the real class, your mock class will be *unrelated* to the real class, but contain methods with the @@ -245,9 +251,9 @@ tests. ### Mocking Free Functions -It's possible to use gMock to mock a free function (i.e. a C-style function or a -static method). You just need to rewrite your code to use an interface (abstract -class). +It is not possible to directly mock a free function (i.e. a C-style function or +a static method). If you need to, you can rewrite your code to use an interface +(abstract class). Instead of calling a free function (say, `OpenFile`) directly, introduce an interface for it and have a concrete subclass that calls the free function: @@ -262,7 +268,7 @@ class FileInterface { class File : public FileInterface { public: ... - virtual bool Open(const char* path, const char* mode) { + bool Open(const char* path, const char* mode) override { return OpenFile(path, mode); } }; @@ -281,9 +287,11 @@ recipe for [mocking non-virtual methods](#MockingNonVirtualMethods). ### Old-Style `MOCK_METHODn` Macros -Before the generic `MOCK_METHOD` macro was introduced, mocks where created using -a family of macros collectively called `MOCK_METHODn`. These macros are still -supported, though migration to the new `MOCK_METHOD` is recommended. +Before the generic `MOCK_METHOD` macro +[was introduced in 2018](https://github.com/google/googletest/commit/c5f08bf91944ce1b19bcf414fa1760e69d20afc2), +mocks where created using a family of macros collectively called `MOCK_METHODn`. +These macros are still supported, though migration to the new `MOCK_METHOD` is +recommended. The macros in the `MOCK_METHODn` family differ from `MOCK_METHOD`: @@ -297,44 +305,86 @@ The macros in the `MOCK_METHODn` family differ from `MOCK_METHOD`: Old macros and their new equivalents: - - - - - +
Simple
Old `MOCK_METHOD1(Foo, bool(int))`
New `MOCK_METHOD(bool, Foo, (int))`
+ + + + + + + + + - + + + + + + + + + - - + + + + + + + + + - + + + + + + + + + - - + + + + + + + + + - - - + + + + + + + + + - - - - - + + + + + + + + + + + + + + + + + +
Simple
OldMOCK_METHOD1(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int))
Const Method
Old -`MOCK_CONST_METHOD1(Foo, bool(int))`
New -`MOCK_METHOD(bool, Foo, (int), (const))`
Const Method
OldMOCK_CONST_METHOD1(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const))
Method in a Class Template
Old `MOCK_METHOD1_T(Foo, bool(int))`
New -`MOCK_METHOD(bool, Foo, (int))`
Method in a Class Template
OldMOCK_METHOD1_T(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int))
Const Method in a Class Template
Old - `MOCK_CONST_METHOD1_T(Foo, bool(int))`
New - `MOCK_METHOD(bool, Foo, (int), (const))`
Const Method in a Class Template
OldMOCK_CONST_METHOD1_T(Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const))
Method with Call Type
Old -`MOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))`
New `MOCK_METHOD(bool, Foo, (int), -(Calltype(STDMETHODCALLTYPE)))`
Method with Call Type
OldMOCK_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (Calltype(STDMETHODCALLTYPE)))
Const Method with Call Type
Old `MOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))`
New `MOCK_METHOD(bool, Foo, (int), (const, -Calltype(STDMETHODCALLTYPE)))`
Const Method with Call Type
OldMOCK_CONST_METHOD1_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const, Calltype(STDMETHODCALLTYPE)))
Method with Call Type in a Class Template
Old `MOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, -bool(int))`
New `MOCK_METHOD(bool, Foo, (int), -(Calltype(STDMETHODCALLTYPE)))`
Const Method with Call Type in a Class Template
Old `MOCK_CONST_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, -Foo, bool(int))`
New `MOCK_METHOD(bool, Foo, -(int), (const, Calltype(STDMETHODCALLTYPE)))`
Method with Call Type in a Class Template
OldMOCK_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (Calltype(STDMETHODCALLTYPE)))
Const Method with Call Type in a Class Template
OldMOCK_CONST_METHOD1_T_WITH_CALLTYPE(STDMETHODCALLTYPE, Foo, bool(int))
NewMOCK_METHOD(bool, Foo, (int), (const, Calltype(STDMETHODCALLTYPE)))
### The Nice, the Strict, and the Naggy {#NiceStrictNaggy} @@ -405,13 +455,14 @@ TEST(...) { } ``` +{: .callout .note} NOTE: `NiceMock` and `StrictMock` only affects *uninteresting* calls (calls of *methods* with no expectations); they do not affect *unexpected* calls (calls of methods with expectations, but they don't match). See [Understanding Uninteresting vs Unexpected Calls](#uninteresting-vs-unexpected). -There are some caveats though (I dislike them just as much as the next guy, but -sadly they are side effects of C++'s limitations): +There are some caveats though (sadly they are side effects of C++'s +limitations): 1. `NiceMock` and `StrictMock` only work for mock methods defined using the `MOCK_METHOD` macro **directly** in the `MockFoo` class. @@ -421,17 +472,7 @@ sadly they are side effects of C++'s limitations): `NiceMock >`) is **not** supported. 2. `NiceMock` and `StrictMock` may not work correctly if the destructor of `MockFoo` is not virtual. We would like to fix this, but it - requires cleaning up existing tests. http://b/28934720 tracks the issue. -3. During the constructor or destructor of `MockFoo`, the mock object is *not* - nice or strict. This may cause surprises if the constructor or destructor - calls a mock method on `this` object. (This behavior, however, is consistent - with C++'s general rule: if a constructor or destructor calls a virtual - method of `this` object, that method is treated as non-virtual. In other - words, to the base class's constructor or destructor, `this` object behaves - like an instance of the base class, not the derived class. This rule is - required for safety. Otherwise a base constructor may use members of a - derived class before they are initialized, or a base destructor may use - members of a derived class after they have been destroyed.) + requires cleaning up existing tests. Finally, you should be **very cautious** about when to use naggy or strict mocks, as they tend to make tests more brittle and harder to maintain. When you @@ -471,9 +512,9 @@ The trick is to redispatch the method in the mock class: class ScopedMockLog : public LogSink { public: ... - virtual void send(LogSeverity severity, const char* full_filename, + void send(LogSeverity severity, const char* full_filename, const char* base_filename, int line, const tm* tm_time, - const char* message, size_t message_len) { + const char* message, size_t message_len) override { // We are only interested in the log severity, full file name, and // log message. Log(severity, full_filename, std::string(message, message_len)); @@ -513,7 +554,7 @@ argument matchers: ```cpp ON_CALL(factory, DoMakeTurtle) - .WillByDefault(MakeMockTurtle()); + .WillByDefault(Return(MakeMockTurtle())); ``` ### Alternative to Mocking Concrete Classes @@ -777,28 +818,12 @@ perhaps your test doesn't need to mock `Concrete()` at all (but it would be oh-so painful to have to define a new mock class whenever you don't need to mock one of its methods). -The trick is to leave a back door in your mock class for accessing the real -methods in the base class: - -```cpp -class MockFoo : public Foo { - public: - // Mocking a pure method. - MOCK_METHOD(void, Pure, (int n), (override)); - // Mocking a concrete method. Foo::Concrete() is shadowed. - MOCK_METHOD(int, Concrete, (const char* str), (override)); - - // Use this to call Concrete() defined in Foo. - int FooConcrete(const char* str) { return Foo::Concrete(str); } -}; -``` - -Now, you can call `Foo::Concrete()` inside an action by: +You can call `Foo::Concrete()` inside an action by: ```cpp ... EXPECT_CALL(foo, Concrete).WillOnce([&foo](const char* str) { - return foo.FooConcrete(str); + return foo.Foo::Concrete(str); }); ``` @@ -807,7 +832,7 @@ or tell the mock object that you don't want to mock `Concrete()`: ```cpp ... ON_CALL(foo, Concrete).WillByDefault([&foo](const char* str) { - return foo.FooConcrete(str); + return foo.Foo::Concrete(str); }); ``` @@ -848,7 +873,6 @@ A frequently used matcher is `_`, which matches anything: ```cpp EXPECT_CALL(foo, DoThat(_, NotNull())); ``` - ### Combining Matchers {#CombiningMatchers} @@ -871,6 +895,22 @@ using ::testing::Not; NULL)); ``` +Matchers are function objects, and parametrized matchers can be composed just +like any other function. However because their types can be long and rarely +provide meaningful information, it can be easier to express them with C++14 +generic lambdas to avoid specifying types. For example, + +```cpp +using ::testing::Contains; +using ::testing::Property; + +inline constexpr auto HasFoo = [](const auto& f) { + return Property(&MyClass::foo, Contains(f)); +}; +... + EXPECT_THAT(x, HasFoo("blah")); +``` + ### Casting Matchers {#SafeMatcherCast} gMock matchers are statically typed, meaning that the compiler can catch your @@ -1024,9 +1064,8 @@ using ::testing::Lt; says that the first argument of `InRange()` must not be 0, and must be less than the second argument. -The expression inside `With()` must be a matcher of type -`Matcher< ::std::tuple >`, where `A1`, ..., `An` are the types of -the function arguments. +The expression inside `With()` must be a matcher of type `Matcher>`, where `A1`, ..., `An` are the types of the function arguments. You can also write `AllArgs(m)` instead of `m` inside `.With()`. The two forms are equivalent, but `.With(AllArgs(Lt()))` is more readable than `.With(Lt())`. @@ -1049,13 +1088,14 @@ z`. Note that in this example, it wasn't necessary specify the positional matchers. As a convenience and example, gMock provides some matchers for 2-tuples, -including the `Lt()` matcher above. See [here](#MultiArgMatchers) for the +including the `Lt()` matcher above. See +[Multi-argument Matchers](reference/matchers.md#MultiArgMatchers) for the complete list. Note that if you want to pass the arguments to a predicate of your own (e.g. `.With(Args<0, 1>(Truly(&MyPredicate)))`), that predicate MUST be written to -take a `::std::tuple` as its argument; gMock will pass the `n` selected -arguments as *one* single tuple to the predicate. +take a `std::tuple` as its argument; gMock will pass the `n` selected arguments +as *one* single tuple to the predicate. ### Using Matchers as Predicates @@ -1097,58 +1137,17 @@ Matches(AllOf(Ge(0), Le(100), Ne(50))) ### Using Matchers in googletest Assertions -Since matchers are basically predicates that also know how to describe -themselves, there is a way to take advantage of them in googletest assertions. -It's called `ASSERT_THAT` and `EXPECT_THAT`: - -```cpp - ASSERT_THAT(value, matcher); // Asserts that value matches matcher. - EXPECT_THAT(value, matcher); // The non-fatal version. -``` - -For example, in a googletest test you can write: - -```cpp -#include "gmock/gmock.h" - -using ::testing::AllOf; -using ::testing::Ge; -using ::testing::Le; -using ::testing::MatchesRegex; -using ::testing::StartsWith; - -... - EXPECT_THAT(Foo(), StartsWith("Hello")); - EXPECT_THAT(Bar(), MatchesRegex("Line \\d+")); - ASSERT_THAT(Baz(), AllOf(Ge(5), Le(10))); -``` - -which (as you can probably guess) executes `Foo()`, `Bar()`, and `Baz()`, and -verifies that: - -* `Foo()` returns a string that starts with `"Hello"`. -* `Bar()` returns a string that matches regular expression `"Line \\d+"`. -* `Baz()` returns a number in the range [5, 10]. - -The nice thing about these macros is that *they read like English*. They -generate informative messages too. For example, if the first `EXPECT_THAT()` -above fails, the message will be something like: - -```cpp -Value of: Foo() - Actual: "Hi, world!" -Expected: starts with "Hello" -``` - -**Credit:** The idea of `(ASSERT|EXPECT)_THAT` was borrowed from Joe Walnes' -Hamcrest project, which adds `assertThat()` to JUnit. +See [`EXPECT_THAT`](reference/assertions.md#EXPECT_THAT) in the Assertions +Reference. ### Using Predicates as Matchers -gMock provides a [built-in set](#MatcherList) of matchers. In case you find them -lacking, you can use an arbitrary unary predicate function or functor as a -matcher - as long as the predicate accepts a value of the type you want. You do -this by wrapping the predicate inside the `Truly()` function, for example: +gMock provides a set of built-in matchers for matching arguments with expected +values—see the [Matchers Reference](reference/matchers.md) for more information. +In case you find the built-in set lacking, you can use an arbitrary unary +predicate function or functor as a matcher - as long as the predicate accepts a +value of the type you want. You do this by wrapping the predicate inside the +`Truly()` function, for example: ```cpp using ::testing::Truly; @@ -1163,8 +1162,6 @@ Note that the predicate function / functor doesn't have to return `bool`. It works as long as the return value can be used as the condition in in statement `if (condition) ...`. - - ### Matching Arguments that Are Not Copyable When you do an `EXPECT_CALL(mock_obj, Foo(bar))`, gMock saves away a copy of @@ -1181,15 +1178,14 @@ executed. Just tell gMock that it should save a reference to `bar`, instead of a copy of it. Here's how: ```cpp -using ::testing::ByRef; using ::testing::Eq; using ::testing::Lt; ... // Expects that Foo()'s argument == bar. - EXPECT_CALL(mock_obj, Foo(Eq(ByRef(bar)))); + EXPECT_CALL(mock_obj, Foo(Eq(std::ref(bar)))); // Expects that Foo()'s argument < bar. - EXPECT_CALL(mock_obj, Foo(Lt(ByRef(bar)))); + EXPECT_CALL(mock_obj, Foo(Lt(std::ref(bar)))); ``` Remember: if you do this, don't change `bar` after the `EXPECT_CALL()`, or the @@ -1219,17 +1215,17 @@ that satisfies matcher `m`. For example: - | Expression | Description | | :--------------------------- | :--------------------------------------- | | `Field(&Foo::number, Ge(3))` | Matches `x` where `x.number >= 3`. | | `Property(&Foo::name, StartsWith("John "))` | Matches `x` where `x.name()` starts with `"John "`. | - Note that in `Property(&Foo::baz, ...)`, method `baz()` must take no argument -and be declared as `const`. +and be declared as `const`. Don't use `Property()` against member functions that +you do not own, because taking addresses of functions is fragile and generally +not part of the contract of the function. -BTW, `Field()` and `Property()` can also match plain pointers to objects. For +`Field()` and `Property()` can also match plain pointers to objects. For instance, ```cpp @@ -1318,32 +1314,30 @@ how you can define a matcher to do it: ```cpp using ::testing::Matcher; -using ::testing::MatcherInterface; -using ::testing::MatchResultListener; -class BarPlusBazEqMatcher : public MatcherInterface { +class BarPlusBazEqMatcher { public: explicit BarPlusBazEqMatcher(int expected_sum) : expected_sum_(expected_sum) {} bool MatchAndExplain(const Foo& foo, - MatchResultListener* /* listener */) const override { + std::ostream* /* listener */) const { return (foo.bar() + foo.baz()) == expected_sum_; } - void DescribeTo(::std::ostream* os) const override { - *os << "bar() + baz() equals " << expected_sum_; + void DescribeTo(std::ostream& os) const { + os << "bar() + baz() equals " << expected_sum_; } - void DescribeNegationTo(::std::ostream* os) const override { - *os << "bar() + baz() does not equal " << expected_sum_; + void DescribeNegationTo(std::ostream& os) const { + os << "bar() + baz() does not equal " << expected_sum_; } private: const int expected_sum_; }; Matcher BarPlusBazEq(int expected_sum) { - return MakeMatcher(new BarPlusBazEqMatcher(expected_sum)); + return BarPlusBazEqMatcher(expected_sum); } ... @@ -1423,6 +1417,8 @@ using ::testing::ElementsAreArray; Use `Pair` when comparing maps or other associative containers. +{% raw %} + ```cpp using testing::ElementsAre; using testing::Pair; @@ -1431,6 +1427,8 @@ using testing::Pair; EXPECT_THAT(m, ElementsAre(Pair("a", 1), Pair("b", 2), Pair("c", 3))); ``` +{% endraw %} + **Tips:** * `ElementsAre*()` can be used to match *any* container that implements the @@ -1469,6 +1467,7 @@ using ::testing::Matcher; ### Matchers must have no side-effects {#PureMatchers} +{: .callout .warning} WARNING: gMock does not guarantee when or how many times a matcher will be invoked. Therefore, all matchers must be *purely functional*: they cannot have any side effects, and the match result must not depend on anything other than @@ -1483,8 +1482,6 @@ mock object and gMock. ### Knowing When to Expect {#UseOnCall} - - **`ON_CALL`** is likely the *single most under-utilized construct* in gMock. There are basically two constructs for defining the behavior of a mock object: @@ -1676,11 +1673,11 @@ times from calling it with the wrong arguments. ### Expecting Ordered Calls {#OrderedCalls} -Although an `EXPECT_CALL()` statement defined earlier takes precedence when -gMock tries to match a function call with an expectation, by default calls don't -have to happen in the order `EXPECT_CALL()` statements are written. For example, -if the arguments match the matchers in the third `EXPECT_CALL()`, but not those -in the first two, then the third expectation will be used. +Although an `EXPECT_CALL()` statement defined later takes precedence when gMock +tries to match a function call with an expectation, by default calls don't have +to happen in the order `EXPECT_CALL()` statements are written. For example, if +the arguments match the matchers in the second `EXPECT_CALL()`, but not those in +the first and third, then the second expectation will be used. If you would rather have all calls occur in the order of the expectations, put the `EXPECT_CALL()` statements in a block where you define a variable of type @@ -1713,8 +1710,8 @@ brittle tests. For example, we may care about `A` occurring before both `B` and the test should reflect our real intent, instead of being overly constraining. gMock allows you to impose an arbitrary DAG (directed acyclic graph) on the -calls. One way to express the DAG is to use the [After](#AfterClause) clause of -`EXPECT_CALL`. +calls. One way to express the DAG is to use the +[`After` clause](reference/mocking.md#EXPECT_CALL.After) of `EXPECT_CALL`. Another way is via the `InSequence()` clause (not the same as the `InSequence` class), which we borrowed from jMock 2. It's less flexible than `After()`, but @@ -1852,10 +1849,9 @@ Methods"). However, gMock doesn't let you use `ReturnRef()` in a mock function whose return type is not a reference, as doing that usually indicates a user error. So, what shall you do? -Though you may be tempted, DO NOT use `ByRef()`: +Though you may be tempted, DO NOT use `std::ref()`: ```cpp -using testing::ByRef; using testing::Return; class MockFoo : public Foo { @@ -1866,7 +1862,7 @@ class MockFoo : public Foo { int x = 0; MockFoo foo; EXPECT_CALL(foo, GetValue()) - .WillRepeatedly(Return(ByRef(x))); // Wrong! + .WillRepeatedly(Return(std::ref(x))); // Wrong! x = 42; EXPECT_EQ(42, foo.GetValue()); ``` @@ -1882,9 +1878,9 @@ Expected: 42 The reason is that `Return(*value*)` converts `value` to the actual return type of the mock function at the time when the action is *created*, not when it is *executed*. (This behavior was chosen for the action to be safe when `value` is -a proxy object that references some temporary objects.) As a result, `ByRef(x)` -is converted to an `int` value (instead of a `const int&`) when the expectation -is set, and `Return(ByRef(x))` will always return 0. +a proxy object that references some temporary objects.) As a result, +`std::ref(x)` is converted to an `int` value (instead of a `const int&`) when +the expectation is set, and `Return(std::ref(x))` will always return 0. `ReturnPointee(pointer)` was provided to solve this problem specifically. It returns the value pointed to by `pointer` at the time the action is *executed*: @@ -2129,7 +2125,7 @@ class MockFoo : public Foo { DefaultValue::Clear(); ``` -Please note that changing the default value for a type can make you tests hard +Please note that changing the default value for a type can make your tests hard to understand. We recommend you to use this feature judiciously. For example, you may want to make sure the `Set()` and `Clear()` calls are right next to the code that uses your mock. @@ -2175,9 +2171,7 @@ own precedence order distinct from the `ON_CALL` precedence order. ### Using Functions/Methods/Functors/Lambdas as Actions {#FunctionsAsActions} If the built-in actions don't suit you, you can use an existing callable -(function, `std::function`, method, functor, lambda as an action. - - +(function, `std::function`, method, functor, lambda) as an action. ```cpp using ::testing::_; using ::testing::Invoke; @@ -2203,7 +2197,8 @@ class Helper { .WillOnce(&CalculateSum) .WillRepeatedly(Invoke(NewPermanentCallback(Sum3, 1))); EXPECT_CALL(foo, ComplexJob(_)) - .WillOnce(Invoke(&helper, &Helper::ComplexJob)); + .WillOnce(Invoke(&helper, &Helper::ComplexJob)) + .WillOnce([] { return true; }) .WillRepeatedly([](int x) { return x > 0; }); foo.Sum(5, 6); // Invokes CalculateSum(5, 6). @@ -2213,13 +2208,13 @@ class Helper { ``` The only requirement is that the type of the function, etc must be *compatible* -with the signature of the mock function, meaning that the latter's arguments can -be implicitly converted to the corresponding arguments of the former, and the -former's return type can be implicitly converted to that of the latter. So, you -can invoke something whose type is *not* exactly the same as the mock function, -as long as it's safe to do so - nice, huh? +with the signature of the mock function, meaning that the latter's arguments (if +it takes any) can be implicitly converted to the corresponding arguments of the +former, and the former's return type can be implicitly converted to that of the +latter. So, you can invoke something whose type is *not* exactly the same as the +mock function, as long as it's safe to do so - nice, huh? -**`Note:`{.escaped}** +Note that: * The action takes ownership of the callback and will delete it when the action itself is destructed. @@ -2268,19 +2263,20 @@ TEST_F(FooTest, Test) { ### Invoking a Function/Method/Functor/Lambda/Callback Without Arguments -`Invoke()` is very useful for doing actions that are more complex. It passes the -mock function's arguments to the function, etc being invoked such that the -callee has the full context of the call to work with. If the invoked function is -not interested in some or all of the arguments, it can simply ignore them. +`Invoke()` passes the mock function's arguments to the function, etc being +invoked such that the callee has the full context of the call to work with. If +the invoked function is not interested in some or all of the arguments, it can +simply ignore them. Yet, a common pattern is that a test author wants to invoke a function without -the arguments of the mock function. `Invoke()` allows her to do that using a -wrapper function that throws away the arguments before invoking an underlining -nullary function. Needless to say, this can be tedious and obscures the intent -of the test. +the arguments of the mock function. She could do that using a wrapper function +that throws away the arguments before invoking an underlining nullary function. +Needless to say, this can be tedious and obscures the intent of the test. -`InvokeWithoutArgs()` solves this problem. It's like `Invoke()` except that it -doesn't pass the mock function's arguments to the callee. Here's an example: +There are two solutions to this problem. First, you can pass any callable of +zero args as an action. Alternatively, use `InvokeWithoutArgs()`, which is like +`Invoke()` except that it doesn't pass the mock function's arguments to the +callee. Here's an example of each: ```cpp using ::testing::_; @@ -2297,14 +2293,14 @@ bool Job2(int n, char c) { ... } ... MockFoo foo; EXPECT_CALL(foo, ComplexJob(_)) - .WillOnce(InvokeWithoutArgs(Job1)) + .WillOnce([] { Job1(); }); .WillOnce(InvokeWithoutArgs(NewPermanentCallback(Job2, 5, 'a'))); foo.ComplexJob(10); // Invokes Job1(). foo.ComplexJob(20); // Invokes Job2(5, 'a'). ``` -**`Note:`{.escaped}** +Note that: * The action takes ownership of the callback and will delete it when the action itself is destructed. @@ -2347,6 +2343,7 @@ using ::testing::_; // second argument DoThis() receives. ``` +{: .callout .note} NOTE: The section below is legacy documentation from before C++ had lambdas: Arghh, you need to refer to a mock function argument but C++ has no lambda @@ -2375,7 +2372,7 @@ using ::testing::InvokeArgument; ``` What if the callable takes an argument by reference? No problem - just wrap it -inside `ByRef()`: +inside `std::ref()`: ```cpp ... @@ -2384,20 +2381,19 @@ inside `ByRef()`: (override)); ... using ::testing::_; - using ::testing::ByRef; using ::testing::InvokeArgument; ... MockFoo foo; Helper helper; ... EXPECT_CALL(foo, Bar(_)) - .WillOnce(InvokeArgument<0>(5, ByRef(helper))); - // ByRef(helper) guarantees that a reference to helper, not a copy of it, - // will be passed to the callback. + .WillOnce(InvokeArgument<0>(5, std::ref(helper))); + // std::ref(helper) guarantees that a reference to helper, not a copy of + // it, will be passed to the callback. ``` What if the callable takes an argument by reference and we do **not** wrap the -argument in `ByRef()`? Then `InvokeArgument()` will *make a copy* of the +argument in `std::ref()`? Then `InvokeArgument()` will *make a copy* of the argument, and pass a *reference to the copy*, instead of a reference to the original value, to the callable. This is especially handy when the argument is a temporary value: @@ -2668,26 +2664,18 @@ behavior nondeterministic. A better way is to use gMock actions and `Notification` objects to force your asynchronous test to behave synchronously. ```cpp -using ::testing::DoAll; -using ::testing::InvokeWithoutArgs; -using ::testing::Return; - class MockEventDispatcher : public EventDispatcher { MOCK_METHOD(bool, DispatchEvent, (int32), (override)); }; -ACTION_P(Notify, notification) { - notification->Notify(); -} - TEST(EventQueueTest, EnqueueEventTest) { MockEventDispatcher mock_event_dispatcher; EventQueue event_queue(&mock_event_dispatcher); const int32 kEventId = 321; - Notification done; + absl::Notification done; EXPECT_CALL(mock_event_dispatcher, DispatchEvent(kEventId)) - .WillOnce(Notify(&done)); + .WillOnce([&done] { done.Notify(); }); event_queue.EnqueueEvent(kEventId); done.WaitForNotification(); @@ -2700,6 +2688,7 @@ additional action to notify the `Notification` object. Now we can just call asynchronous call to finish. After that, our test suite is complete and we can safely exit. +{: .callout .note} Note: this example has a downside: namely, if the expectation is not satisfied, our test will run forever. It will eventually time-out and fail, but it will take longer and be slightly harder to debug. To alleviate this problem, you can @@ -2850,8 +2839,8 @@ work with non-copyable objects; you'll have to use functors instead. #### Legacy workarounds for move-only types {#LegacyMoveOnly} Support for move-only function arguments was only introduced to gMock in April -2017. In older code, you may encounter the following workaround for the lack of -this feature (it is no longer necessary - we're including it just for +of 2017. In older code, you may encounter the following workaround for the lack +of this feature (it is no longer necessary - we're including it just for reference): ```cpp @@ -2979,36 +2968,27 @@ TEST(MyServerTest, ProcessesRequest) { } // server is destroyed when it goes out of scope here. ``` +{: .callout .tip} **Tip:** The `Mock::VerifyAndClearExpectations()` function returns a `bool` to indicate whether the verification was successful (`true` for yes), so you can wrap that function call inside a `ASSERT_TRUE()` if there is no point going further when the verification has failed. -### Using Check Points {#UsingCheckPoints} +Do not set new expectations after verifying and clearing a mock after its use. +Setting expectations after code that exercises the mock has undefined behavior. +See [Using Mocks in Tests](gmock_for_dummies.md#using-mocks-in-tests) for more +information. -Sometimes you may want to "reset" a mock object at various check points in your -test: at each check point, you verify that all existing expectations on the mock -object have been satisfied, and then you set some new expectations on it as if -it's newly created. This allows you to work with a mock object in "phases" whose -sizes are each manageable. +### Using Checkpoints {#UsingCheckPoints} -One such scenario is that in your test's `SetUp()` function, you may want to put -the object you are testing into a certain state, with the help from a mock -object. Once in the desired state, you want to clear all expectations on the -mock, such that in the `TEST_F` body you can set fresh expectations on it. +Sometimes you might want to test a mock object's behavior in phases whose sizes +are each manageable, or you might want to set more detailed expectations about +which API calls invoke which mock functions. -As you may have figured out, the `Mock::VerifyAndClearExpectations()` function -we saw in the previous recipe can help you here. Or, if you are using -`ON_CALL()` to set default actions on the mock object and want to clear the -default actions as well, use `Mock::VerifyAndClear(&mock_object)` instead. This -function does what `Mock::VerifyAndClearExpectations(&mock_object)` does and -returns the same `bool`, **plus** it clears the `ON_CALL()` statements on -`mock_object` too. - -Another trick you can use to achieve the same effect is to put the expectations -in sequences and insert calls to a dummy "check-point" function at specific -places. Then you can verify that the mock function calls do happen at the right -time. For example, if you are exercising code: +A technique you can use is to put the expectations in a sequence and insert +calls to a dummy "checkpoint" function at specific places. Then you can verify +that the mock function calls do happen at the right time. For example, if you +are exercising the code: ```cpp Foo(1); @@ -3017,7 +2997,7 @@ time. For example, if you are exercising code: ``` and want to verify that `Foo(1)` and `Foo(3)` both invoke `mock.Bar("a")`, but -`Foo(2)` doesn't invoke anything. You can write: +`Foo(2)` doesn't invoke anything, you can write: ```cpp using ::testing::MockFunction; @@ -3043,10 +3023,10 @@ TEST(FooTest, InvokesBarCorrectly) { } ``` -The expectation spec says that the first `Bar("a")` must happen before check -point "1", the second `Bar("a")` must happen after check point "2", and nothing -should happen between the two check points. The explicit check points make it -easy to tell which `Bar("a")` is called by which call to `Foo()`. +The expectation spec says that the first `Bar("a")` call must happen before +checkpoint "1", the second `Bar("a")` call must happen after checkpoint "2", and +nothing should happen between the two checkpoints. The explicit checkpoints make +it clear which `Bar("a")` is called by which call to `Foo()`. ### Mocking Destructors @@ -3072,7 +3052,7 @@ class MockFoo : public Foo { ... // Add the following two lines to the mock class. MOCK_METHOD(void, Die, ()); - virtual ~MockFoo() { Die(); } + ~MockFoo() override { Die(); } }; ``` @@ -3271,8 +3251,6 @@ If you are interested in the mock call trace but not the stack traces, you can combine `--gmock_verbose=info` with `--gtest_stack_trace_depth=0` on the test command line. - - ### Running Tests in Emacs If you build and run your tests in Emacs using the `M-x google-compile` command @@ -3297,6 +3275,7 @@ after typing `M-m`), or `M-up`/`M-down` to move back and forth between errors. ### Writing New Matchers Quickly {#NewMatchers} +{: .callout .warning} WARNING: gMock does not guarantee when or how many times a matcher will be invoked. Therefore, all matchers must be functionally pure. See [this section](#PureMatchers) for more details. @@ -3341,7 +3320,7 @@ or, ```cpp using ::testing::Not; ... - // Verifies that two values are divisible by 7. + // Verifies that a value is divisible by 7 and the other is not. EXPECT_THAT(some_expression, IsDivisibleBy7()); EXPECT_THAT(some_other_expression, Not(IsDivisibleBy7())); ``` @@ -3400,6 +3379,7 @@ match succeeds in case of a success (unless it's obvious) - this is useful when the matcher is used inside `Not()`. There is no need to print the argument value itself, as gMock already prints it for you. +{: .callout .note} NOTE: The type of the value being matched (`arg_type`) is determined by the context in which you use the matcher and is supplied to you by the compiler, so you don't need to worry about declaring it (nor can you). This allows the @@ -3538,51 +3518,39 @@ MATCHER_P2(Blah, a, b, description_string_2) { ... } ``` While it's tempting to always use the `MATCHER*` macros when defining a new -matcher, you should also consider implementing `MatcherInterface` or using -`MakePolymorphicMatcher()` instead (see the recipes that follow), especially if -you need to use the matcher a lot. While these approaches require more work, -they give you more control on the types of the value being matched and the -matcher parameters, which in general leads to better compiler error messages -that pay off in the long run. They also allow overloading matchers based on -parameter types (as opposed to just based on the number of parameters). +matcher, you should also consider implementing the matcher interface directly +instead (see the recipes that follow), especially if you need to use the matcher +a lot. While these approaches require more work, they give you more control on +the types of the value being matched and the matcher parameters, which in +general leads to better compiler error messages that pay off in the long run. +They also allow overloading matchers based on parameter types (as opposed to +just based on the number of parameters). ### Writing New Monomorphic Matchers -A matcher of argument type `T` implements `::testing::MatcherInterface` and -does two things: it tests whether a value of type `T` matches the matcher, and -can describe what kind of values it matches. The latter ability is used for +A matcher of argument type `T` implements the matcher interface for `T` and does +two things: it tests whether a value of type `T` matches the matcher, and can +describe what kind of values it matches. The latter ability is used for generating readable error messages when expectations are violated. -The interface looks like this: +A matcher of `T` must declare a typedef like: ```cpp -class MatchResultListener { - public: - ... - // Streams x to the underlying ostream; does nothing if the ostream - // is NULL. - template - MatchResultListener& operator<<(const T& x); +using is_gtest_matcher = void; +``` - // Returns the underlying ostream. - ::std::ostream* stream(); -}; +and supports the following operations: -template -class MatcherInterface { - public: - virtual ~MatcherInterface(); +```cpp +// Match a value and optionally explain into an ostream. +bool matched = matcher.MatchAndExplain(value, maybe_os); +// where `value` is of type `T` and +// `maybe_os` is of type `std::ostream*`, where it can be null if the caller +// is not interested in there textual explanation. - // Returns true if and only if the matcher matches x; also explains the match - // result to 'listener'. - virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; - - // Describes this matcher to an ostream. - virtual void DescribeTo(::std::ostream* os) const = 0; - - // Describes the negation of this matcher to an ostream. - virtual void DescribeNegationTo(::std::ostream* os) const; -}; +matcher.DescribeTo(os); +matcher.DescribeNegationTo(os); +// where `os` is of type `std::ostream*`. ``` If you need a custom matcher but `Truly()` is not a good option (for example, @@ -3597,29 +3565,27 @@ For example, you can define a matcher to test whether an `int` is divisible by 7 and then use it like this: ```cpp -using ::testing::MakeMatcher; using ::testing::Matcher; -using ::testing::MatcherInterface; -using ::testing::MatchResultListener; -class DivisibleBy7Matcher : public MatcherInterface { +class DivisibleBy7Matcher { public: - bool MatchAndExplain(int n, - MatchResultListener* /* listener */) const override { + using is_gtest_matcher = void; + + bool MatchAndExplain(int n, std::ostream*) const { return (n % 7) == 0; } - void DescribeTo(::std::ostream* os) const override { + void DescribeTo(std::ostream* os) const { *os << "is divisible by 7"; } - void DescribeNegationTo(::std::ostream* os) const override { + void DescribeNegationTo(std::ostream* os) const { *os << "is not divisible by 7"; } }; Matcher DivisibleBy7() { - return MakeMatcher(new DivisibleBy7Matcher); + return DivisibleBy7Matcher(); } ... @@ -3627,16 +3593,15 @@ Matcher DivisibleBy7() { ``` You may improve the matcher message by streaming additional information to the -`listener` argument in `MatchAndExplain()`: +`os` argument in `MatchAndExplain()`: ```cpp -class DivisibleBy7Matcher : public MatcherInterface { +class DivisibleBy7Matcher { public: - bool MatchAndExplain(int n, - MatchResultListener* listener) const override { + bool MatchAndExplain(int n, std::ostream* os) const { const int remainder = n % 7; - if (remainder != 0) { - *listener << "the remainder is " << remainder; + if (remainder != 0 && os != nullptr) { + *os << "the remainder is " << remainder; } return remainder == 0; } @@ -3652,15 +3617,87 @@ Expected: is divisible by 7 Actual: 23 (the remainder is 2) ``` +{: .callout .tip} +Tip: for convenience, `MatchAndExplain()` can take a `MatchResultListener*` +instead of `std::ostream*`. + ### Writing New Polymorphic Matchers -You've learned how to write your own matchers in the previous recipe. Just one -problem: a matcher created using `MakeMatcher()` only works for one particular -type of arguments. If you want a *polymorphic* matcher that works with arguments -of several types (for instance, `Eq(x)` can be used to match a *`value`* as long -as `value == x` compiles -- *`value`* and `x` don't have to share the same -type), you can learn the trick from `testing/base/public/gmock-matchers.h` but -it's a bit involved. +Expanding what we learned above to *polymorphic* matchers is now just as simple +as adding templates in the right place. + +```cpp + +class NotNullMatcher { + public: + using is_gtest_matcher = void; + + // To implement a polymorphic matcher, we just need to make MatchAndExplain a + // template on its first argument. + + // In this example, we want to use NotNull() with any pointer, so + // MatchAndExplain() accepts a pointer of any type as its first argument. + // In general, you can define MatchAndExplain() as an ordinary method or + // a method template, or even overload it. + template + bool MatchAndExplain(T* p, std::ostream*) const { + return p != nullptr; + } + + // Describes the property of a value matching this matcher. + void DescribeTo(std::ostream* os) const { *os << "is not NULL"; } + + // Describes the property of a value NOT matching this matcher. + void DescribeNegationTo(std::ostream* os) const { *os << "is NULL"; } +}; + +NotNullMatcher NotNull() { + return NotNullMatcher(); +} + +... + + EXPECT_CALL(foo, Bar(NotNull())); // The argument must be a non-NULL pointer. +``` + +### Legacy Matcher Implementation + +Defining matchers used to be somewhat more complicated, in which it required +several supporting classes and virtual functions. To implement a matcher for +type `T` using the legacy API you have to derive from `MatcherInterface` and +call `MakeMatcher` to construct the object. + +The interface looks like this: + +```cpp +class MatchResultListener { + public: + ... + // Streams x to the underlying ostream; does nothing if the ostream + // is NULL. + template + MatchResultListener& operator<<(const T& x); + + // Returns the underlying ostream. + std::ostream* stream(); +}; + +template +class MatcherInterface { + public: + virtual ~MatcherInterface(); + + // Returns true if and only if the matcher matches x; also explains the match + // result to 'listener'. + virtual bool MatchAndExplain(T x, MatchResultListener* listener) const = 0; + + // Describes this matcher to an ostream. + virtual void DescribeTo(std::ostream* os) const = 0; + + // Describes the negation of this matcher to an ostream. + virtual void DescribeNegationTo(std::ostream* os) const; +}; +``` Fortunately, most of the time you can define a polymorphic matcher easily with the help of `MakePolymorphicMatcher()`. Here's how you can define `NotNull()` as @@ -3705,6 +3742,7 @@ PolymorphicMatcher NotNull() { EXPECT_CALL(foo, Bar(NotNull())); // The argument must be a non-NULL pointer. ``` +{: .callout .note} **Note:** Your polymorphic matcher class does **not** need to inherit from `MatcherInterface` or any other class, and its methods do **not** need to be virtual. @@ -3718,8 +3756,8 @@ A cardinality is used in `Times()` to tell gMock how many times you expect a call to occur. It doesn't have to be exact. For example, you can say `AtLeast(5)` or `Between(2, 4)`. -If the [built-in set](cheat_sheet.md#CardinalityList) of cardinalities doesn't -suit you, you are free to define your own by implementing the following +If the [built-in set](gmock_cheat_sheet.md#CardinalityList) of cardinalities +doesn't suit you, you are free to define your own by implementing the following interface (in namespace `testing`): ```cpp @@ -3995,7 +4033,7 @@ ACTION_TEMPLATE(DuplicateArg, // Note the comma between int and k: HAS_2_TEMPLATE_PARAMS(int, k, typename, T), AND_1_VALUE_PARAMS(output)) { - *output = T(::std::get(args)); + *output = T(std::get(args)); } ``` @@ -4042,23 +4080,18 @@ If you are writing a function that returns an `ACTION` object, you'll need to know its type. The type depends on the macro used to define the action and the parameter types. The rule is relatively simple: + | Given Definition | Expression | Has Type | | ----------------------------- | ------------------- | --------------------- | | `ACTION(Foo)` | `Foo()` | `FooAction` | -| `ACTION_TEMPLATE(Foo,` | `Foo()` : t_m>` : -: `AND_0_VALUE_PARAMS())` : : : +| `ACTION_TEMPLATE(Foo, HAS_m_TEMPLATE_PARAMS(...), AND_0_VALUE_PARAMS())` | `Foo()` | `FooAction` | | `ACTION_P(Bar, param)` | `Bar(int_value)` | `BarActionP` | -| `ACTION_TEMPLATE(Bar,` | `Bar` | `FooActionP` : -: `AND_1_VALUE_PARAMS(p1))` : : : -| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value,` | `BazActionP2` : -| `ACTION_TEMPLATE(Baz,` | `Baz` | `FooActionP2` : -: `AND_2_VALUE_PARAMS(p1, p2))` : `int_value)` : : +| `ACTION_TEMPLATE(Bar, HAS_m_TEMPLATE_PARAMS(...), AND_1_VALUE_PARAMS(p1))` | `Bar(int_value)` | `BarActionP` | +| `ACTION_P2(Baz, p1, p2)` | `Baz(bool_value, int_value)` | `BazActionP2` | +| `ACTION_TEMPLATE(Baz, HAS_m_TEMPLATE_PARAMS(...), AND_2_VALUE_PARAMS(p1, p2))` | `Baz(bool_value, int_value)` | `BazActionP2` | | ... | ... | ... | + Note that we have to pick different suffixes (`Action`, `ActionP`, `ActionP2`, and etc) for actions with different numbers of value parameters, or the action definitions cannot be overloaded on the number of them. @@ -4087,7 +4120,7 @@ class ActionInterface { // // For example, if F is int(bool, const string&), then Result would - // be int, and ArgumentTuple would be ::std::tuple. + // be int, and ArgumentTuple would be std::tuple. virtual Result Perform(const ArgumentTuple& args) = 0; }; ``` @@ -4102,8 +4135,8 @@ typedef int IncrementMethod(int*); class IncrementArgumentAction : public ActionInterface { public: - int Perform(const ::std::tuple& args) override { - int* p = ::std::get<0>(args); // Grabs the first argument. + int Perform(const std::tuple& args) override { + int* p = std::get<0>(args); // Grabs the first argument. return *p++; } }; @@ -4148,8 +4181,8 @@ class ReturnSecondArgumentAction { public: template Result Perform(const ArgumentTuple& args) const { - // To get the i-th (0-based) argument, use ::std::get(args). - return ::std::get<1>(args); + // To get the i-th (0-based) argument, use std::get(args). + return std::get<1>(args); } }; ``` @@ -4207,7 +4240,7 @@ value printer. This printer knows how to print built-in C++ types, native arrays, STL containers, and any type that supports the `<<` operator. For other types, it prints the raw bytes in the value and hopes that you the user can figure it out. -[googletest's advanced guide](../../googletest/docs/advanced.md#teaching-googletest-how-to-print-your-values) +[The GoogleTest advanced guide](advanced.md#teaching-googletest-how-to-print-your-values) explains how to extend the printer to do a better job at printing your particular type than to dump the bytes. @@ -4266,5 +4299,3 @@ expectations. Although `std::function` supports unlimited number of arguments, `MockFunction` implementation is limited to ten. If you ever hit that limit... well, your callback has bigger problems than being mockable. :-) - - diff --git a/ext/googletest/googlemock/docs/gmock_faq.md b/ext/googletest/docs/gmock_faq.md similarity index 97% rename from ext/googletest/googlemock/docs/gmock_faq.md rename to ext/googletest/docs/gmock_faq.md index 214aabf121..2cd9b3f315 100644 --- a/ext/googletest/googlemock/docs/gmock_faq.md +++ b/ext/googletest/docs/gmock_faq.md @@ -1,11 +1,9 @@ -## Legacy gMock FAQ {#GMockFaq} - - +# Legacy gMock FAQ ### When I call a method on my mock object, the method for the real object is invoked instead. What's the problem? In order for a method to be mocked, it must be *virtual*, unless you use the -[high-perf dependency injection technique](#MockingNonVirtualMethods). +[high-perf dependency injection technique](gmock_cook_book.md#MockingNonVirtualMethods). ### Can I mock a variadic function? @@ -81,8 +79,6 @@ void Bar(int* p); // Neither p nor *p is const. void Bar(const int* p); // p is not const, but *p is. ``` - - ### I can't figure out why gMock thinks my expectations are not satisfied. What should I do? You might want to run your test with `--gmock_verbose=info`. This flag lets @@ -91,7 +87,7 @@ trace, you'll gain insights on why the expectations you set are not met. If you see the message "The mock function has no default action set, and its return type has no default value set.", then try -[adding a default action](for_dummies.md#DefaultValue). Due to a known issue, +[adding a default action](gmock_cheat_sheet.md#OnCall). Due to a known issue, unexpected calls on mocks without default actions don't print out a detailed comparison between the actual arguments and the expected arguments. @@ -126,8 +122,6 @@ using ::testing::_; .Times(0); ``` - - ### I have a failed test where gMock tells me TWICE that a particular expectation is not satisfied. Isn't this redundant? When gMock detects a failure, it prints relevant information (the mock function @@ -386,8 +380,8 @@ doesn't say what the return value should be. You need `DoAll()` to chain a `SetArgPointee()` with a `Return()` that provides a value appropriate to the API being mocked. -See this [recipe](cook_book.md#mocking-side-effects) for more details and an -example. +See this [recipe](gmock_cook_book.md#mocking-side-effects) for more details and +an example. ### I have a huge mock class, and Microsoft Visual C++ runs out of memory when compiling it. What can I do? diff --git a/ext/googletest/googlemock/docs/for_dummies.md b/ext/googletest/docs/gmock_for_dummies.md similarity index 92% rename from ext/googletest/googlemock/docs/for_dummies.md rename to ext/googletest/docs/gmock_for_dummies.md index e11c18d9bf..0392b5de3d 100644 --- a/ext/googletest/googlemock/docs/for_dummies.md +++ b/ext/googletest/docs/gmock_for_dummies.md @@ -1,8 +1,6 @@ -## gMock for Dummies {#GMockForDummies} +# gMock for Dummies - - -### What Is gMock? +## What Is gMock? When you write a prototype or test, often it's not feasible or wise to rely on real objects entirely. A **mock object** implements the same interface as a real @@ -10,9 +8,9 @@ object (so it can be used as one), but lets you specify at run time how it will be used and what it should do (which methods will be called? in which order? how many times? with what arguments? what will they return? etc). -**Note:** It is easy to confuse the term *fake objects* with mock objects. Fakes -and mocks actually mean very different things in the Test-Driven Development -(TDD) community: +It is easy to confuse the term *fake objects* with mock objects. Fakes and mocks +actually mean very different things in the Test-Driven Development (TDD) +community: * **Fake** objects have working implementations, but usually take some shortcut (perhaps to make the operations less expensive), which makes them @@ -39,7 +37,7 @@ When using gMock, 3. then you exercise code that uses the mock objects. gMock will catch any violation to the expectations as soon as it arises. -### Why gMock? +## Why gMock? While mock objects help you remove unnecessary dependencies in tests and make them fast and reliable, using mocks manually in C++ is *hard*: @@ -53,9 +51,9 @@ them fast and reliable, using mocks manually in C++ is *hard*: one. In contrast, Java and Python programmers have some fine mock frameworks (jMock, -EasyMock, [Mox](http://wtf/mox), etc), which automate the creation of mocks. As -a result, mocking is a proven effective technique and widely adopted practice in -those communities. Having the right tool absolutely makes the difference. +EasyMock, etc), which automate the creation of mocks. As a result, mocking is a +proven effective technique and widely adopted practice in those communities. +Having the right tool absolutely makes the difference. gMock was built to help C++ programmers. It was inspired by jMock and EasyMock, but designed with C++'s specifics in mind. It is your friend if any of the @@ -85,11 +83,11 @@ We encourage you to use gMock as * a *testing* tool to cut your tests' outbound dependencies and probe the interaction between your module and its collaborators. -### Getting Started +## Getting Started gMock is bundled with googletest. -### A Case for Mock Turtles +## A Case for Mock Turtles Let's look at an example. Suppose you are developing a graphics program that relies on a [LOGO](http://en.wikipedia.org/wiki/Logo_programming_language)-like @@ -106,7 +104,7 @@ the API in an interface (say, `Turtle`) and code to that interface: ```cpp class Turtle { ... - virtual ~Turtle() {}; + virtual ~Turtle() {} virtual void PenUp() = 0; virtual void PenDown() = 0; virtual void Forward(int distance) = 0; @@ -135,20 +133,20 @@ because your new machine does anti-aliasing differently), easier to read and maintain (the intent of a test is expressed in the code, not in some binary images), and run *much, much faster*. -### Writing the Mock Class +## Writing the Mock Class If you are lucky, the mocks you need to use have already been implemented by some nice people. If, however, you find yourself in the position to write a mock class, relax - gMock turns this task into a fun game! (Well, almost.) -#### How to Define It +### How to Define It Using the `Turtle` interface as example, here are the simple steps you need to follow: * Derive a class `MockTurtle` from `Turtle`. * Take a *virtual* function of `Turtle` (while it's possible to - [mock non-virtual methods using templates](cook_book.md#MockingNonVirtualMethods), + [mock non-virtual methods using templates](gmock_cook_book.md#MockingNonVirtualMethods), it's much more involved). * In the `public:` section of the child class, write `MOCK_METHOD();` * Now comes the fun part: you take the function signature, cut-and-paste it @@ -184,7 +182,7 @@ class MockTurtle : public Turtle { You don't need to define these mock methods somewhere else - the `MOCK_METHOD` macro will generate the definitions for you. It's that simple! -#### Where to Put It +### Where to Put It When you define a mock class, you need to decide where to put its definition. Some people put it in a `_test.cc`. This is fine when the interface being mocked @@ -206,14 +204,12 @@ choosing the adaptor interface can make your code easier to write and more readable (a net win in the long run), as you can choose `FooAdaptor` to fit your specific domain much better than `Foo` does. - - -### Using Mocks in Tests +## Using Mocks in Tests Once you have a mock class, using it is easy. The typical work flow is: 1. Import the gMock names from the `testing` namespace such that you can use - them unqualified (You only have to do it once per file. Remember that + them unqualified (You only have to do it once per file). Remember that namespaces are a good idea. 2. Create some mock objects. 3. Specify your expectations on them (How many times will a method be called? @@ -257,8 +253,8 @@ Stack trace: ... ``` -**Tip 1:** If you run the test from an Emacs buffer, you can hit on the -line number to jump right to the failed expectation. +**Tip 1:** If you run the test from an Emacs buffer, you can hit `` on +the line number to jump right to the failed expectation. **Tip 2:** If your mock objects are never deleted, the final verification won't happen. Therefore it's a good idea to turn on the heap checker in your tests @@ -266,8 +262,9 @@ when you allocate mocks on the heap. You get that automatically if you use the `gtest_main` library already. **Important note:** gMock requires expectations to be set **before** the mock -functions are called, otherwise the behavior is **undefined**. In particular, -you mustn't interleave `EXPECT_CALL()s` and calls to the mock functions. +functions are called, otherwise the behavior is **undefined**. Do not alternate +between calls to `EXPECT_CALL()` and calls to the mock functions, and do not set +any expectations on a mock after passing the mock to an API. This means `EXPECT_CALL()` should be read as expecting that a call will occur *in the future*, not that a call has occurred. Why does gMock work like that? @@ -279,7 +276,7 @@ Admittedly, this test is contrived and doesn't do much. You can easily achieve the same effect without using gMock. However, as we shall reveal soon, gMock allows you to do *so much more* with the mocks. -### Setting Expectations +## Setting Expectations The key to using a mock object successfully is to set the *right expectations* on it. If you set the expectations too strict, your test will fail as the result @@ -288,7 +285,7 @@ to do it just right such that your test can catch exactly the kind of bugs you intend it to catch. gMock provides the necessary means for you to do it "just right." -#### General Syntax +### General Syntax In gMock we use the `EXPECT_CALL()` macro to set an expectation on a mock method. The general syntax is: @@ -314,8 +311,8 @@ EXPECT_CALL(mock_object, non-overloaded-method) This syntax allows the test writer to specify "called with any arguments" without explicitly specifying the number or types of arguments. To avoid -unintended ambiguity, this syntax may only be used for methods which are not -overloaded +unintended ambiguity, this syntax may only be used for methods that are not +overloaded. Either form of the macro can be followed by some optional *clauses* that provide more information about the expectation. We'll discuss how each clause works in @@ -338,12 +335,13 @@ says that the `turtle` object's `GetX()` method will be called five times, it will return 100 the first time, 150 the second time, and then 200 every time. Some people like to call this style of syntax a Domain-Specific Language (DSL). +{: .callout .note} **Note:** Why do we use a macro to do this? Well it serves two purposes: first -it makes expectations easily identifiable (either by `gsearch` or by a human +it makes expectations easily identifiable (either by `grep` or by a human reader), and second it allows gMock to include the source file location of a failed expectation in messages, making debugging easier. -#### Matchers: What Arguments Do We Expect? +### Matchers: What Arguments Do We Expect? When a mock function takes arguments, we may specify what arguments we are expecting, for example: @@ -374,8 +372,8 @@ convenient way of saying "any value". In the above examples, `100` and `50` are also matchers; implicitly, they are the same as `Eq(100)` and `Eq(50)`, which specify that the argument must be equal (using `operator==`) to the matcher argument. There are many -[built-in matchers](#MatcherList) for common types (as well as -[custom matchers](cook_book.md#NewMatchers)); for example: +[built-in matchers](reference/matchers.md) for common types (as well as +[custom matchers](gmock_cook_book.md#NewMatchers)); for example: ```cpp using ::testing::Ge; @@ -397,9 +395,9 @@ EXPECT_CALL(turtle, GoTo); This works for all non-overloaded methods; if a method is overloaded, you need to help gMock resolve which overload is expected by specifying the number of arguments and possibly also the -[types of the arguments](cook_book.md#SelectOverload). +[types of the arguments](gmock_cook_book.md#SelectOverload). -#### Cardinalities: How Many Times Will It Be Called? +### Cardinalities: How Many Times Will It Be Called? The first clause we can specify following an `EXPECT_CALL()` is `Times()`. We call its argument a **cardinality** as it tells *how many times* the call should @@ -414,7 +412,7 @@ called. We've seen `AtLeast(n)` as an example of fuzzy cardinalities earlier. For the list of built-in cardinalities you can use, see -[here](cheat_sheet.md#CardinalityList). +[here](gmock_cheat_sheet.md#CardinalityList). The `Times()` clause can be omitted. **If you omit `Times()`, gMock will infer the cardinality for you.** The rules are easy to remember: @@ -429,7 +427,7 @@ the cardinality for you.** The rules are easy to remember: **Quick quiz:** what do you think will happen if a function is expected to be called twice but actually called four times? -#### Actions: What Should It Do? +### Actions: What Should It Do? Remember that a mock object doesn't really have a working implementation? We as users have to tell it what to do when a method is invoked. This is easy in @@ -482,8 +480,8 @@ the *default* action for the function every time (unless, of course, you have a `WillRepeatedly()`.). What can we do inside `WillOnce()` besides `Return()`? You can return a -reference using `ReturnRef(*variable*)`, or invoke a pre-defined function, among -[others](cook_book.md#using-actions). +reference using `ReturnRef(`*`variable`*`)`, or invoke a pre-defined function, +among [others](gmock_cook_book.md#using-actions). **Important note:** The `EXPECT_CALL()` statement evaluates the action clause only once, even though the action may be performed many times. Therefore you @@ -503,7 +501,7 @@ always return 100 as `n++` is only evaluated once. Similarly, `Return(new Foo)` will create a new `Foo` object when the `EXPECT_CALL()` is executed, and will return the same pointer every time. If you want the side effect to happen every time, you need to define a custom action, which we'll teach in the -[cook book](http://). +[cook book](gmock_cook_book.md). Time for another quiz! What do you think the following means? @@ -522,7 +520,7 @@ will be taken afterwards. So the right answer is that `turtle.GetY()` will return 100 the first time, but **return 0 from the second time on**, as returning 0 is the default action for `int` functions. -#### Using Multiple Expectations {#MultiExpectations} +### Using Multiple Expectations {#MultiExpectations} So far we've only shown examples where you have a single expectation. More realistically, you'll specify expectations on multiple mock methods which may be @@ -547,6 +545,7 @@ error, as the last matching expectation (#2) has been saturated. If, however, the third `Forward(10)` call is replaced by `Forward(20)`, then it would be OK, as now #1 will be the matching expectation. +{: .callout .note} **Note:** Why does gMock search for a match in the *reverse* order of the expectations? The reason is that this allows a user to set up the default expectations in a mock object's constructor or the test fixture's set-up phase @@ -555,15 +554,16 @@ body. So, if you have two expectations on the same method, you want to put the one with more specific matchers **after** the other, or the more specific rule would be shadowed by the more general one that comes after it. +{: .callout .tip} **Tip:** It is very common to start with a catch-all expectation for a method and `Times(AnyNumber())` (omitting arguments, or with `_` for all arguments, if overloaded). This makes any calls to the method expected. This is not necessary for methods that are not mentioned at all (these are "uninteresting"), but is useful for methods that have some expectations, but for which other calls are ok. See -[Understanding Uninteresting vs Unexpected Calls](cook_book.md#uninteresting-vs-unexpected). +[Understanding Uninteresting vs Unexpected Calls](gmock_cook_book.md#uninteresting-vs-unexpected). -#### Ordered vs Unordered Calls {#OrderedCalls} +### Ordered vs Unordered Calls {#OrderedCalls} By default, an expectation can match a call even though an earlier expectation hasn't been satisfied. In other words, the calls don't have to occur in the @@ -598,9 +598,9 @@ order as written. If a call is made out-of-order, it will be an error. (What if you care about the relative order of some of the calls, but not all of them? Can you specify an arbitrary partial order? The answer is ... yes! The -details can be found [here](cook_book.md#OrderedCalls).) +details can be found [here](gmock_cook_book.md#OrderedCalls).) -#### All Expectations Are Sticky (Unless Said Otherwise) {#StickyExpectations} +### All Expectations Are Sticky (Unless Said Otherwise) {#StickyExpectations} Now let's do a quick quiz to see how well you can use this mock stuff already. How would you test that the turtle is asked to go to the origin *exactly twice* @@ -688,7 +688,7 @@ it's in a sequence - as soon as another expectation that comes after it in the sequence has been used, it automatically retires (and will never be used to match any call). -#### Uninteresting Calls +### Uninteresting Calls A mock object may have many methods, and not all of them are that interesting. For example, in some tests we may not care about how many times `GetX()` and @@ -697,4 +697,4 @@ For example, in some tests we may not care about how many times `GetX()` and In gMock, if you are not interested in a method, just don't say anything about it. If a call to this method occurs, you'll see a warning in the test output, but it won't be a failure. This is called "naggy" behavior; to change, see -[The Nice, the Strict, and the Naggy](cook_book.md#NiceStrictNaggy). +[The Nice, the Strict, and the Naggy](gmock_cook_book.md#NiceStrictNaggy). diff --git a/ext/googletest/docs/index.md b/ext/googletest/docs/index.md new file mode 100644 index 0000000000..b162c74011 --- /dev/null +++ b/ext/googletest/docs/index.md @@ -0,0 +1,22 @@ +# GoogleTest User's Guide + +## Welcome to GoogleTest! + +GoogleTest is Google's C++ testing and mocking framework. This user's guide has +the following contents: + +* [GoogleTest Primer](primer.md) - Teaches you how to write simple tests using + GoogleTest. Read this first if you are new to GoogleTest. +* [GoogleTest Advanced](advanced.md) - Read this when you've finished the + Primer and want to utilize GoogleTest to its full potential. +* [GoogleTest Samples](samples.md) - Describes some GoogleTest samples. +* [GoogleTest FAQ](faq.md) - Have a question? Want some tips? Check here + first. +* [Mocking for Dummies](gmock_for_dummies.md) - Teaches you how to create mock + objects and use them in tests. +* [Mocking Cookbook](gmock_cook_book.md) - Includes tips and approaches to + common mocking use cases. +* [Mocking Cheat Sheet](gmock_cheat_sheet.md) - A handy reference for + matchers, actions, invariants, and more. +* [Mocking FAQ](gmock_faq.md) - Contains answers to some mocking-specific + questions. diff --git a/ext/googletest/googletest/docs/pkgconfig.md b/ext/googletest/docs/pkgconfig.md similarity index 52% rename from ext/googletest/googletest/docs/pkgconfig.md rename to ext/googletest/docs/pkgconfig.md index 6dc0673889..18a2546a38 100644 --- a/ext/googletest/googletest/docs/pkgconfig.md +++ b/ext/googletest/docs/pkgconfig.md @@ -45,77 +45,6 @@ splitting the pkg-config `Cflags` variable into include dirs and macros for goes for using `_LDFLAGS` over the more commonplace `_LIBRARIES`, which happens to discard `-L` flags and `-pthread`. -### Autotools - -Finding GoogleTest in Autoconf and using it from Automake is also fairly easy: - -In your `configure.ac`: - -``` -AC_PREREQ([2.69]) -AC_INIT([my_gtest_pkgconfig], [0.0.1]) -AC_CONFIG_SRCDIR([samples/sample3_unittest.cc]) -AC_PROG_CXX - -PKG_CHECK_MODULES([GTEST], [gtest_main]) - -AM_INIT_AUTOMAKE([foreign subdir-objects]) -AC_CONFIG_FILES([Makefile]) -AC_OUTPUT -``` - -and in your `Makefile.am`: - -``` -check_PROGRAMS = testapp -TESTS = $(check_PROGRAMS) - -testapp_SOURCES = samples/sample3_unittest.cc -testapp_CXXFLAGS = $(GTEST_CFLAGS) -testapp_LDADD = $(GTEST_LIBS) -``` - -### Meson - -Meson natively uses pkgconfig to query dependencies: - -``` -project('my_gtest_pkgconfig', 'cpp', version : '0.0.1') - -gtest_dep = dependency('gtest_main') - -testapp = executable( - 'testapp', - files(['samples/sample3_unittest.cc']), - dependencies : gtest_dep, - install : false) - -test('first_and_only_test', testapp) -``` - -### Plain Makefiles - -Since `pkg-config` is a small Unix command-line utility, it can be used in -handwritten `Makefile`s too: - -```makefile -GTEST_CFLAGS = `pkg-config --cflags gtest_main` -GTEST_LIBS = `pkg-config --libs gtest_main` - -.PHONY: tests all - -tests: all - ./testapp - -all: testapp - -testapp: testapp.o - $(CXX) $(CXXFLAGS) $(LDFLAGS) $< -o $@ $(GTEST_LIBS) - -testapp.o: samples/sample3_unittest.cc - $(CXX) $(CPPFLAGS) $(CXXFLAGS) $< -c -o $@ $(GTEST_CFLAGS) -``` - ### Help! pkg-config can't find GoogleTest! Let's say you have a `CMakeLists.txt` along the lines of the one in this @@ -139,3 +68,81 @@ export PKG_CONFIG_PATH=/usr/local/lib64/pkgconfig ``` pkg-config will also try to look in `PKG_CONFIG_PATH` to find `gtest_main.pc`. + +### Using pkg-config in a cross-compilation setting + +Pkg-config can be used in a cross-compilation setting too. To do this, let's +assume the final prefix of the cross-compiled installation will be `/usr`, and +your sysroot is `/home/MYUSER/sysroot`. Configure and install GTest using + +``` +mkdir build && cmake -DCMAKE_INSTALL_PREFIX=/usr .. +``` + +Install into the sysroot using `DESTDIR`: + +``` +make -j install DESTDIR=/home/MYUSER/sysroot +``` + +Before we continue, it is recommended to **always** define the following two +variables for pkg-config in a cross-compilation setting: + +``` +export PKG_CONFIG_ALLOW_SYSTEM_CFLAGS=yes +export PKG_CONFIG_ALLOW_SYSTEM_LIBS=yes +``` + +otherwise `pkg-config` will filter `-I` and `-L` flags against standard prefixes +such as `/usr` (see https://bugs.freedesktop.org/show_bug.cgi?id=28264#c3 for +reasons why this stripping needs to occur usually). + +If you look at the generated pkg-config file, it will look something like + +``` +libdir=/usr/lib64 +includedir=/usr/include + +Name: gtest +Description: GoogleTest (without main() function) +Version: 1.11.0 +URL: https://github.com/google/googletest +Libs: -L${libdir} -lgtest -lpthread +Cflags: -I${includedir} -DGTEST_HAS_PTHREAD=1 -lpthread +``` + +Notice that the sysroot is not included in `libdir` and `includedir`! If you try +to run `pkg-config` with the correct +`PKG_CONFIG_LIBDIR=/home/MYUSER/sysroot/usr/lib64/pkgconfig` against this `.pc` +file, you will get + +``` +$ pkg-config --cflags gtest +-DGTEST_HAS_PTHREAD=1 -lpthread -I/usr/include +$ pkg-config --libs gtest +-L/usr/lib64 -lgtest -lpthread +``` + +which is obviously wrong and points to the `CBUILD` and not `CHOST` root. In +order to use this in a cross-compilation setting, we need to tell pkg-config to +inject the actual sysroot into `-I` and `-L` variables. Let us now tell +pkg-config about the actual sysroot + +``` +export PKG_CONFIG_DIR= +export PKG_CONFIG_SYSROOT_DIR=/home/MYUSER/sysroot +export PKG_CONFIG_LIBDIR=${PKG_CONFIG_SYSROOT_DIR}/usr/lib64/pkgconfig +``` + +and running `pkg-config` again we get + +``` +$ pkg-config --cflags gtest +-DGTEST_HAS_PTHREAD=1 -lpthread -I/home/MYUSER/sysroot/usr/include +$ pkg-config --libs gtest +-L/home/MYUSER/sysroot/usr/lib64 -lgtest -lpthread +``` + +which contains the correct sysroot now. For a more comprehensive guide to also +including `${CHOST}` in build system calls, see the excellent tutorial by Diego +Elio Pettenò: diff --git a/ext/googletest/docs/platforms.md b/ext/googletest/docs/platforms.md new file mode 100644 index 0000000000..eba6ef8056 --- /dev/null +++ b/ext/googletest/docs/platforms.md @@ -0,0 +1,35 @@ +# Supported Platforms + +GoogleTest requires a codebase and compiler compliant with the C++11 standard or +newer. + +The GoogleTest code is officially supported on the following platforms. +Operating systems or tools not listed below are community-supported. For +community-supported platforms, patches that do not complicate the code may be +considered. + +If you notice any problems on your platform, please file an issue on the +[GoogleTest GitHub Issue Tracker](https://github.com/google/googletest/issues). +Pull requests containing fixes are welcome! + +### Operating systems + +* Linux +* macOS +* Windows + +### Compilers + +* gcc 5.0+ +* clang 5.0+ +* MSVC 2015+ + +**macOS users:** Xcode 9.3+ provides clang 5.0+. + +### Build systems + +* [Bazel](https://bazel.build/) +* [CMake](https://cmake.org/) + +Bazel is the build system used by the team internally and in tests. CMake is +supported on a best-effort basis and by the community. diff --git a/ext/googletest/googletest/docs/primer.md b/ext/googletest/docs/primer.md similarity index 73% rename from ext/googletest/googletest/docs/primer.md rename to ext/googletest/docs/primer.md index 0317692bbb..6d8fdf4439 100644 --- a/ext/googletest/googletest/docs/primer.md +++ b/ext/googletest/docs/primer.md @@ -44,6 +44,7 @@ minutes to learn the basics and get started. So let's go! ## Beware of the nomenclature +{: .callout .note} _Note:_ There might be some confusion arising from different definitions of the terms _Test_, _Test Case_ and _Test Suite_, so beware of misunderstanding these. @@ -66,13 +67,11 @@ deprecated and refactored away. So please be aware of the different definitions of the terms: - Meaning | googletest Term | [ISTQB](http://www.istqb.org/) Term :----------------------------------------------------------------------------------- | :---------------------- | :---------------------------------- Exercise a particular program path with specific input values and verify the results | [TEST()](#simple-tests) | [Test Case][istqb test case] - [istqb test case]: http://glossary.istqb.org/en/search/test%20case [istqb test suite]: http://glossary.istqb.org/en/search/test%20suite @@ -119,7 +118,9 @@ Depending on the nature of the leak, it may or may not be worth fixing - so keep this in mind if you get a heap checker error in addition to assertion errors. To provide a custom failure message, simply stream it into the macro using the -`<<` operator or a sequence of such operators. An example: +`<<` operator or a sequence of such operators. See the following example, using +the [`ASSERT_EQ` and `EXPECT_EQ`](reference/assertions.md#EXPECT_EQ) macros to +verify value equality: ```c++ ASSERT_EQ(x.size(), y.size()) << "Vectors x and y are of unequal length"; @@ -134,112 +135,12 @@ macro--in particular, C strings and `string` objects. If a wide string (`wchar_t*`, `TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is streamed to an assertion, it will be translated to UTF-8 when printed. -### Basic Assertions - -These assertions do basic true/false condition testing. - -Fatal assertion | Nonfatal assertion | Verifies --------------------------- | -------------------------- | -------------------- -`ASSERT_TRUE(condition);` | `EXPECT_TRUE(condition);` | `condition` is true -`ASSERT_FALSE(condition);` | `EXPECT_FALSE(condition);` | `condition` is false - -Remember, when they fail, `ASSERT_*` yields a fatal failure and returns from the -current function, while `EXPECT_*` yields a nonfatal failure, allowing the -function to continue running. In either case, an assertion failure means its -containing test fails. - -**Availability**: Linux, Windows, Mac. - -### Binary Comparison - -This section describes assertions that compare two values. - -Fatal assertion | Nonfatal assertion | Verifies ------------------------- | ------------------------ | -------------- -`ASSERT_EQ(val1, val2);` | `EXPECT_EQ(val1, val2);` | `val1 == val2` -`ASSERT_NE(val1, val2);` | `EXPECT_NE(val1, val2);` | `val1 != val2` -`ASSERT_LT(val1, val2);` | `EXPECT_LT(val1, val2);` | `val1 < val2` -`ASSERT_LE(val1, val2);` | `EXPECT_LE(val1, val2);` | `val1 <= val2` -`ASSERT_GT(val1, val2);` | `EXPECT_GT(val1, val2);` | `val1 > val2` -`ASSERT_GE(val1, val2);` | `EXPECT_GE(val1, val2);` | `val1 >= val2` - -Value arguments must be comparable by the assertion's comparison operator or -you'll get a compiler error. We used to require the arguments to support the -`<<` operator for streaming to an `ostream`, but this is no longer necessary. If -`<<` is supported, it will be called to print the arguments when the assertion -fails; otherwise googletest will attempt to print them in the best way it can. -For more details and how to customize the printing of the arguments, see the -[documentation](../../googlemock/docs/cook_book.md#teaching-gmock-how-to-print-your-values). - -These assertions can work with a user-defined type, but only if you define the -corresponding comparison operator (e.g., `==` or `<`). Since this is discouraged -by the Google -[C++ Style Guide](https://google.github.io/styleguide/cppguide.html#Operator_Overloading), -you may need to use `ASSERT_TRUE()` or `EXPECT_TRUE()` to assert the equality of -two objects of a user-defined type. - -However, when possible, `ASSERT_EQ(actual, expected)` is preferred to -`ASSERT_TRUE(actual == expected)`, since it tells you `actual` and `expected`'s -values on failure. - -Arguments are always evaluated exactly once. Therefore, it's OK for the -arguments to have side effects. However, as with any ordinary C/C++ function, -the arguments' evaluation order is undefined (i.e., the compiler is free to -choose any order), and your code should not depend on any particular argument -evaluation order. - -`ASSERT_EQ()` does pointer equality on pointers. If used on two C strings, it -tests if they are in the same memory location, not if they have the same value. -Therefore, if you want to compare C strings (e.g. `const char*`) by value, use -`ASSERT_STREQ()`, which will be described later on. In particular, to assert -that a C string is `NULL`, use `ASSERT_STREQ(c_string, NULL)`. Consider using -`ASSERT_EQ(c_string, nullptr)` if c++11 is supported. To compare two `string` -objects, you should use `ASSERT_EQ`. - -When doing pointer comparisons use `*_EQ(ptr, nullptr)` and `*_NE(ptr, nullptr)` -instead of `*_EQ(ptr, NULL)` and `*_NE(ptr, NULL)`. This is because `nullptr` is -typed, while `NULL` is not. See the [FAQ](faq.md) for more details. - -If you're working with floating point numbers, you may want to use the floating -point variations of some of these macros in order to avoid problems caused by -rounding. See [Advanced googletest Topics](advanced.md) for details. - -Macros in this section work with both narrow and wide string objects (`string` -and `wstring`). - -**Availability**: Linux, Windows, Mac. - -**Historical note**: Before February 2016 `*_EQ` had a convention of calling it -as `ASSERT_EQ(expected, actual)`, so lots of existing code uses this order. Now -`*_EQ` treats both parameters in the same way. - -### String Comparison - -The assertions in this group compare two **C strings**. If you want to compare -two `string` objects, use `EXPECT_EQ`, `EXPECT_NE`, and etc instead. - - - -| Fatal assertion | Nonfatal assertion | Verifies | -| -------------------------- | ------------------------------ | -------------------------------------------------------- | -| `ASSERT_STREQ(str1,str2);` | `EXPECT_STREQ(str1,str2);` | the two C strings have the same content | -| `ASSERT_STRNE(str1,str2);` | `EXPECT_STRNE(str1,str2);` | the two C strings have different contents | -| `ASSERT_STRCASEEQ(str1,str2);` | `EXPECT_STRCASEEQ(str1,str2);` | the two C strings have the same content, ignoring case | -| `ASSERT_STRCASENE(str1,str2);` | `EXPECT_STRCASENE(str1,str2);` | the two C strings have different contents, ignoring case | - - - -Note that "CASE" in an assertion name means that case is ignored. A `NULL` -pointer and an empty string are considered *different*. - -`*STREQ*` and `*STRNE*` also accept wide C strings (`wchar_t*`). If a comparison -of two wide strings fails, their values will be printed as UTF-8 narrow strings. - -**Availability**: Linux, Windows, Mac. - -**See also**: For more string comparison tricks (substring, prefix, suffix, and -regular expression matching, for example), see [this](advanced.md) in the -Advanced googletest Guide. +GoogleTest provides a collection of assertions for verifying the behavior of +your code in various ways. You can check Boolean conditions, compare values +based on relational operators, verify string values, floating-point values, and +much more. There are even assertions that enable you to verify more complex +states by providing custom predicates. For the complete list of assertions +provided by GoogleTest, see the [Assertions Reference](reference/assertions.md). ## Simple Tests @@ -261,7 +162,7 @@ TEST(TestSuiteName, TestName) { `TEST()` arguments go from general to specific. The *first* argument is the name of the test suite, and the *second* argument is the test's name within the test -case. Both names must be valid C++ identifiers, and they should not contain +suite. Both names must be valid C++ identifiers, and they should not contain any underscores (`_`). A test's *full name* consists of its containing test suite and its individual name. Tests from different test suites can have the same individual name. @@ -418,7 +319,7 @@ The above uses both `ASSERT_*` and `EXPECT_*` assertions. The rule of thumb is to use `EXPECT_*` when you want the test to continue to reveal more errors after the assertion failure, and use `ASSERT_*` when continuing after failure doesn't make sense. For example, the second assertion in the `Dequeue` test is -`ASSERT_NE(nullptr, n)`, as we need to dereference the pointer `n` later, which +`ASSERT_NE(n, nullptr)`, as we need to dereference the pointer `n` later, which would lead to a segfault when `n` is `NULL`. When these tests run, the following happens: @@ -464,6 +365,7 @@ When invoked, the `RUN_ALL_TESTS()` macro: If a fatal failure happens the subsequent steps will be skipped. +{: .callout .important} > IMPORTANT: You must **not** ignore the return value of `RUN_ALL_TESTS()`, or > you will get a compiler error. The rationale for this design is that the > automated testing service determines whether a test has passed based on its @@ -478,22 +380,31 @@ If a fatal failure happens the subsequent steps will be skipped. ## Writing the main() Function -Write your own main() function, which should return the value of +Most users should _not_ need to write their own `main` function and instead link +with `gtest_main` (as opposed to with `gtest`), which defines a suitable entry +point. See the end of this section for details. The remainder of this section +should only apply when you need to do something custom before the tests run that +cannot be expressed within the framework of fixtures and test suites. + +If you write your own `main` function, it should return the value of `RUN_ALL_TESTS()`. You can start from this boilerplate: ```c++ #include "this/package/foo.h" + #include "gtest/gtest.h" +namespace my { +namespace project { namespace { // The fixture for testing class Foo. class FooTest : public ::testing::Test { protected: - // You can remove any or all of the following functions if its body - // is empty. + // You can remove any or all of the following functions if their bodies would + // be empty. FooTest() { // You can do set-up work for each test here. @@ -516,7 +427,8 @@ class FooTest : public ::testing::Test { // before the destructor). } - // Objects declared here can be used by all tests in the test suite for Foo. + // Class members declared here can be used by all tests in the test suite + // for Foo. }; // Tests that the Foo::Bar() method does Abc. @@ -533,6 +445,8 @@ TEST_F(FooTest, DoesXyz) { } } // namespace +} // namespace project +} // namespace my int main(int argc, char **argv) { ::testing::InitGoogleTest(&argc, argv); @@ -549,11 +463,12 @@ the [AdvancedGuide](advanced.md). You **must** call this function before calling On Windows, `InitGoogleTest()` also works with wide strings, so it can be used in programs compiled in `UNICODE` mode as well. -But maybe you think that writing all those main() functions is too much work? We +But maybe you think that writing all those `main` functions is too much work? We agree with you completely, and that's why Google Test provides a basic implementation of main(). If it fits your needs, then just link your test with -gtest\_main library and you are good to go. +the `gtest_main` library and you are good to go. +{: .callout .note} NOTE: `ParseGUnitFlags()` is deprecated in favor of `InitGoogleTest()`. ## Known Limitations diff --git a/ext/googletest/docs/quickstart-bazel.md b/ext/googletest/docs/quickstart-bazel.md new file mode 100644 index 0000000000..362ee6d050 --- /dev/null +++ b/ext/googletest/docs/quickstart-bazel.md @@ -0,0 +1,161 @@ +# Quickstart: Building with Bazel + +This tutorial aims to get you up and running with GoogleTest using the Bazel +build system. If you're using GoogleTest for the first time or need a refresher, +we recommend this tutorial as a starting point. + +## Prerequisites + +To complete this tutorial, you'll need: + +* A compatible operating system (e.g. Linux, macOS, Windows). +* A compatible C++ compiler that supports at least C++11. +* [Bazel](https://bazel.build/), the preferred build system used by the + GoogleTest team. + +See [Supported Platforms](platforms.md) for more information about platforms +compatible with GoogleTest. + +If you don't already have Bazel installed, see the +[Bazel installation guide](https://docs.bazel.build/versions/master/install.html). + +{: .callout .note} +Note: The terminal commands in this tutorial show a Unix shell prompt, but the +commands work on the Windows command line as well. + +## Set up a Bazel workspace + +A +[Bazel workspace](https://docs.bazel.build/versions/master/build-ref.html#workspace) +is a directory on your filesystem that you use to manage source files for the +software you want to build. Each workspace directory has a text file named +`WORKSPACE` which may be empty, or may contain references to external +dependencies required to build the outputs. + +First, create a directory for your workspace: + +``` +$ mkdir my_workspace && cd my_workspace +``` + +Next, you’ll create the `WORKSPACE` file to specify dependencies. A common and +recommended way to depend on GoogleTest is to use a +[Bazel external dependency](https://docs.bazel.build/versions/master/external.html) +via the +[`http_archive` rule](https://docs.bazel.build/versions/master/repo/http.html#http_archive). +To do this, in the root directory of your workspace (`my_workspace/`), create a +file named `WORKSPACE` with the following contents: + +``` +load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive") + +http_archive( + name = "com_google_googletest", + urls = ["https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip"], + strip_prefix = "googletest-609281088cfefc76f9d0ce82e1ff6c30cc3591e5", +) +``` + +The above configuration declares a dependency on GoogleTest which is downloaded +as a ZIP archive from GitHub. In the above example, +`609281088cfefc76f9d0ce82e1ff6c30cc3591e5` is the Git commit hash of the +GoogleTest version to use; we recommend updating the hash often to point to the +latest version. + +Bazel also needs a dependency on the +[`rules_cc` repository](https://github.com/bazelbuild/rules_cc) to build C++ +code, so add the following to the `WORKSPACE` file: + +``` +http_archive( + name = "rules_cc", + urls = ["https://github.com/bazelbuild/rules_cc/archive/40548a2974f1aea06215272d9c2b47a14a24e556.zip"], + strip_prefix = "rules_cc-40548a2974f1aea06215272d9c2b47a14a24e556", +) +``` + +Now you're ready to build C++ code that uses GoogleTest. + +## Create and run a binary + +With your Bazel workspace set up, you can now use GoogleTest code within your +own project. + +As an example, create a file named `hello_test.cc` in your `my_workspace` +directory with the following contents: + +```cpp +#include + +// Demonstrate some basic assertions. +TEST(HelloTest, BasicAssertions) { + // Expect two strings not to be equal. + EXPECT_STRNE("hello", "world"); + // Expect equality. + EXPECT_EQ(7 * 6, 42); +} +``` + +GoogleTest provides [assertions](primer.md#assertions) that you use to test the +behavior of your code. The above sample includes the main GoogleTest header file +and demonstrates some basic assertions. + +To build the code, create a file named `BUILD` in the same directory with the +following contents: + +``` +load("@rules_cc//cc:defs.bzl", "cc_test") + +cc_test( + name = "hello_test", + size = "small", + srcs = ["hello_test.cc"], + deps = ["@com_google_googletest//:gtest_main"], +) +``` + +This `cc_test` rule declares the C++ test binary you want to build, and links to +GoogleTest (`//:gtest_main`) using the prefix you specified in the `WORKSPACE` +file (`@com_google_googletest`). For more information about Bazel `BUILD` files, +see the +[Bazel C++ Tutorial](https://docs.bazel.build/versions/master/tutorial/cpp.html). + +Now you can build and run your test: + +
+my_workspace$ bazel test --test_output=all //:hello_test
+INFO: Analyzed target //:hello_test (26 packages loaded, 362 targets configured).
+INFO: Found 1 test target...
+INFO: From Testing //:hello_test:
+==================== Test output for //:hello_test:
+Running main() from gmock_main.cc
+[==========] Running 1 test from 1 test suite.
+[----------] Global test environment set-up.
+[----------] 1 test from HelloTest
+[ RUN      ] HelloTest.BasicAssertions
+[       OK ] HelloTest.BasicAssertions (0 ms)
+[----------] 1 test from HelloTest (0 ms total)
+
+[----------] Global test environment tear-down
+[==========] 1 test from 1 test suite ran. (0 ms total)
+[  PASSED  ] 1 test.
+================================================================================
+Target //:hello_test up-to-date:
+  bazel-bin/hello_test
+INFO: Elapsed time: 4.190s, Critical Path: 3.05s
+INFO: 27 processes: 8 internal, 19 linux-sandbox.
+INFO: Build completed successfully, 27 total actions
+//:hello_test                                                     PASSED in 0.1s
+
+INFO: Build completed successfully, 27 total actions
+
+ +Congratulations! You've successfully built and run a test binary using +GoogleTest. + +## Next steps + +* [Check out the Primer](primer.md) to start learning how to write simple + tests. +* [See the code samples](samples.md) for more examples showing how to use a + variety of GoogleTest features. diff --git a/ext/googletest/docs/quickstart-cmake.md b/ext/googletest/docs/quickstart-cmake.md new file mode 100644 index 0000000000..420f1d3a3c --- /dev/null +++ b/ext/googletest/docs/quickstart-cmake.md @@ -0,0 +1,156 @@ +# Quickstart: Building with CMake + +This tutorial aims to get you up and running with GoogleTest using CMake. If +you're using GoogleTest for the first time or need a refresher, we recommend +this tutorial as a starting point. If your project uses Bazel, see the +[Quickstart for Bazel](quickstart-bazel.md) instead. + +## Prerequisites + +To complete this tutorial, you'll need: + +* A compatible operating system (e.g. Linux, macOS, Windows). +* A compatible C++ compiler that supports at least C++11. +* [CMake](https://cmake.org/) and a compatible build tool for building the + project. + * Compatible build tools include + [Make](https://www.gnu.org/software/make/), + [Ninja](https://ninja-build.org/), and others - see + [CMake Generators](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html) + for more information. + +See [Supported Platforms](platforms.md) for more information about platforms +compatible with GoogleTest. + +If you don't already have CMake installed, see the +[CMake installation guide](https://cmake.org/install). + +{: .callout .note} +Note: The terminal commands in this tutorial show a Unix shell prompt, but the +commands work on the Windows command line as well. + +## Set up a project + +CMake uses a file named `CMakeLists.txt` to configure the build system for a +project. You'll use this file to set up your project and declare a dependency on +GoogleTest. + +First, create a directory for your project: + +``` +$ mkdir my_project && cd my_project +``` + +Next, you'll create the `CMakeLists.txt` file and declare a dependency on +GoogleTest. There are many ways to express dependencies in the CMake ecosystem; +in this quickstart, you'll use the +[`FetchContent` CMake module](https://cmake.org/cmake/help/latest/module/FetchContent.html). +To do this, in your project directory (`my_project`), create a file named +`CMakeLists.txt` with the following contents: + +```cmake +cmake_minimum_required(VERSION 3.14) +project(my_project) + +# GoogleTest requires at least C++11 +set(CMAKE_CXX_STANDARD 11) + +include(FetchContent) +FetchContent_Declare( + googletest + URL https://github.com/google/googletest/archive/609281088cfefc76f9d0ce82e1ff6c30cc3591e5.zip +) +# For Windows: Prevent overriding the parent project's compiler/linker settings +set(gtest_force_shared_crt ON CACHE BOOL "" FORCE) +FetchContent_MakeAvailable(googletest) +``` + +The above configuration declares a dependency on GoogleTest which is downloaded +from GitHub. In the above example, `609281088cfefc76f9d0ce82e1ff6c30cc3591e5` is +the Git commit hash of the GoogleTest version to use; we recommend updating the +hash often to point to the latest version. + +For more information about how to create `CMakeLists.txt` files, see the +[CMake Tutorial](https://cmake.org/cmake/help/latest/guide/tutorial/index.html). + +## Create and run a binary + +With GoogleTest declared as a dependency, you can use GoogleTest code within +your own project. + +As an example, create a file named `hello_test.cc` in your `my_project` +directory with the following contents: + +```cpp +#include + +// Demonstrate some basic assertions. +TEST(HelloTest, BasicAssertions) { + // Expect two strings not to be equal. + EXPECT_STRNE("hello", "world"); + // Expect equality. + EXPECT_EQ(7 * 6, 42); +} +``` + +GoogleTest provides [assertions](primer.md#assertions) that you use to test the +behavior of your code. The above sample includes the main GoogleTest header file +and demonstrates some basic assertions. + +To build the code, add the following to the end of your `CMakeLists.txt` file: + +```cmake +enable_testing() + +add_executable( + hello_test + hello_test.cc +) +target_link_libraries( + hello_test + gtest_main +) + +include(GoogleTest) +gtest_discover_tests(hello_test) +``` + +The above configuration enables testing in CMake, declares the C++ test binary +you want to build (`hello_test`), and links it to GoogleTest (`gtest_main`). The +last two lines enable CMake's test runner to discover the tests included in the +binary, using the +[`GoogleTest` CMake module](https://cmake.org/cmake/help/git-stage/module/GoogleTest.html). + +Now you can build and run your test: + +
+my_project$ cmake -S . -B build
+-- The C compiler identification is GNU 10.2.1
+-- The CXX compiler identification is GNU 10.2.1
+...
+-- Build files have been written to: .../my_project/build
+
+my_project$ cmake --build build
+Scanning dependencies of target gtest
+...
+[100%] Built target gmock_main
+
+my_project$ cd build && ctest
+Test project .../my_project/build
+    Start 1: HelloTest.BasicAssertions
+1/1 Test #1: HelloTest.BasicAssertions ........   Passed    0.00 sec
+
+100% tests passed, 0 tests failed out of 1
+
+Total Test time (real) =   0.01 sec
+
+ +Congratulations! You've successfully built and run a test binary using +GoogleTest. + +## Next steps + +* [Check out the Primer](primer.md) to start learning how to write simple + tests. +* [See the code samples](samples.md) for more examples showing how to use a + variety of GoogleTest features. diff --git a/ext/googletest/docs/reference/actions.md b/ext/googletest/docs/reference/actions.md new file mode 100644 index 0000000000..ab81a129ef --- /dev/null +++ b/ext/googletest/docs/reference/actions.md @@ -0,0 +1,115 @@ +# Actions Reference + +[**Actions**](../gmock_for_dummies.md#actions-what-should-it-do) specify what a +mock function should do when invoked. This page lists the built-in actions +provided by GoogleTest. All actions are defined in the `::testing` namespace. + +## Returning a Value + +| Action | Description | +| :-------------------------------- | :-------------------------------------------- | +| `Return()` | Return from a `void` mock function. | +| `Return(value)` | Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type at the time the expectation is set, not when the action is executed. | +| `ReturnArg()` | Return the `N`-th (0-based) argument. | +| `ReturnNew(a1, ..., ak)` | Return `new T(a1, ..., ak)`; a different object is created each time. | +| `ReturnNull()` | Return a null pointer. | +| `ReturnPointee(ptr)` | Return the value pointed to by `ptr`. | +| `ReturnRef(variable)` | Return a reference to `variable`. | +| `ReturnRefOfCopy(value)` | Return a reference to a copy of `value`; the copy lives as long as the action. | +| `ReturnRoundRobin({a1, ..., ak})` | Each call will return the next `ai` in the list, starting at the beginning when the end of the list is reached. | + +## Side Effects + +| Action | Description | +| :--------------------------------- | :-------------------------------------- | +| `Assign(&variable, value)` | Assign `value` to variable. | +| `DeleteArg()` | Delete the `N`-th (0-based) argument, which must be a pointer. | +| `SaveArg(pointer)` | Save the `N`-th (0-based) argument to `*pointer`. | +| `SaveArgPointee(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. | +| `SetArgReferee(value)` | Assign `value` to the variable referenced by the `N`-th (0-based) argument. | +| `SetArgPointee(value)` | Assign `value` to the variable pointed by the `N`-th (0-based) argument. | +| `SetArgumentPointee(value)` | Same as `SetArgPointee(value)`. Deprecated. Will be removed in v1.7.0. | +| `SetArrayArgument(first, last)` | Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-th (0-based) argument, which can be either a pointer or an iterator. The action does not take ownership of the elements in the source range. | +| `SetErrnoAndReturn(error, value)` | Set `errno` to `error` and return `value`. | +| `Throw(exception)` | Throws the given exception, which can be any copyable value. Available since v1.1.0. | + +## Using a Function, Functor, or Lambda as an Action + +In the following, by "callable" we mean a free function, `std::function`, +functor, or lambda. + +| Action | Description | +| :---------------------------------- | :------------------------------------- | +| `f` | Invoke `f` with the arguments passed to the mock function, where `f` is a callable. | +| `Invoke(f)` | Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor. | +| `Invoke(object_pointer, &class::method)` | Invoke the method on the object with the arguments passed to the mock function. | +| `InvokeWithoutArgs(f)` | Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments. | +| `InvokeWithoutArgs(object_pointer, &class::method)` | Invoke the method on the object, which takes no arguments. | +| `InvokeArgument(arg1, arg2, ..., argk)` | Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments. | + +The return value of the invoked function is used as the return value of the +action. + +When defining a callable to be used with `Invoke*()`, you can declare any unused +parameters as `Unused`: + +```cpp +using ::testing::Invoke; +double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); } +... +EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance)); +``` + +`Invoke(callback)` and `InvokeWithoutArgs(callback)` take ownership of +`callback`, which must be permanent. The type of `callback` must be a base +callback type instead of a derived one, e.g. + +```cpp + BlockingClosure* done = new BlockingClosure; + ... Invoke(done) ...; // This won't compile! + + Closure* done2 = new BlockingClosure; + ... Invoke(done2) ...; // This works. +``` + +In `InvokeArgument(...)`, if an argument needs to be passed by reference, +wrap it inside `std::ref()`. For example, + +```cpp +using ::testing::InvokeArgument; +... +InvokeArgument<2>(5, string("Hi"), std::ref(foo)) +``` + +calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by +value, and `foo` by reference. + +## Default Action + +| Action | Description | +| :------------ | :----------------------------------------------------- | +| `DoDefault()` | Do the default action (specified by `ON_CALL()` or the built-in one). | + +{: .callout .note} +**Note:** due to technical reasons, `DoDefault()` cannot be used inside a +composite action - trying to do so will result in a run-time error. + +## Composite Actions + +| Action | Description | +| :----------------------------- | :------------------------------------------ | +| `DoAll(a1, a2, ..., an)` | Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void and will receive a readonly view of the arguments. | +| `IgnoreResult(a)` | Perform action `a` and ignore its result. `a` must not return void. | +| `WithArg(a)` | Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it. | +| `WithArgs(a)` | Pass the selected (0-based) arguments of the mock function to action `a` and perform it. | +| `WithoutArgs(a)` | Perform action `a` without any arguments. | + +## Defining Actions + +| Macro | Description | +| :--------------------------------- | :-------------------------------------- | +| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. | +| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. | +| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`. | + +The `ACTION*` macros cannot be used inside a function or class. diff --git a/ext/googletest/docs/reference/assertions.md b/ext/googletest/docs/reference/assertions.md new file mode 100644 index 0000000000..7bf03a3dde --- /dev/null +++ b/ext/googletest/docs/reference/assertions.md @@ -0,0 +1,633 @@ +# Assertions Reference + +This page lists the assertion macros provided by GoogleTest for verifying code +behavior. To use them, include the header `gtest/gtest.h`. + +The majority of the macros listed below come as a pair with an `EXPECT_` variant +and an `ASSERT_` variant. Upon failure, `EXPECT_` macros generate nonfatal +failures and allow the current function to continue running, while `ASSERT_` +macros generate fatal failures and abort the current function. + +All assertion macros support streaming a custom failure message into them with +the `<<` operator, for example: + +```cpp +EXPECT_TRUE(my_condition) << "My condition is not true"; +``` + +Anything that can be streamed to an `ostream` can be streamed to an assertion +macro—in particular, C strings and string objects. If a wide string (`wchar_t*`, +`TCHAR*` in `UNICODE` mode on Windows, or `std::wstring`) is streamed to an +assertion, it will be translated to UTF-8 when printed. + +## Explicit Success and Failure {#success-failure} + +The assertions in this section generate a success or failure directly instead of +testing a value or expression. These are useful when control flow, rather than a +Boolean expression, determines the test's success or failure, as shown by the +following example: + +```c++ +switch(expression) { + case 1: + ... some checks ... + case 2: + ... some other checks ... + default: + FAIL() << "We shouldn't get here."; +} +``` + +### SUCCEED {#SUCCEED} + +`SUCCEED()` + +Generates a success. This *does not* make the overall test succeed. A test is +considered successful only if none of its assertions fail during its execution. + +The `SUCCEED` assertion is purely documentary and currently doesn't generate any +user-visible output. However, we may add `SUCCEED` messages to GoogleTest output +in the future. + +### FAIL {#FAIL} + +`FAIL()` + +Generates a fatal failure, which returns from the current function. + +Can only be used in functions that return `void`. See +[Assertion Placement](../advanced.md#assertion-placement) for more information. + +### ADD_FAILURE {#ADD_FAILURE} + +`ADD_FAILURE()` + +Generates a nonfatal failure, which allows the current function to continue +running. + +### ADD_FAILURE_AT {#ADD_FAILURE_AT} + +`ADD_FAILURE_AT(`*`file_path`*`,`*`line_number`*`)` + +Generates a nonfatal failure at the file and line number specified. + +## Generalized Assertion {#generalized} + +The following assertion allows [matchers](matchers.md) to be used to verify +values. + +### EXPECT_THAT {#EXPECT_THAT} + +`EXPECT_THAT(`*`value`*`,`*`matcher`*`)` \ +`ASSERT_THAT(`*`value`*`,`*`matcher`*`)` + +Verifies that *`value`* matches the [matcher](matchers.md) *`matcher`*. + +For example, the following code verifies that the string `value1` starts with +`"Hello"`, `value2` matches a regular expression, and `value3` is between 5 and +10: + +```cpp +#include "gmock/gmock.h" + +using ::testing::AllOf; +using ::testing::Gt; +using ::testing::Lt; +using ::testing::MatchesRegex; +using ::testing::StartsWith; + +... +EXPECT_THAT(value1, StartsWith("Hello")); +EXPECT_THAT(value2, MatchesRegex("Line \\d+")); +ASSERT_THAT(value3, AllOf(Gt(5), Lt(10))); +``` + +Matchers enable assertions of this form to read like English and generate +informative failure messages. For example, if the above assertion on `value1` +fails, the resulting message will be similar to the following: + +``` +Value of: value1 + Actual: "Hi, world!" +Expected: starts with "Hello" +``` + +GoogleTest provides a built-in library of matchers—see the +[Matchers Reference](matchers.md). It is also possible to write your own +matchers—see [Writing New Matchers Quickly](../gmock_cook_book.md#NewMatchers). +The use of matchers makes `EXPECT_THAT` a powerful, extensible assertion. + +*The idea for this assertion was borrowed from Joe Walnes' Hamcrest project, +which adds `assertThat()` to JUnit.* + +## Boolean Conditions {#boolean} + +The following assertions test Boolean conditions. + +### EXPECT_TRUE {#EXPECT_TRUE} + +`EXPECT_TRUE(`*`condition`*`)` \ +`ASSERT_TRUE(`*`condition`*`)` + +Verifies that *`condition`* is true. + +### EXPECT_FALSE {#EXPECT_FALSE} + +`EXPECT_FALSE(`*`condition`*`)` \ +`ASSERT_FALSE(`*`condition`*`)` + +Verifies that *`condition`* is false. + +## Binary Comparison {#binary-comparison} + +The following assertions compare two values. The value arguments must be +comparable by the assertion's comparison operator, otherwise a compiler error +will result. + +If an argument supports the `<<` operator, it will be called to print the +argument when the assertion fails. Otherwise, GoogleTest will attempt to print +them in the best way it can—see +[Teaching GoogleTest How to Print Your Values](../advanced.md#teaching-googletest-how-to-print-your-values). + +Arguments are always evaluated exactly once, so it's OK for the arguments to +have side effects. However, the argument evaluation order is undefined and +programs should not depend on any particular argument evaluation order. + +These assertions work with both narrow and wide string objects (`string` and +`wstring`). + +See also the [Floating-Point Comparison](#floating-point) assertions to compare +floating-point numbers and avoid problems caused by rounding. + +### EXPECT_EQ {#EXPECT_EQ} + +`EXPECT_EQ(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_EQ(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`==`*`val2`*. + +Does pointer equality on pointers. If used on two C strings, it tests if they +are in the same memory location, not if they have the same value. Use +[`EXPECT_STREQ`](#EXPECT_STREQ) to compare C strings (e.g. `const char*`) by +value. + +When comparing a pointer to `NULL`, use `EXPECT_EQ(`*`ptr`*`, nullptr)` instead +of `EXPECT_EQ(`*`ptr`*`, NULL)`. + +### EXPECT_NE {#EXPECT_NE} + +`EXPECT_NE(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_NE(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`!=`*`val2`*. + +Does pointer equality on pointers. If used on two C strings, it tests if they +are in different memory locations, not if they have different values. Use +[`EXPECT_STRNE`](#EXPECT_STRNE) to compare C strings (e.g. `const char*`) by +value. + +When comparing a pointer to `NULL`, use `EXPECT_NE(`*`ptr`*`, nullptr)` instead +of `EXPECT_NE(`*`ptr`*`, NULL)`. + +### EXPECT_LT {#EXPECT_LT} + +`EXPECT_LT(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_LT(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`<`*`val2`*. + +### EXPECT_LE {#EXPECT_LE} + +`EXPECT_LE(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_LE(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`<=`*`val2`*. + +### EXPECT_GT {#EXPECT_GT} + +`EXPECT_GT(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_GT(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`>`*`val2`*. + +### EXPECT_GE {#EXPECT_GE} + +`EXPECT_GE(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_GE(`*`val1`*`,`*`val2`*`)` + +Verifies that *`val1`*`>=`*`val2`*. + +## String Comparison {#c-strings} + +The following assertions compare two **C strings**. To compare two `string` +objects, use [`EXPECT_EQ`](#EXPECT_EQ) or [`EXPECT_NE`](#EXPECT_NE) instead. + +These assertions also accept wide C strings (`wchar_t*`). If a comparison of two +wide strings fails, their values will be printed as UTF-8 narrow strings. + +To compare a C string with `NULL`, use `EXPECT_EQ(`*`c_string`*`, nullptr)` or +`EXPECT_NE(`*`c_string`*`, nullptr)`. + +### EXPECT_STREQ {#EXPECT_STREQ} + +`EXPECT_STREQ(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STREQ(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have the same contents. + +### EXPECT_STRNE {#EXPECT_STRNE} + +`EXPECT_STRNE(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STRNE(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have different contents. + +### EXPECT_STRCASEEQ {#EXPECT_STRCASEEQ} + +`EXPECT_STRCASEEQ(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STRCASEEQ(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have the same contents, +ignoring case. + +### EXPECT_STRCASENE {#EXPECT_STRCASENE} + +`EXPECT_STRCASENE(`*`str1`*`,`*`str2`*`)` \ +`ASSERT_STRCASENE(`*`str1`*`,`*`str2`*`)` + +Verifies that the two C strings *`str1`* and *`str2`* have different contents, +ignoring case. + +## Floating-Point Comparison {#floating-point} + +The following assertions compare two floating-point values. + +Due to rounding errors, it is very unlikely that two floating-point values will +match exactly, so `EXPECT_EQ` is not suitable. In general, for floating-point +comparison to make sense, the user needs to carefully choose the error bound. + +GoogleTest also provides assertions that use a default error bound based on +Units in the Last Place (ULPs). To learn more about ULPs, see the article +[Comparing Floating Point Numbers](https://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/). + +### EXPECT_FLOAT_EQ {#EXPECT_FLOAT_EQ} + +`EXPECT_FLOAT_EQ(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_FLOAT_EQ(`*`val1`*`,`*`val2`*`)` + +Verifies that the two `float` values *`val1`* and *`val2`* are approximately +equal, to within 4 ULPs from each other. + +### EXPECT_DOUBLE_EQ {#EXPECT_DOUBLE_EQ} + +`EXPECT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)` \ +`ASSERT_DOUBLE_EQ(`*`val1`*`,`*`val2`*`)` + +Verifies that the two `double` values *`val1`* and *`val2`* are approximately +equal, to within 4 ULPs from each other. + +### EXPECT_NEAR {#EXPECT_NEAR} + +`EXPECT_NEAR(`*`val1`*`,`*`val2`*`,`*`abs_error`*`)` \ +`ASSERT_NEAR(`*`val1`*`,`*`val2`*`,`*`abs_error`*`)` + +Verifies that the difference between *`val1`* and *`val2`* does not exceed the +absolute error bound *`abs_error`*. + +## Exception Assertions {#exceptions} + +The following assertions verify that a piece of code throws, or does not throw, +an exception. Usage requires exceptions to be enabled in the build environment. + +Note that the piece of code under test can be a compound statement, for example: + +```cpp +EXPECT_NO_THROW({ + int n = 5; + DoSomething(&n); +}); +``` + +### EXPECT_THROW {#EXPECT_THROW} + +`EXPECT_THROW(`*`statement`*`,`*`exception_type`*`)` \ +`ASSERT_THROW(`*`statement`*`,`*`exception_type`*`)` + +Verifies that *`statement`* throws an exception of type *`exception_type`*. + +### EXPECT_ANY_THROW {#EXPECT_ANY_THROW} + +`EXPECT_ANY_THROW(`*`statement`*`)` \ +`ASSERT_ANY_THROW(`*`statement`*`)` + +Verifies that *`statement`* throws an exception of any type. + +### EXPECT_NO_THROW {#EXPECT_NO_THROW} + +`EXPECT_NO_THROW(`*`statement`*`)` \ +`ASSERT_NO_THROW(`*`statement`*`)` + +Verifies that *`statement`* does not throw any exception. + +## Predicate Assertions {#predicates} + +The following assertions enable more complex predicates to be verified while +printing a more clear failure message than if `EXPECT_TRUE` were used alone. + +### EXPECT_PRED* {#EXPECT_PRED} + +`EXPECT_PRED1(`*`pred`*`,`*`val1`*`)` \ +`EXPECT_PRED2(`*`pred`*`,`*`val1`*`,`*`val2`*`)` \ +`EXPECT_PRED3(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`EXPECT_PRED4(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` \ +`EXPECT_PRED5(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +`ASSERT_PRED1(`*`pred`*`,`*`val1`*`)` \ +`ASSERT_PRED2(`*`pred`*`,`*`val1`*`,`*`val2`*`)` \ +`ASSERT_PRED3(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`ASSERT_PRED4(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` \ +`ASSERT_PRED5(`*`pred`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +Verifies that the predicate *`pred`* returns `true` when passed the given values +as arguments. + +The parameter *`pred`* is a function or functor that accepts as many arguments +as the corresponding macro accepts values. If *`pred`* returns `true` for the +given arguments, the assertion succeeds, otherwise the assertion fails. + +When the assertion fails, it prints the value of each argument. Arguments are +always evaluated exactly once. + +As an example, see the following code: + +```cpp +// Returns true if m and n have no common divisors except 1. +bool MutuallyPrime(int m, int n) { ... } +... +const int a = 3; +const int b = 4; +const int c = 10; +... +EXPECT_PRED2(MutuallyPrime, a, b); // Succeeds +EXPECT_PRED2(MutuallyPrime, b, c); // Fails +``` + +In the above example, the first assertion succeeds, and the second fails with +the following message: + +``` +MutuallyPrime(b, c) is false, where +b is 4 +c is 10 +``` + +Note that if the given predicate is an overloaded function or a function +template, the assertion macro might not be able to determine which version to +use, and it might be necessary to explicitly specify the type of the function. +For example, for a Boolean function `IsPositive()` overloaded to take either a +single `int` or `double` argument, it would be necessary to write one of the +following: + +```cpp +EXPECT_PRED1(static_cast(IsPositive), 5); +EXPECT_PRED1(static_cast(IsPositive), 3.14); +``` + +Writing simply `EXPECT_PRED1(IsPositive, 5);` would result in a compiler error. +Similarly, to use a template function, specify the template arguments: + +```cpp +template +bool IsNegative(T x) { + return x < 0; +} +... +EXPECT_PRED1(IsNegative, -5); // Must specify type for IsNegative +``` + +If a template has multiple parameters, wrap the predicate in parentheses so the +macro arguments are parsed correctly: + +```cpp +ASSERT_PRED2((MyPredicate), 5, 0); +``` + +### EXPECT_PRED_FORMAT* {#EXPECT_PRED_FORMAT} + +`EXPECT_PRED_FORMAT1(`*`pred_formatter`*`,`*`val1`*`)` \ +`EXPECT_PRED_FORMAT2(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`)` \ +`EXPECT_PRED_FORMAT3(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`EXPECT_PRED_FORMAT4(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` +\ +`EXPECT_PRED_FORMAT5(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +`ASSERT_PRED_FORMAT1(`*`pred_formatter`*`,`*`val1`*`)` \ +`ASSERT_PRED_FORMAT2(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`)` \ +`ASSERT_PRED_FORMAT3(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`)` \ +`ASSERT_PRED_FORMAT4(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`)` +\ +`ASSERT_PRED_FORMAT5(`*`pred_formatter`*`,`*`val1`*`,`*`val2`*`,`*`val3`*`,`*`val4`*`,`*`val5`*`)` + +Verifies that the predicate *`pred_formatter`* succeeds when passed the given +values as arguments. + +The parameter *`pred_formatter`* is a *predicate-formatter*, which is a function +or functor with the signature: + +```cpp +testing::AssertionResult PredicateFormatter(const char* expr1, + const char* expr2, + ... + const char* exprn, + T1 val1, + T2 val2, + ... + Tn valn); +``` + +where *`val1`*, *`val2`*, ..., *`valn`* are the values of the predicate +arguments, and *`expr1`*, *`expr2`*, ..., *`exprn`* are the corresponding +expressions as they appear in the source code. The types `T1`, `T2`, ..., `Tn` +can be either value types or reference types; if an argument has type `T`, it +can be declared as either `T` or `const T&`, whichever is appropriate. For more +about the return type `testing::AssertionResult`, see +[Using a Function That Returns an AssertionResult](../advanced.md#using-a-function-that-returns-an-assertionresult). + +As an example, see the following code: + +```cpp +// Returns the smallest prime common divisor of m and n, +// or 1 when m and n are mutually prime. +int SmallestPrimeCommonDivisor(int m, int n) { ... } + +// Returns true if m and n have no common divisors except 1. +bool MutuallyPrime(int m, int n) { ... } + +// A predicate-formatter for asserting that two integers are mutually prime. +testing::AssertionResult AssertMutuallyPrime(const char* m_expr, + const char* n_expr, + int m, + int n) { + if (MutuallyPrime(m, n)) return testing::AssertionSuccess(); + + return testing::AssertionFailure() << m_expr << " and " << n_expr + << " (" << m << " and " << n << ") are not mutually prime, " + << "as they have a common divisor " << SmallestPrimeCommonDivisor(m, n); +} + +... +const int a = 3; +const int b = 4; +const int c = 10; +... +EXPECT_PRED_FORMAT2(AssertMutuallyPrime, a, b); // Succeeds +EXPECT_PRED_FORMAT2(AssertMutuallyPrime, b, c); // Fails +``` + +In the above example, the final assertion fails and the predicate-formatter +produces the following failure message: + +``` +b and c (4 and 10) are not mutually prime, as they have a common divisor 2 +``` + +## Windows HRESULT Assertions {#HRESULT} + +The following assertions test for `HRESULT` success or failure. For example: + +```cpp +CComPtr shell; +ASSERT_HRESULT_SUCCEEDED(shell.CoCreateInstance(L"Shell.Application")); +CComVariant empty; +ASSERT_HRESULT_SUCCEEDED(shell->ShellExecute(CComBSTR(url), empty, empty, empty, empty)); +``` + +The generated output contains the human-readable error message associated with +the returned `HRESULT` code. + +### EXPECT_HRESULT_SUCCEEDED {#EXPECT_HRESULT_SUCCEEDED} + +`EXPECT_HRESULT_SUCCEEDED(`*`expression`*`)` \ +`ASSERT_HRESULT_SUCCEEDED(`*`expression`*`)` + +Verifies that *`expression`* is a success `HRESULT`. + +### EXPECT_HRESULT_FAILED {#EXPECT_HRESULT_FAILED} + +`EXPECT_HRESULT_FAILED(`*`expression`*`)` \ +`EXPECT_HRESULT_FAILED(`*`expression`*`)` + +Verifies that *`expression`* is a failure `HRESULT`. + +## Death Assertions {#death} + +The following assertions verify that a piece of code causes the process to +terminate. For context, see [Death Tests](../advanced.md#death-tests). + +These assertions spawn a new process and execute the code under test in that +process. How that happens depends on the platform and the variable +`::testing::GTEST_FLAG(death_test_style)`, which is initialized from the +command-line flag `--gtest_death_test_style`. + +* On POSIX systems, `fork()` (or `clone()` on Linux) is used to spawn the + child, after which: + * If the variable's value is `"fast"`, the death test statement is + immediately executed. + * If the variable's value is `"threadsafe"`, the child process re-executes + the unit test binary just as it was originally invoked, but with some + extra flags to cause just the single death test under consideration to + be run. +* On Windows, the child is spawned using the `CreateProcess()` API, and + re-executes the binary to cause just the single death test under + consideration to be run - much like the `"threadsafe"` mode on POSIX. + +Other values for the variable are illegal and will cause the death test to fail. +Currently, the flag's default value is +**`"fast"`**. + +If the death test statement runs to completion without dying, the child process +will nonetheless terminate, and the assertion fails. + +Note that the piece of code under test can be a compound statement, for example: + +```cpp +EXPECT_DEATH({ + int n = 5; + DoSomething(&n); +}, "Error on line .* of DoSomething()"); +``` + +### EXPECT_DEATH {#EXPECT_DEATH} + +`EXPECT_DEATH(`*`statement`*`,`*`matcher`*`)` \ +`ASSERT_DEATH(`*`statement`*`,`*`matcher`*`)` + +Verifies that *`statement`* causes the process to terminate with a nonzero exit +status and produces `stderr` output that matches *`matcher`*. + +The parameter *`matcher`* is either a [matcher](matchers.md) for a `const +std::string&`, or a regular expression (see +[Regular Expression Syntax](../advanced.md#regular-expression-syntax))—a bare +string *`s`* (with no matcher) is treated as +[`ContainsRegex(s)`](matchers.md#string-matchers), **not** +[`Eq(s)`](matchers.md#generic-comparison). + +For example, the following code verifies that calling `DoSomething(42)` causes +the process to die with an error message that contains the text `My error`: + +```cpp +EXPECT_DEATH(DoSomething(42), "My error"); +``` + +### EXPECT_DEATH_IF_SUPPORTED {#EXPECT_DEATH_IF_SUPPORTED} + +`EXPECT_DEATH_IF_SUPPORTED(`*`statement`*`,`*`matcher`*`)` \ +`ASSERT_DEATH_IF_SUPPORTED(`*`statement`*`,`*`matcher`*`)` + +If death tests are supported, behaves the same as +[`EXPECT_DEATH`](#EXPECT_DEATH). Otherwise, verifies nothing. + +### EXPECT_DEBUG_DEATH {#EXPECT_DEBUG_DEATH} + +`EXPECT_DEBUG_DEATH(`*`statement`*`,`*`matcher`*`)` \ +`ASSERT_DEBUG_DEATH(`*`statement`*`,`*`matcher`*`)` + +In debug mode, behaves the same as [`EXPECT_DEATH`](#EXPECT_DEATH). When not in +debug mode (i.e. `NDEBUG` is defined), just executes *`statement`*. + +### EXPECT_EXIT {#EXPECT_EXIT} + +`EXPECT_EXIT(`*`statement`*`,`*`predicate`*`,`*`matcher`*`)` \ +`ASSERT_EXIT(`*`statement`*`,`*`predicate`*`,`*`matcher`*`)` + +Verifies that *`statement`* causes the process to terminate with an exit status +that satisfies *`predicate`*, and produces `stderr` output that matches +*`matcher`*. + +The parameter *`predicate`* is a function or functor that accepts an `int` exit +status and returns a `bool`. GoogleTest provides two predicates to handle common +cases: + +```cpp +// Returns true if the program exited normally with the given exit status code. +::testing::ExitedWithCode(exit_code); + +// Returns true if the program was killed by the given signal. +// Not available on Windows. +::testing::KilledBySignal(signal_number); +``` + +The parameter *`matcher`* is either a [matcher](matchers.md) for a `const +std::string&`, or a regular expression (see +[Regular Expression Syntax](../advanced.md#regular-expression-syntax))—a bare +string *`s`* (with no matcher) is treated as +[`ContainsRegex(s)`](matchers.md#string-matchers), **not** +[`Eq(s)`](matchers.md#generic-comparison). + +For example, the following code verifies that calling `NormalExit()` causes the +process to print a message containing the text `Success` to `stderr` and exit +with exit status code 0: + +```cpp +EXPECT_EXIT(NormalExit(), testing::ExitedWithCode(0), "Success"); +``` diff --git a/ext/googletest/docs/reference/matchers.md b/ext/googletest/docs/reference/matchers.md new file mode 100644 index 0000000000..1a60b4c0dc --- /dev/null +++ b/ext/googletest/docs/reference/matchers.md @@ -0,0 +1,285 @@ +# Matchers Reference + +A **matcher** matches a *single* argument. You can use it inside `ON_CALL()` or +`EXPECT_CALL()`, or use it to validate a value directly using two macros: + +| Macro | Description | +| :----------------------------------- | :------------------------------------ | +| `EXPECT_THAT(actual_value, matcher)` | Asserts that `actual_value` matches `matcher`. | +| `ASSERT_THAT(actual_value, matcher)` | The same as `EXPECT_THAT(actual_value, matcher)`, except that it generates a **fatal** failure. | + +{: .callout .note} +**Note:** Although equality matching via `EXPECT_THAT(actual_value, +expected_value)` is supported, prefer to make the comparison explicit via +`EXPECT_THAT(actual_value, Eq(expected_value))` or `EXPECT_EQ(actual_value, +expected_value)`. + +Built-in matchers (where `argument` is the function argument, e.g. +`actual_value` in the example above, or when used in the context of +`EXPECT_CALL(mock_object, method(matchers))`, the arguments of `method`) are +divided into several categories. All matchers are defined in the `::testing` +namespace unless otherwise noted. + +## Wildcard + +Matcher | Description +:-------------------------- | :----------------------------------------------- +`_` | `argument` can be any value of the correct type. +`A()` or `An()` | `argument` can be any value of type `type`. + +## Generic Comparison + +| Matcher | Description | +| :--------------------- | :-------------------------------------------------- | +| `Eq(value)` or `value` | `argument == value` | +| `Ge(value)` | `argument >= value` | +| `Gt(value)` | `argument > value` | +| `Le(value)` | `argument <= value` | +| `Lt(value)` | `argument < value` | +| `Ne(value)` | `argument != value` | +| `IsFalse()` | `argument` evaluates to `false` in a Boolean context. | +| `IsTrue()` | `argument` evaluates to `true` in a Boolean context. | +| `IsNull()` | `argument` is a `NULL` pointer (raw or smart). | +| `NotNull()` | `argument` is a non-null pointer (raw or smart). | +| `Optional(m)` | `argument` is `optional<>` that contains a value matching `m`. (For testing whether an `optional<>` is set, check for equality with `nullopt`. You may need to use `Eq(nullopt)` if the inner type doesn't have `==`.)| +| `VariantWith(m)` | `argument` is `variant<>` that holds the alternative of type T with a value matching `m`. | +| `Ref(variable)` | `argument` is a reference to `variable`. | +| `TypedEq(value)` | `argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded. | + +Except `Ref()`, these matchers make a *copy* of `value` in case it's modified or +destructed later. If the compiler complains that `value` doesn't have a public +copy constructor, try wrap it in `std::ref()`, e.g. +`Eq(std::ref(non_copyable_value))`. If you do that, make sure +`non_copyable_value` is not changed afterwards, or the meaning of your matcher +will be changed. + +`IsTrue` and `IsFalse` are useful when you need to use a matcher, or for types +that can be explicitly converted to Boolean, but are not implicitly converted to +Boolean. In other cases, you can use the basic +[`EXPECT_TRUE` and `EXPECT_FALSE`](assertions.md#boolean) assertions. + +## Floating-Point Matchers {#FpMatchers} + +| Matcher | Description | +| :------------------------------- | :--------------------------------- | +| `DoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal. | +| `FloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal. | +| `NanSensitiveDoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal. | +| `NanSensitiveFloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal. | +| `IsNan()` | `argument` is any floating-point type with a NaN value. | + +The above matchers use ULP-based comparison (the same as used in googletest). +They automatically pick a reasonable error bound based on the absolute value of +the expected value. `DoubleEq()` and `FloatEq()` conform to the IEEE standard, +which requires comparing two NaNs for equality to return false. The +`NanSensitive*` version instead treats two NaNs as equal, which is often what a +user wants. + +| Matcher | Description | +| :------------------------------------------------ | :----------------------- | +| `DoubleNear(a_double, max_abs_error)` | `argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal. | +| `FloatNear(a_float, max_abs_error)` | `argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal. | +| `NanSensitiveDoubleNear(a_double, max_abs_error)` | `argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal. | +| `NanSensitiveFloatNear(a_float, max_abs_error)` | `argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal. | + +## String Matchers + +The `argument` can be either a C string or a C++ string object: + +| Matcher | Description | +| :---------------------- | :------------------------------------------------- | +| `ContainsRegex(string)` | `argument` matches the given regular expression. | +| `EndsWith(suffix)` | `argument` ends with string `suffix`. | +| `HasSubstr(string)` | `argument` contains `string` as a sub-string. | +| `IsEmpty()` | `argument` is an empty string. | +| `MatchesRegex(string)` | `argument` matches the given regular expression with the match starting at the first character and ending at the last character. | +| `StartsWith(prefix)` | `argument` starts with string `prefix`. | +| `StrCaseEq(string)` | `argument` is equal to `string`, ignoring case. | +| `StrCaseNe(string)` | `argument` is not equal to `string`, ignoring case. | +| `StrEq(string)` | `argument` is equal to `string`. | +| `StrNe(string)` | `argument` is not equal to `string`. | + +`ContainsRegex()` and `MatchesRegex()` take ownership of the `RE` object. They +use the regular expression syntax defined +[here](../advanced.md#regular-expression-syntax). All of these matchers, except +`ContainsRegex()` and `MatchesRegex()` work for wide strings as well. + +## Container Matchers + +Most STL-style containers support `==`, so you can use `Eq(expected_container)` +or simply `expected_container` to match a container exactly. If you want to +write the elements in-line, match them more flexibly, or get more informative +messages, you can use: + +| Matcher | Description | +| :---------------------------------------- | :------------------------------- | +| `BeginEndDistanceIs(m)` | `argument` is a container whose `begin()` and `end()` iterators are separated by a number of increments matching `m`. E.g. `BeginEndDistanceIs(2)` or `BeginEndDistanceIs(Lt(2))`. For containers that define a `size()` method, `SizeIs(m)` may be more efficient. | +| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. | +| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. | +| `Contains(e).Times(n)` | `argument` contains elements that match `e`, which can be either a value or a matcher, and the number of matches is `n`, which can be either a value or a matcher. Unlike the plain `Contains` and `Each` this allows to check for arbitrary occurrences including testing for absence with `Contains(e).Times(0)`. | +| `Each(e)` | `argument` is a container where *every* element matches `e`, which can be either a value or a matcher. | +| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the *i*-th element matches `ei`, which can be a value or a matcher. | +| `ElementsAreArray({e0, e1, ..., en})`, `ElementsAreArray(a_container)`, `ElementsAreArray(begin, end)`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `IsEmpty()` | `argument` is an empty container (`container.empty()`). | +| `IsSubsetOf({e0, e1, ..., en})`, `IsSubsetOf(a_container)`, `IsSubsetOf(begin, end)`, `IsSubsetOf(array)`, or `IsSubsetOf(array, count)` | `argument` matches `UnorderedElementsAre(x0, x1, ..., xk)` for some subset `{x0, x1, ..., xk}` of the expected matchers. | +| `IsSupersetOf({e0, e1, ..., en})`, `IsSupersetOf(a_container)`, `IsSupersetOf(begin, end)`, `IsSupersetOf(array)`, or `IsSupersetOf(array, count)` | Some subset of `argument` matches `UnorderedElementsAre(`expected matchers`)`. | +| `Pointwise(m, container)`, `Pointwise(m, {e0, e1, ..., en})` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. | +| `SizeIs(m)` | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`. | +| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under *some* permutation of the elements, each element matches an `ei` (for a different `i`), which can be a value or a matcher. | +| `UnorderedElementsAreArray({e0, e1, ..., en})`, `UnorderedElementsAreArray(a_container)`, `UnorderedElementsAreArray(begin, end)`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `UnorderedPointwise(m, container)`, `UnorderedPointwise(m, {e0, e1, ..., en})` | Like `Pointwise(m, container)`, but ignores the order of elements. | +| `WhenSorted(m)` | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(ElementsAre(1, 2, 3))` verifies that `argument` contains elements 1, 2, and 3, ignoring order. | +| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater(), ElementsAre(3, 2, 1))`. | + +**Notes:** + +* These matchers can also match: + 1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), + and + 2. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, + int len)` -- see [Multi-argument Matchers](#MultiArgMatchers)). +* The array being matched may be multi-dimensional (i.e. its elements can be + arrays). +* `m` in `Pointwise(m, ...)` and `UnorderedPointwise(m, ...)` should be a + matcher for `::std::tuple` where `T` and `U` are the element type of + the actual container and the expected container, respectively. For example, + to compare two `Foo` containers where `Foo` doesn't support `operator==`, + one might write: + + ```cpp + using ::std::get; + MATCHER(FooEq, "") { + return std::get<0>(arg).Equals(std::get<1>(arg)); + } + ... + EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos)); + ``` + +## Member Matchers + +| Matcher | Description | +| :------------------------------ | :----------------------------------------- | +| `Field(&class::field, m)` | `argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. | +| `Field(field_name, &class::field, m)` | The same as the two-parameter version, but provides a better error message. | +| `Key(e)` | `argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`. | +| `Pair(m1, m2)` | `argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`. | +| `FieldsAre(m...)` | `argument` is a compatible object where each field matches piecewise with the matchers `m...`. A compatible object is any that supports the `std::tuple_size`+`get(obj)` protocol. In C++17 and up this also supports types compatible with structured bindings, like aggregates. | +| `Property(&class::property, m)` | `argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. The method `property()` must take no argument and be declared as `const`. | +| `Property(property_name, &class::property, m)` | The same as the two-parameter version, but provides a better error message. + +**Notes:** + +* You can use `FieldsAre()` to match any type that supports structured + bindings, such as `std::tuple`, `std::pair`, `std::array`, and aggregate + types. For example: + + ```cpp + std::tuple my_tuple{7, "hello world"}; + EXPECT_THAT(my_tuple, FieldsAre(Ge(0), HasSubstr("hello"))); + + struct MyStruct { + int value = 42; + std::string greeting = "aloha"; + }; + MyStruct s; + EXPECT_THAT(s, FieldsAre(42, "aloha")); + ``` + +* Don't use `Property()` against member functions that you do not own, because + taking addresses of functions is fragile and generally not part of the + contract of the function. + +## Matching the Result of a Function, Functor, or Callback + +| Matcher | Description | +| :--------------- | :------------------------------------------------ | +| `ResultOf(f, m)` | `f(argument)` matches matcher `m`, where `f` is a function or functor. | + +## Pointer Matchers + +| Matcher | Description | +| :------------------------ | :---------------------------------------------- | +| `Address(m)` | the result of `std::addressof(argument)` matches `m`. | +| `Pointee(m)` | `argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`. | +| `Pointer(m)` | `argument` (either a smart pointer or a raw pointer) contains a pointer that matches `m`. `m` will match against the raw pointer regardless of the type of `argument`. | +| `WhenDynamicCastTo(m)` | when `argument` is passed through `dynamic_cast()`, it matches matcher `m`. | + +## Multi-argument Matchers {#MultiArgMatchers} + +Technically, all matchers match a *single* value. A "multi-argument" matcher is +just one that matches a *tuple*. The following matchers can be used to match a +tuple `(x, y)`: + +Matcher | Description +:------ | :---------- +`Eq()` | `x == y` +`Ge()` | `x >= y` +`Gt()` | `x > y` +`Le()` | `x <= y` +`Lt()` | `x < y` +`Ne()` | `x != y` + +You can use the following selectors to pick a subset of the arguments (or +reorder them) to participate in the matching: + +| Matcher | Description | +| :------------------------- | :---------------------------------------------- | +| `AllArgs(m)` | Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`. | +| `Args(m)` | The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`. | + +## Composite Matchers + +You can make a matcher from one or more other matchers: + +| Matcher | Description | +| :------------------------------- | :-------------------------------------- | +| `AllOf(m1, m2, ..., mn)` | `argument` matches all of the matchers `m1` to `mn`. | +| `AllOfArray({m0, m1, ..., mn})`, `AllOfArray(a_container)`, `AllOfArray(begin, end)`, `AllOfArray(array)`, or `AllOfArray(array, count)` | The same as `AllOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `AnyOf(m1, m2, ..., mn)` | `argument` matches at least one of the matchers `m1` to `mn`. | +| `AnyOfArray({m0, m1, ..., mn})`, `AnyOfArray(a_container)`, `AnyOfArray(begin, end)`, `AnyOfArray(array)`, or `AnyOfArray(array, count)` | The same as `AnyOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. | +| `Not(m)` | `argument` doesn't match matcher `m`. | +| `Conditional(cond, m1, m2)` | Matches matcher `m1` if `cond` evalutes to true, else matches `m2`.| + +## Adapters for Matchers + +| Matcher | Description | +| :---------------------- | :------------------------------------ | +| `MatcherCast(m)` | casts matcher `m` to type `Matcher`. | +| `SafeMatcherCast(m)` | [safely casts](../gmock_cook_book.md#SafeMatcherCast) matcher `m` to type `Matcher`. | +| `Truly(predicate)` | `predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor. | + +`AddressSatisfies(callback)` and `Truly(callback)` take ownership of `callback`, +which must be a permanent callback. + +## Using Matchers as Predicates {#MatchersAsPredicatesCheat} + +| Matcher | Description | +| :---------------------------- | :------------------------------------------ | +| `Matches(m)(value)` | evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor. | +| `ExplainMatchResult(m, value, result_listener)` | evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`. | +| `Value(value, m)` | evaluates to `true` if `value` matches `m`. | + +## Defining Matchers + +| Macro | Description | +| :----------------------------------- | :------------------------------------ | +| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. | +| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a matcher `IsDivisibleBy(n)` to match a number divisible by `n`. | +| `MATCHER_P2(IsBetween, a, b, absl::StrCat(negation ? "isn't" : "is", " between ", PrintToString(a), " and ", PrintToString(b))) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. | + +**Notes:** + +1. The `MATCHER*` macros cannot be used inside a function or class. +2. The matcher body must be *purely functional* (i.e. it cannot have any side + effect, and the result must not depend on anything other than the value + being matched and the matcher parameters). +3. You can use `PrintToString(x)` to convert a value `x` of any type to a + string. +4. You can use `ExplainMatchResult()` in a custom matcher to wrap another + matcher, for example: + + ```cpp + MATCHER_P(NestedPropertyMatches, matcher, "") { + return ExplainMatchResult(matcher, arg.nested().property(), result_listener); + } + ``` diff --git a/ext/googletest/docs/reference/mocking.md b/ext/googletest/docs/reference/mocking.md new file mode 100644 index 0000000000..c29f71603f --- /dev/null +++ b/ext/googletest/docs/reference/mocking.md @@ -0,0 +1,587 @@ +# Mocking Reference + +This page lists the facilities provided by GoogleTest for creating and working +with mock objects. To use them, include the header +`gmock/gmock.h`. + +## Macros {#macros} + +GoogleTest defines the following macros for working with mocks. + +### MOCK_METHOD {#MOCK_METHOD} + +`MOCK_METHOD(`*`return_type`*`,`*`method_name`*`, (`*`args...`*`));` \ +`MOCK_METHOD(`*`return_type`*`,`*`method_name`*`, (`*`args...`*`), +(`*`specs...`*`));` + +Defines a mock method *`method_name`* with arguments `(`*`args...`*`)` and +return type *`return_type`* within a mock class. + +The parameters of `MOCK_METHOD` mirror the method declaration. The optional +fourth parameter *`specs...`* is a comma-separated list of qualifiers. The +following qualifiers are accepted: + +| Qualifier | Meaning | +| -------------------------- | -------------------------------------------- | +| `const` | Makes the mocked method a `const` method. Required if overriding a `const` method. | +| `override` | Marks the method with `override`. Recommended if overriding a `virtual` method. | +| `noexcept` | Marks the method with `noexcept`. Required if overriding a `noexcept` method. | +| `Calltype(`*`calltype`*`)` | Sets the call type for the method, for example `Calltype(STDMETHODCALLTYPE)`. Useful on Windows. | +| `ref(`*`qualifier`*`)` | Marks the method with the given reference qualifier, for example `ref(&)` or `ref(&&)`. Required if overriding a method that has a reference qualifier. | + +Note that commas in arguments prevent `MOCK_METHOD` from parsing the arguments +correctly if they are not appropriately surrounded by parentheses. See the +following example: + +```cpp +class MyMock { + public: + // The following 2 lines will not compile due to commas in the arguments: + MOCK_METHOD(std::pair, GetPair, ()); // Error! + MOCK_METHOD(bool, CheckMap, (std::map, bool)); // Error! + + // One solution - wrap arguments that contain commas in parentheses: + MOCK_METHOD((std::pair), GetPair, ()); + MOCK_METHOD(bool, CheckMap, ((std::map), bool)); + + // Another solution - use type aliases: + using BoolAndInt = std::pair; + MOCK_METHOD(BoolAndInt, GetPair, ()); + using MapIntDouble = std::map; + MOCK_METHOD(bool, CheckMap, (MapIntDouble, bool)); +}; +``` + +`MOCK_METHOD` must be used in the `public:` section of a mock class definition, +regardless of whether the method being mocked is `public`, `protected`, or +`private` in the base class. + +### EXPECT_CALL {#EXPECT_CALL} + +`EXPECT_CALL(`*`mock_object`*`,`*`method_name`*`(`*`matchers...`*`))` + +Creates an [expectation](../gmock_for_dummies.md#setting-expectations) that the +method *`method_name`* of the object *`mock_object`* is called with arguments +that match the given matchers *`matchers...`*. `EXPECT_CALL` must precede any +code that exercises the mock object. + +The parameter *`matchers...`* is a comma-separated list of +[matchers](../gmock_for_dummies.md#matchers-what-arguments-do-we-expect) that +correspond to each argument of the method *`method_name`*. The expectation will +apply only to calls of *`method_name`* whose arguments match all of the +matchers. If `(`*`matchers...`*`)` is omitted, the expectation behaves as if +each argument's matcher were a [wildcard matcher (`_`)](matchers.md#wildcard). +See the [Matchers Reference](matchers.md) for a list of all built-in matchers. + +The following chainable clauses can be used to modify the expectation, and they +must be used in the following order: + +```cpp +EXPECT_CALL(mock_object, method_name(matchers...)) + .With(multi_argument_matcher) // Can be used at most once + .Times(cardinality) // Can be used at most once + .InSequence(sequences...) // Can be used any number of times + .After(expectations...) // Can be used any number of times + .WillOnce(action) // Can be used any number of times + .WillRepeatedly(action) // Can be used at most once + .RetiresOnSaturation(); // Can be used at most once +``` + +See details for each modifier clause below. + +#### With {#EXPECT_CALL.With} + +`.With(`*`multi_argument_matcher`*`)` + +Restricts the expectation to apply only to mock function calls whose arguments +as a whole match the multi-argument matcher *`multi_argument_matcher`*. + +GoogleTest passes all of the arguments as one tuple into the matcher. The +parameter *`multi_argument_matcher`* must thus be a matcher of type +`Matcher>`, where `A1, ..., An` are the types of the +function arguments. + +For example, the following code sets the expectation that +`my_mock.SetPosition()` is called with any two arguments, the first argument +being less than the second: + +```cpp +using ::testing::_; +using ::testing::Lt; +... +EXPECT_CALL(my_mock, SetPosition(_, _)) + .With(Lt()); +``` + +GoogleTest provides some built-in matchers for 2-tuples, including the `Lt()` +matcher above. See [Multi-argument Matchers](matchers.md#MultiArgMatchers). + +The `With` clause can be used at most once on an expectation and must be the +first clause. + +#### Times {#EXPECT_CALL.Times} + +`.Times(`*`cardinality`*`)` + +Specifies how many times the mock function call is expected. + +The parameter *`cardinality`* represents the number of expected calls and can be +one of the following, all defined in the `::testing` namespace: + +| Cardinality | Meaning | +| ------------------- | --------------------------------------------------- | +| `AnyNumber()` | The function can be called any number of times. | +| `AtLeast(n)` | The function call is expected at least *n* times. | +| `AtMost(n)` | The function call is expected at most *n* times. | +| `Between(m, n)` | The function call is expected between *m* and *n* times, inclusive. | +| `Exactly(n)` or `n` | The function call is expected exactly *n* times. If *n* is 0, the call should never happen. | + +If the `Times` clause is omitted, GoogleTest infers the cardinality as follows: + +* If neither [`WillOnce`](#EXPECT_CALL.WillOnce) nor + [`WillRepeatedly`](#EXPECT_CALL.WillRepeatedly) are specified, the inferred + cardinality is `Times(1)`. +* If there are *n* `WillOnce` clauses and no `WillRepeatedly` clause, where + *n* >= 1, the inferred cardinality is `Times(n)`. +* If there are *n* `WillOnce` clauses and one `WillRepeatedly` clause, where + *n* >= 0, the inferred cardinality is `Times(AtLeast(n))`. + +The `Times` clause can be used at most once on an expectation. + +#### InSequence {#EXPECT_CALL.InSequence} + +`.InSequence(`*`sequences...`*`)` + +Specifies that the mock function call is expected in a certain sequence. + +The parameter *`sequences...`* is any number of [`Sequence`](#Sequence) objects. +Expected calls assigned to the same sequence are expected to occur in the order +the expectations are declared. + +For example, the following code sets the expectation that the `Reset()` method +of `my_mock` is called before both `GetSize()` and `Describe()`, and `GetSize()` +and `Describe()` can occur in any order relative to each other: + +```cpp +using ::testing::Sequence; +Sequence s1, s2; +... +EXPECT_CALL(my_mock, Reset()) + .InSequence(s1, s2); +EXPECT_CALL(my_mock, GetSize()) + .InSequence(s1); +EXPECT_CALL(my_mock, Describe()) + .InSequence(s2); +``` + +The `InSequence` clause can be used any number of times on an expectation. + +See also the [`InSequence` class](#InSequence). + +#### After {#EXPECT_CALL.After} + +`.After(`*`expectations...`*`)` + +Specifies that the mock function call is expected to occur after one or more +other calls. + +The parameter *`expectations...`* can be up to five +[`Expectation`](#Expectation) or [`ExpectationSet`](#ExpectationSet) objects. +The mock function call is expected to occur after all of the given expectations. + +For example, the following code sets the expectation that the `Describe()` +method of `my_mock` is called only after both `InitX()` and `InitY()` have been +called. + +```cpp +using ::testing::Expectation; +... +Expectation init_x = EXPECT_CALL(my_mock, InitX()); +Expectation init_y = EXPECT_CALL(my_mock, InitY()); +EXPECT_CALL(my_mock, Describe()) + .After(init_x, init_y); +``` + +The `ExpectationSet` object is helpful when the number of prerequisites for an +expectation is large or variable, for example: + +```cpp +using ::testing::ExpectationSet; +... +ExpectationSet all_inits; +// Collect all expectations of InitElement() calls +for (int i = 0; i < element_count; i++) { + all_inits += EXPECT_CALL(my_mock, InitElement(i)); +} +EXPECT_CALL(my_mock, Describe()) + .After(all_inits); // Expect Describe() call after all InitElement() calls +``` + +The `After` clause can be used any number of times on an expectation. + +#### WillOnce {#EXPECT_CALL.WillOnce} + +`.WillOnce(`*`action`*`)` + +Specifies the mock function's actual behavior when invoked, for a single +matching function call. + +The parameter *`action`* represents the +[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function +call will perform. See the [Actions Reference](actions.md) for a list of +built-in actions. + +The use of `WillOnce` implicitly sets a cardinality on the expectation when +`Times` is not specified. See [`Times`](#EXPECT_CALL.Times). + +Each matching function call will perform the next action in the order declared. +For example, the following code specifies that `my_mock.GetNumber()` is expected +to be called exactly 3 times and will return `1`, `2`, and `3` respectively on +the first, second, and third calls: + +```cpp +using ::testing::Return; +... +EXPECT_CALL(my_mock, GetNumber()) + .WillOnce(Return(1)) + .WillOnce(Return(2)) + .WillOnce(Return(3)); +``` + +The `WillOnce` clause can be used any number of times on an expectation. + +#### WillRepeatedly {#EXPECT_CALL.WillRepeatedly} + +`.WillRepeatedly(`*`action`*`)` + +Specifies the mock function's actual behavior when invoked, for all subsequent +matching function calls. Takes effect after the actions specified in the +[`WillOnce`](#EXPECT_CALL.WillOnce) clauses, if any, have been performed. + +The parameter *`action`* represents the +[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function +call will perform. See the [Actions Reference](actions.md) for a list of +built-in actions. + +The use of `WillRepeatedly` implicitly sets a cardinality on the expectation +when `Times` is not specified. See [`Times`](#EXPECT_CALL.Times). + +If any `WillOnce` clauses have been specified, matching function calls will +perform those actions before the action specified by `WillRepeatedly`. See the +following example: + +```cpp +using ::testing::Return; +... +EXPECT_CALL(my_mock, GetName()) + .WillRepeatedly(Return("John Doe")); // Return "John Doe" on all calls + +EXPECT_CALL(my_mock, GetNumber()) + .WillOnce(Return(42)) // Return 42 on the first call + .WillRepeatedly(Return(7)); // Return 7 on all subsequent calls +``` + +The `WillRepeatedly` clause can be used at most once on an expectation. + +#### RetiresOnSaturation {#EXPECT_CALL.RetiresOnSaturation} + +`.RetiresOnSaturation()` + +Indicates that the expectation will no longer be active after the expected +number of matching function calls has been reached. + +The `RetiresOnSaturation` clause is only meaningful for expectations with an +upper-bounded cardinality. The expectation will *retire* (no longer match any +function calls) after it has been *saturated* (the upper bound has been +reached). See the following example: + +```cpp +using ::testing::_; +using ::testing::AnyNumber; +... +EXPECT_CALL(my_mock, SetNumber(_)) // Expectation 1 + .Times(AnyNumber()); +EXPECT_CALL(my_mock, SetNumber(7)) // Expectation 2 + .Times(2) + .RetiresOnSaturation(); +``` + +In the above example, the first two calls to `my_mock.SetNumber(7)` match +expectation 2, which then becomes inactive and no longer matches any calls. A +third call to `my_mock.SetNumber(7)` would then match expectation 1. Without +`RetiresOnSaturation()` on expectation 2, a third call to `my_mock.SetNumber(7)` +would match expectation 2 again, producing a failure since the limit of 2 calls +was exceeded. + +The `RetiresOnSaturation` clause can be used at most once on an expectation and +must be the last clause. + +### ON_CALL {#ON_CALL} + +`ON_CALL(`*`mock_object`*`,`*`method_name`*`(`*`matchers...`*`))` + +Defines what happens when the method *`method_name`* of the object +*`mock_object`* is called with arguments that match the given matchers +*`matchers...`*. Requires a modifier clause to specify the method's behavior. +*Does not* set any expectations that the method will be called. + +The parameter *`matchers...`* is a comma-separated list of +[matchers](../gmock_for_dummies.md#matchers-what-arguments-do-we-expect) that +correspond to each argument of the method *`method_name`*. The `ON_CALL` +specification will apply only to calls of *`method_name`* whose arguments match +all of the matchers. If `(`*`matchers...`*`)` is omitted, the behavior is as if +each argument's matcher were a [wildcard matcher (`_`)](matchers.md#wildcard). +See the [Matchers Reference](matchers.md) for a list of all built-in matchers. + +The following chainable clauses can be used to set the method's behavior, and +they must be used in the following order: + +```cpp +ON_CALL(mock_object, method_name(matchers...)) + .With(multi_argument_matcher) // Can be used at most once + .WillByDefault(action); // Required +``` + +See details for each modifier clause below. + +#### With {#ON_CALL.With} + +`.With(`*`multi_argument_matcher`*`)` + +Restricts the specification to only mock function calls whose arguments as a +whole match the multi-argument matcher *`multi_argument_matcher`*. + +GoogleTest passes all of the arguments as one tuple into the matcher. The +parameter *`multi_argument_matcher`* must thus be a matcher of type +`Matcher>`, where `A1, ..., An` are the types of the +function arguments. + +For example, the following code sets the default behavior when +`my_mock.SetPosition()` is called with any two arguments, the first argument +being less than the second: + +```cpp +using ::testing::_; +using ::testing::Lt; +using ::testing::Return; +... +ON_CALL(my_mock, SetPosition(_, _)) + .With(Lt()) + .WillByDefault(Return(true)); +``` + +GoogleTest provides some built-in matchers for 2-tuples, including the `Lt()` +matcher above. See [Multi-argument Matchers](matchers.md#MultiArgMatchers). + +The `With` clause can be used at most once with each `ON_CALL` statement. + +#### WillByDefault {#ON_CALL.WillByDefault} + +`.WillByDefault(`*`action`*`)` + +Specifies the default behavior of a matching mock function call. + +The parameter *`action`* represents the +[action](../gmock_for_dummies.md#actions-what-should-it-do) that the function +call will perform. See the [Actions Reference](actions.md) for a list of +built-in actions. + +For example, the following code specifies that by default, a call to +`my_mock.Greet()` will return `"hello"`: + +```cpp +using ::testing::Return; +... +ON_CALL(my_mock, Greet()) + .WillByDefault(Return("hello")); +``` + +The action specified by `WillByDefault` is superseded by the actions specified +on a matching `EXPECT_CALL` statement, if any. See the +[`WillOnce`](#EXPECT_CALL.WillOnce) and +[`WillRepeatedly`](#EXPECT_CALL.WillRepeatedly) clauses of `EXPECT_CALL`. + +The `WillByDefault` clause must be used exactly once with each `ON_CALL` +statement. + +## Classes {#classes} + +GoogleTest defines the following classes for working with mocks. + +### DefaultValue {#DefaultValue} + +`::testing::DefaultValue` + +Allows a user to specify the default value for a type `T` that is both copyable +and publicly destructible (i.e. anything that can be used as a function return +type). For mock functions with a return type of `T`, this default value is +returned from function calls that do not specify an action. + +Provides the static methods `Set()`, `SetFactory()`, and `Clear()` to manage the +default value: + +```cpp +// Sets the default value to be returned. T must be copy constructible. +DefaultValue::Set(value); + +// Sets a factory. Will be invoked on demand. T must be move constructible. +T MakeT(); +DefaultValue::SetFactory(&MakeT); + +// Unsets the default value. +DefaultValue::Clear(); +``` + +### NiceMock {#NiceMock} + +`::testing::NiceMock` + +Represents a mock object that suppresses warnings on +[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The +template parameter `T` is any mock class, except for another `NiceMock`, +`NaggyMock`, or `StrictMock`. + +Usage of `NiceMock` is analogous to usage of `T`. `NiceMock` is a subclass +of `T`, so it can be used wherever an object of type `T` is accepted. In +addition, `NiceMock` can be constructed with any arguments that a constructor +of `T` accepts. + +For example, the following code suppresses warnings on the mock `my_mock` of +type `MockClass` if a method other than `DoSomething()` is called: + +```cpp +using ::testing::NiceMock; +... +NiceMock my_mock("some", "args"); +EXPECT_CALL(my_mock, DoSomething()); +... code that uses my_mock ... +``` + +`NiceMock` only works for mock methods defined using the `MOCK_METHOD` macro +directly in the definition of class `T`. If a mock method is defined in a base +class of `T`, a warning might still be generated. + +`NiceMock` might not work correctly if the destructor of `T` is not virtual. + +### NaggyMock {#NaggyMock} + +`::testing::NaggyMock` + +Represents a mock object that generates warnings on +[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The +template parameter `T` is any mock class, except for another `NiceMock`, +`NaggyMock`, or `StrictMock`. + +Usage of `NaggyMock` is analogous to usage of `T`. `NaggyMock` is a +subclass of `T`, so it can be used wherever an object of type `T` is accepted. +In addition, `NaggyMock` can be constructed with any arguments that a +constructor of `T` accepts. + +For example, the following code generates warnings on the mock `my_mock` of type +`MockClass` if a method other than `DoSomething()` is called: + +```cpp +using ::testing::NaggyMock; +... +NaggyMock my_mock("some", "args"); +EXPECT_CALL(my_mock, DoSomething()); +... code that uses my_mock ... +``` + +Mock objects of type `T` by default behave the same way as `NaggyMock`. + +### StrictMock {#StrictMock} + +`::testing::StrictMock` + +Represents a mock object that generates test failures on +[uninteresting calls](../gmock_cook_book.md#uninteresting-vs-unexpected). The +template parameter `T` is any mock class, except for another `NiceMock`, +`NaggyMock`, or `StrictMock`. + +Usage of `StrictMock` is analogous to usage of `T`. `StrictMock` is a +subclass of `T`, so it can be used wherever an object of type `T` is accepted. +In addition, `StrictMock` can be constructed with any arguments that a +constructor of `T` accepts. + +For example, the following code generates a test failure on the mock `my_mock` +of type `MockClass` if a method other than `DoSomething()` is called: + +```cpp +using ::testing::StrictMock; +... +StrictMock my_mock("some", "args"); +EXPECT_CALL(my_mock, DoSomething()); +... code that uses my_mock ... +``` + +`StrictMock` only works for mock methods defined using the `MOCK_METHOD` +macro directly in the definition of class `T`. If a mock method is defined in a +base class of `T`, a failure might not be generated. + +`StrictMock` might not work correctly if the destructor of `T` is not +virtual. + +### Sequence {#Sequence} + +`::testing::Sequence` + +Represents a chronological sequence of expectations. See the +[`InSequence`](#EXPECT_CALL.InSequence) clause of `EXPECT_CALL` for usage. + +### InSequence {#InSequence} + +`::testing::InSequence` + +An object of this type causes all expectations encountered in its scope to be +put in an anonymous sequence. + +This allows more convenient expression of multiple expectations in a single +sequence: + +```cpp +using ::testing::InSequence; +{ + InSequence seq; + + // The following are expected to occur in the order declared. + EXPECT_CALL(...); + EXPECT_CALL(...); + ... + EXPECT_CALL(...); +} +``` + +The name of the `InSequence` object does not matter. + +### Expectation {#Expectation} + +`::testing::Expectation` + +Represents a mock function call expectation as created by +[`EXPECT_CALL`](#EXPECT_CALL): + +```cpp +using ::testing::Expectation; +Expectation my_expectation = EXPECT_CALL(...); +``` + +Useful for specifying sequences of expectations; see the +[`After`](#EXPECT_CALL.After) clause of `EXPECT_CALL`. + +### ExpectationSet {#ExpectationSet} + +`::testing::ExpectationSet` + +Represents a set of mock function call expectations. + +Use the `+=` operator to add [`Expectation`](#Expectation) objects to the set: + +```cpp +using ::testing::ExpectationSet; +ExpectationSet my_expectations; +my_expectations += EXPECT_CALL(...); +``` + +Useful for specifying sequences of expectations; see the +[`After`](#EXPECT_CALL.After) clause of `EXPECT_CALL`. diff --git a/ext/googletest/docs/reference/testing.md b/ext/googletest/docs/reference/testing.md new file mode 100644 index 0000000000..554d6c9584 --- /dev/null +++ b/ext/googletest/docs/reference/testing.md @@ -0,0 +1,1431 @@ +# Testing Reference + + + +This page lists the facilities provided by GoogleTest for writing test programs. +To use them, include the header `gtest/gtest.h`. + +## Macros + +GoogleTest defines the following macros for writing tests. + +### TEST {#TEST} + +
+TEST(TestSuiteName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual test named *`TestName`* in the test suite +*`TestSuiteName`*, consisting of the given statements. + +Both arguments *`TestSuiteName`* and *`TestName`* must be valid C++ identifiers +and must not contain underscores (`_`). Tests in different test suites can have +the same individual name. + +The statements within the test body can be any code under test. +[Assertions](assertions.md) used within the test body determine the outcome of +the test. + +### TEST_F {#TEST_F} + +
+TEST_F(TestFixtureName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual test named *`TestName`* that uses the test fixture class +*`TestFixtureName`*. The test suite name is *`TestFixtureName`*. + +Both arguments *`TestFixtureName`* and *`TestName`* must be valid C++ +identifiers and must not contain underscores (`_`). *`TestFixtureName`* must be +the name of a test fixture class—see +[Test Fixtures](../primer.md#same-data-multiple-tests). + +The statements within the test body can be any code under test. +[Assertions](assertions.md) used within the test body determine the outcome of +the test. + +### TEST_P {#TEST_P} + +
+TEST_P(TestFixtureName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual value-parameterized test named *`TestName`* that uses the +test fixture class *`TestFixtureName`*. The test suite name is +*`TestFixtureName`*. + +Both arguments *`TestFixtureName`* and *`TestName`* must be valid C++ +identifiers and must not contain underscores (`_`). *`TestFixtureName`* must be +the name of a value-parameterized test fixture class—see +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +The statements within the test body can be any code under test. Within the test +body, the test parameter can be accessed with the `GetParam()` function (see +[`WithParamInterface`](#WithParamInterface)). For example: + +```cpp +TEST_P(MyTestSuite, DoesSomething) { + ... + EXPECT_TRUE(DoSomething(GetParam())); + ... +} +``` + +[Assertions](assertions.md) used within the test body determine the outcome of +the test. + +See also [`INSTANTIATE_TEST_SUITE_P`](#INSTANTIATE_TEST_SUITE_P). + +### INSTANTIATE_TEST_SUITE_P {#INSTANTIATE_TEST_SUITE_P} + +`INSTANTIATE_TEST_SUITE_P(`*`InstantiationName`*`,`*`TestSuiteName`*`,`*`param_generator`*`)` +\ +`INSTANTIATE_TEST_SUITE_P(`*`InstantiationName`*`,`*`TestSuiteName`*`,`*`param_generator`*`,`*`name_generator`*`)` + +Instantiates the value-parameterized test suite *`TestSuiteName`* (defined with +[`TEST_P`](#TEST_P)). + +The argument *`InstantiationName`* is a unique name for the instantiation of the +test suite, to distinguish between multiple instantiations. In test output, the +instantiation name is added as a prefix to the test suite name +*`TestSuiteName`*. + +The argument *`param_generator`* is one of the following GoogleTest-provided +functions that generate the test parameters, all defined in the `::testing` +namespace: + + + +| Parameter Generator | Behavior | +| ------------------- | ---------------------------------------------------- | +| `Range(begin, end [, step])` | Yields values `{begin, begin+step, begin+step+step, ...}`. The values do not include `end`. `step` defaults to 1. | +| `Values(v1, v2, ..., vN)` | Yields values `{v1, v2, ..., vN}`. | +| `ValuesIn(container)` or `ValuesIn(begin,end)` | Yields values from a C-style array, an STL-style container, or an iterator range `[begin, end)`. | +| `Bool()` | Yields sequence `{false, true}`. | +| `Combine(g1, g2, ..., gN)` | Yields as `std::tuple` *n*-tuples all combinations (Cartesian product) of the values generated by the given *n* generators `g1`, `g2`, ..., `gN`. | + +The optional last argument *`name_generator`* is a function or functor that +generates custom test name suffixes based on the test parameters. The function +must accept an argument of type +[`TestParamInfo`](#TestParamInfo) and return a `std::string`. +The test name suffix can only contain alphanumeric characters and underscores. +GoogleTest provides [`PrintToStringParamName`](#PrintToStringParamName), or a +custom function can be used for more control: + +```cpp +INSTANTIATE_TEST_SUITE_P( + MyInstantiation, MyTestSuite, + ::testing::Values(...), + [](const ::testing::TestParamInfo& info) { + // Can use info.param here to generate the test suffix + std::string name = ... + return name; + }); +``` + +For more information, see +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +See also +[`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST`](#GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST). + +### TYPED_TEST_SUITE {#TYPED_TEST_SUITE} + +`TYPED_TEST_SUITE(`*`TestFixtureName`*`,`*`Types`*`)` + +Defines a typed test suite based on the test fixture *`TestFixtureName`*. The +test suite name is *`TestFixtureName`*. + +The argument *`TestFixtureName`* is a fixture class template, parameterized by a +type, for example: + +```cpp +template +class MyFixture : public ::testing::Test { + public: + ... + using List = std::list; + static T shared_; + T value_; +}; +``` + +The argument *`Types`* is a [`Types`](#Types) object representing the list of +types to run the tests on, for example: + +```cpp +using MyTypes = ::testing::Types; +TYPED_TEST_SUITE(MyFixture, MyTypes); +``` + +The type alias (`using` or `typedef`) is necessary for the `TYPED_TEST_SUITE` +macro to parse correctly. + +See also [`TYPED_TEST`](#TYPED_TEST) and +[Typed Tests](../advanced.md#typed-tests) for more information. + +### TYPED_TEST {#TYPED_TEST} + +
+TYPED_TEST(TestSuiteName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual typed test named *`TestName`* in the typed test suite +*`TestSuiteName`*. The test suite must be defined with +[`TYPED_TEST_SUITE`](#TYPED_TEST_SUITE). + +Within the test body, the special name `TypeParam` refers to the type parameter, +and `TestFixture` refers to the fixture class. See the following example: + +```cpp +TYPED_TEST(MyFixture, Example) { + // Inside a test, refer to the special name TypeParam to get the type + // parameter. Since we are inside a derived class template, C++ requires + // us to visit the members of MyFixture via 'this'. + TypeParam n = this->value_; + + // To visit static members of the fixture, add the 'TestFixture::' + // prefix. + n += TestFixture::shared_; + + // To refer to typedefs in the fixture, add the 'typename TestFixture::' + // prefix. The 'typename' is required to satisfy the compiler. + typename TestFixture::List values; + + values.push_back(n); + ... +} +``` + +For more information, see [Typed Tests](../advanced.md#typed-tests). + +### TYPED_TEST_SUITE_P {#TYPED_TEST_SUITE_P} + +`TYPED_TEST_SUITE_P(`*`TestFixtureName`*`)` + +Defines a type-parameterized test suite based on the test fixture +*`TestFixtureName`*. The test suite name is *`TestFixtureName`*. + +The argument *`TestFixtureName`* is a fixture class template, parameterized by a +type. See [`TYPED_TEST_SUITE`](#TYPED_TEST_SUITE) for an example. + +See also [`TYPED_TEST_P`](#TYPED_TEST_P) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### TYPED_TEST_P {#TYPED_TEST_P} + +
+TYPED_TEST_P(TestSuiteName, TestName) {
+  ... statements ...
+}
+
+ +Defines an individual type-parameterized test named *`TestName`* in the +type-parameterized test suite *`TestSuiteName`*. The test suite must be defined +with [`TYPED_TEST_SUITE_P`](#TYPED_TEST_SUITE_P). + +Within the test body, the special name `TypeParam` refers to the type parameter, +and `TestFixture` refers to the fixture class. See [`TYPED_TEST`](#TYPED_TEST) +for an example. + +See also [`REGISTER_TYPED_TEST_SUITE_P`](#REGISTER_TYPED_TEST_SUITE_P) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### REGISTER_TYPED_TEST_SUITE_P {#REGISTER_TYPED_TEST_SUITE_P} + +`REGISTER_TYPED_TEST_SUITE_P(`*`TestSuiteName`*`,`*`TestNames...`*`)` + +Registers the type-parameterized tests *`TestNames...`* of the test suite +*`TestSuiteName`*. The test suite and tests must be defined with +[`TYPED_TEST_SUITE_P`](#TYPED_TEST_SUITE_P) and [`TYPED_TEST_P`](#TYPED_TEST_P). + +For example: + +```cpp +// Define the test suite and tests. +TYPED_TEST_SUITE_P(MyFixture); +TYPED_TEST_P(MyFixture, HasPropertyA) { ... } +TYPED_TEST_P(MyFixture, HasPropertyB) { ... } + +// Register the tests in the test suite. +REGISTER_TYPED_TEST_SUITE_P(MyFixture, HasPropertyA, HasPropertyB); +``` + +See also [`INSTANTIATE_TYPED_TEST_SUITE_P`](#INSTANTIATE_TYPED_TEST_SUITE_P) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### INSTANTIATE_TYPED_TEST_SUITE_P {#INSTANTIATE_TYPED_TEST_SUITE_P} + +`INSTANTIATE_TYPED_TEST_SUITE_P(`*`InstantiationName`*`,`*`TestSuiteName`*`,`*`Types`*`)` + +Instantiates the type-parameterized test suite *`TestSuiteName`*. The test suite +must be registered with +[`REGISTER_TYPED_TEST_SUITE_P`](#REGISTER_TYPED_TEST_SUITE_P). + +The argument *`InstantiationName`* is a unique name for the instantiation of the +test suite, to distinguish between multiple instantiations. In test output, the +instantiation name is added as a prefix to the test suite name +*`TestSuiteName`*. + +The argument *`Types`* is a [`Types`](#Types) object representing the list of +types to run the tests on, for example: + +```cpp +using MyTypes = ::testing::Types; +INSTANTIATE_TYPED_TEST_SUITE_P(MyInstantiation, MyFixture, MyTypes); +``` + +The type alias (`using` or `typedef`) is necessary for the +`INSTANTIATE_TYPED_TEST_SUITE_P` macro to parse correctly. + +For more information, see +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests). + +### FRIEND_TEST {#FRIEND_TEST} + +`FRIEND_TEST(`*`TestSuiteName`*`,`*`TestName`*`)` + +Within a class body, declares an individual test as a friend of the class, +enabling the test to access private class members. + +If the class is defined in a namespace, then in order to be friends of the +class, test fixtures and tests must be defined in the exact same namespace, +without inline or anonymous namespaces. + +For example, if the class definition looks like the following: + +```cpp +namespace my_namespace { + +class MyClass { + friend class MyClassTest; + FRIEND_TEST(MyClassTest, HasPropertyA); + FRIEND_TEST(MyClassTest, HasPropertyB); + ... definition of class MyClass ... +}; + +} // namespace my_namespace +``` + +Then the test code should look like: + +```cpp +namespace my_namespace { + +class MyClassTest : public ::testing::Test { + ... +}; + +TEST_F(MyClassTest, HasPropertyA) { ... } +TEST_F(MyClassTest, HasPropertyB) { ... } + +} // namespace my_namespace +``` + +See [Testing Private Code](../advanced.md#testing-private-code) for more +information. + +### SCOPED_TRACE {#SCOPED_TRACE} + +`SCOPED_TRACE(`*`message`*`)` + +Causes the current file name, line number, and the given message *`message`* to +be added to the failure message for each assertion failure that occurs in the +scope. + +For more information, see +[Adding Traces to Assertions](../advanced.md#adding-traces-to-assertions). + +See also the [`ScopedTrace` class](#ScopedTrace). + +### GTEST_SKIP {#GTEST_SKIP} + +`GTEST_SKIP()` + +Prevents further test execution at runtime. + +Can be used in individual test cases or in the `SetUp()` methods of test +environments or test fixtures (classes derived from the +[`Environment`](#Environment) or [`Test`](#Test) classes). If used in a global +test environment `SetUp()` method, it skips all tests in the test program. If +used in a test fixture `SetUp()` method, it skips all tests in the corresponding +test suite. + +Similar to assertions, `GTEST_SKIP` allows streaming a custom message into it. + +See [Skipping Test Execution](../advanced.md#skipping-test-execution) for more +information. + +### GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST {#GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST} + +`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(`*`TestSuiteName`*`)` + +Allows the value-parameterized test suite *`TestSuiteName`* to be +uninstantiated. + +By default, every [`TEST_P`](#TEST_P) call without a corresponding +[`INSTANTIATE_TEST_SUITE_P`](#INSTANTIATE_TEST_SUITE_P) call causes a failing +test in the test suite `GoogleTestVerification`. +`GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST` suppresses this failure for the +given test suite. + +## Classes and types + +GoogleTest defines the following classes and types to help with writing tests. + +### AssertionResult {#AssertionResult} + +`::testing::AssertionResult` + +A class for indicating whether an assertion was successful. + +When the assertion wasn't successful, the `AssertionResult` object stores a +non-empty failure message that can be retrieved with the object's `message()` +method. + +To create an instance of this class, use one of the factory functions +[`AssertionSuccess()`](#AssertionSuccess) or +[`AssertionFailure()`](#AssertionFailure). + +### AssertionException {#AssertionException} + +`::testing::AssertionException` + +Exception which can be thrown from +[`TestEventListener::OnTestPartResult`](#TestEventListener::OnTestPartResult). + +### EmptyTestEventListener {#EmptyTestEventListener} + +`::testing::EmptyTestEventListener` + +Provides an empty implementation of all methods in the +[`TestEventListener`](#TestEventListener) interface, such that a subclass only +needs to override the methods it cares about. + +### Environment {#Environment} + +`::testing::Environment` + +Represents a global test environment. See +[Global Set-Up and Tear-Down](../advanced.md#global-set-up-and-tear-down). + +#### Protected Methods {#Environment-protected} + +##### SetUp {#Environment::SetUp} + +`virtual void Environment::SetUp()` + +Override this to define how to set up the environment. + +##### TearDown {#Environment::TearDown} + +`virtual void Environment::TearDown()` + +Override this to define how to tear down the environment. + +### ScopedTrace {#ScopedTrace} + +`::testing::ScopedTrace` + +An instance of this class causes a trace to be included in every test failure +message generated by code in the scope of the lifetime of the `ScopedTrace` +instance. The effect is undone with the destruction of the instance. + +The `ScopedTrace` constructor has the following form: + +```cpp +template +ScopedTrace(const char* file, int line, const T& message) +``` + +Example usage: + +```cpp +::testing::ScopedTrace trace("file.cc", 123, "message"); +``` + +The resulting trace includes the given source file path and line number, and the +given message. The `message` argument can be anything streamable to +`std::ostream`. + +See also [`SCOPED_TRACE`](#SCOPED_TRACE). + +### Test {#Test} + +`::testing::Test` + +The abstract class that all tests inherit from. `Test` is not copyable. + +#### Public Methods {#Test-public} + +##### SetUpTestSuite {#Test::SetUpTestSuite} + +`static void Test::SetUpTestSuite()` + +Performs shared setup for all tests in the test suite. GoogleTest calls +`SetUpTestSuite()` before running the first test in the test suite. + +##### TearDownTestSuite {#Test::TearDownTestSuite} + +`static void Test::TearDownTestSuite()` + +Performs shared teardown for all tests in the test suite. GoogleTest calls +`TearDownTestSuite()` after running the last test in the test suite. + +##### HasFatalFailure {#Test::HasFatalFailure} + +`static bool Test::HasFatalFailure()` + +Returns true if and only if the current test has a fatal failure. + +##### HasNonfatalFailure {#Test::HasNonfatalFailure} + +`static bool Test::HasNonfatalFailure()` + +Returns true if and only if the current test has a nonfatal failure. + +##### HasFailure {#Test::HasFailure} + +`static bool Test::HasFailure()` + +Returns true if and only if the current test has any failure, either fatal or +nonfatal. + +##### IsSkipped {#Test::IsSkipped} + +`static bool Test::IsSkipped()` + +Returns true if and only if the current test was skipped. + +##### RecordProperty {#Test::RecordProperty} + +`static void Test::RecordProperty(const std::string& key, const std::string& +value)` \ +`static void Test::RecordProperty(const std::string& key, int value)` + +Logs a property for the current test, test suite, or entire invocation of the +test program. Only the last value for a given key is logged. + +The key must be a valid XML attribute name, and cannot conflict with the ones +already used by GoogleTest (`name`, `status`, `time`, `classname`, `type_param`, +and `value_param`). + +`RecordProperty` is `public static` so it can be called from utility functions +that are not members of the test fixture. + +Calls to `RecordProperty` made during the lifespan of the test (from the moment +its constructor starts to the moment its destructor finishes) are output in XML +as attributes of the `` element. Properties recorded from a fixture's +`SetUpTestSuite` or `TearDownTestSuite` methods are logged as attributes of the +corresponding `` element. Calls to `RecordProperty` made in the +global context (before or after invocation of `RUN_ALL_TESTS` or from the +`SetUp`/`TearDown` methods of registered `Environment` objects) are output as +attributes of the `` element. + +#### Protected Methods {#Test-protected} + +##### SetUp {#Test::SetUp} + +`virtual void Test::SetUp()` + +Override this to perform test fixture setup. GoogleTest calls `SetUp()` before +running each individual test. + +##### TearDown {#Test::TearDown} + +`virtual void Test::TearDown()` + +Override this to perform test fixture teardown. GoogleTest calls `TearDown()` +after running each individual test. + +### TestWithParam {#TestWithParam} + +`::testing::TestWithParam` + +A convenience class which inherits from both [`Test`](#Test) and +[`WithParamInterface`](#WithParamInterface). + +### TestSuite {#TestSuite} + +Represents a test suite. `TestSuite` is not copyable. + +#### Public Methods {#TestSuite-public} + +##### name {#TestSuite::name} + +`const char* TestSuite::name() const` + +Gets the name of the test suite. + +##### type_param {#TestSuite::type_param} + +`const char* TestSuite::type_param() const` + +Returns the name of the parameter type, or `NULL` if this is not a typed or +type-parameterized test suite. See [Typed Tests](../advanced.md#typed-tests) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests). + +##### should_run {#TestSuite::should_run} + +`bool TestSuite::should_run() const` + +Returns true if any test in this test suite should run. + +##### successful_test_count {#TestSuite::successful_test_count} + +`int TestSuite::successful_test_count() const` + +Gets the number of successful tests in this test suite. + +##### skipped_test_count {#TestSuite::skipped_test_count} + +`int TestSuite::skipped_test_count() const` + +Gets the number of skipped tests in this test suite. + +##### failed_test_count {#TestSuite::failed_test_count} + +`int TestSuite::failed_test_count() const` + +Gets the number of failed tests in this test suite. + +##### reportable_disabled_test_count {#TestSuite::reportable_disabled_test_count} + +`int TestSuite::reportable_disabled_test_count() const` + +Gets the number of disabled tests that will be reported in the XML report. + +##### disabled_test_count {#TestSuite::disabled_test_count} + +`int TestSuite::disabled_test_count() const` + +Gets the number of disabled tests in this test suite. + +##### reportable_test_count {#TestSuite::reportable_test_count} + +`int TestSuite::reportable_test_count() const` + +Gets the number of tests to be printed in the XML report. + +##### test_to_run_count {#TestSuite::test_to_run_count} + +`int TestSuite::test_to_run_count() const` + +Get the number of tests in this test suite that should run. + +##### total_test_count {#TestSuite::total_test_count} + +`int TestSuite::total_test_count() const` + +Gets the number of all tests in this test suite. + +##### Passed {#TestSuite::Passed} + +`bool TestSuite::Passed() const` + +Returns true if and only if the test suite passed. + +##### Failed {#TestSuite::Failed} + +`bool TestSuite::Failed() const` + +Returns true if and only if the test suite failed. + +##### elapsed_time {#TestSuite::elapsed_time} + +`TimeInMillis TestSuite::elapsed_time() const` + +Returns the elapsed time, in milliseconds. + +##### start_timestamp {#TestSuite::start_timestamp} + +`TimeInMillis TestSuite::start_timestamp() const` + +Gets the time of the test suite start, in ms from the start of the UNIX epoch. + +##### GetTestInfo {#TestSuite::GetTestInfo} + +`const TestInfo* TestSuite::GetTestInfo(int i) const` + +Returns the [`TestInfo`](#TestInfo) for the `i`-th test among all the tests. `i` +can range from 0 to `total_test_count() - 1`. If `i` is not in that range, +returns `NULL`. + +##### ad_hoc_test_result {#TestSuite::ad_hoc_test_result} + +`const TestResult& TestSuite::ad_hoc_test_result() const` + +Returns the [`TestResult`](#TestResult) that holds test properties recorded +during execution of `SetUpTestSuite` and `TearDownTestSuite`. + +### TestInfo {#TestInfo} + +`::testing::TestInfo` + +Stores information about a test. + +#### Public Methods {#TestInfo-public} + +##### test_suite_name {#TestInfo::test_suite_name} + +`const char* TestInfo::test_suite_name() const` + +Returns the test suite name. + +##### name {#TestInfo::name} + +`const char* TestInfo::name() const` + +Returns the test name. + +##### type_param {#TestInfo::type_param} + +`const char* TestInfo::type_param() const` + +Returns the name of the parameter type, or `NULL` if this is not a typed or +type-parameterized test. See [Typed Tests](../advanced.md#typed-tests) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests). + +##### value_param {#TestInfo::value_param} + +`const char* TestInfo::value_param() const` + +Returns the text representation of the value parameter, or `NULL` if this is not +a value-parameterized test. See +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +##### file {#TestInfo::file} + +`const char* TestInfo::file() const` + +Returns the file name where this test is defined. + +##### line {#TestInfo::line} + +`int TestInfo::line() const` + +Returns the line where this test is defined. + +##### is_in_another_shard {#TestInfo::is_in_another_shard} + +`bool TestInfo::is_in_another_shard() const` + +Returns true if this test should not be run because it's in another shard. + +##### should_run {#TestInfo::should_run} + +`bool TestInfo::should_run() const` + +Returns true if this test should run, that is if the test is not disabled (or it +is disabled but the `also_run_disabled_tests` flag has been specified) and its +full name matches the user-specified filter. + +GoogleTest allows the user to filter the tests by their full names. Only the +tests that match the filter will run. See +[Running a Subset of the Tests](../advanced.md#running-a-subset-of-the-tests) +for more information. + +##### is_reportable {#TestInfo::is_reportable} + +`bool TestInfo::is_reportable() const` + +Returns true if and only if this test will appear in the XML report. + +##### result {#TestInfo::result} + +`const TestResult* TestInfo::result() const` + +Returns the result of the test. See [`TestResult`](#TestResult). + +### TestParamInfo {#TestParamInfo} + +`::testing::TestParamInfo` + +Describes a parameter to a value-parameterized test. The type `T` is the type of +the parameter. + +Contains the fields `param` and `index` which hold the value of the parameter +and its integer index respectively. + +### UnitTest {#UnitTest} + +`::testing::UnitTest` + +This class contains information about the test program. + +`UnitTest` is a singleton class. The only instance is created when +`UnitTest::GetInstance()` is first called. This instance is never deleted. + +`UnitTest` is not copyable. + +#### Public Methods {#UnitTest-public} + +##### GetInstance {#UnitTest::GetInstance} + +`static UnitTest* UnitTest::GetInstance()` + +Gets the singleton `UnitTest` object. The first time this method is called, a +`UnitTest` object is constructed and returned. Consecutive calls will return the +same object. + +##### original_working_dir {#UnitTest::original_working_dir} + +`const char* UnitTest::original_working_dir() const` + +Returns the working directory when the first [`TEST()`](#TEST) or +[`TEST_F()`](#TEST_F) was executed. The `UnitTest` object owns the string. + +##### current_test_suite {#UnitTest::current_test_suite} + +`const TestSuite* UnitTest::current_test_suite() const` + +Returns the [`TestSuite`](#TestSuite) object for the test that's currently +running, or `NULL` if no test is running. + +##### current_test_info {#UnitTest::current_test_info} + +`const TestInfo* UnitTest::current_test_info() const` + +Returns the [`TestInfo`](#TestInfo) object for the test that's currently +running, or `NULL` if no test is running. + +##### random_seed {#UnitTest::random_seed} + +`int UnitTest::random_seed() const` + +Returns the random seed used at the start of the current test run. + +##### successful_test_suite_count {#UnitTest::successful_test_suite_count} + +`int UnitTest::successful_test_suite_count() const` + +Gets the number of successful test suites. + +##### failed_test_suite_count {#UnitTest::failed_test_suite_count} + +`int UnitTest::failed_test_suite_count() const` + +Gets the number of failed test suites. + +##### total_test_suite_count {#UnitTest::total_test_suite_count} + +`int UnitTest::total_test_suite_count() const` + +Gets the number of all test suites. + +##### test_suite_to_run_count {#UnitTest::test_suite_to_run_count} + +`int UnitTest::test_suite_to_run_count() const` + +Gets the number of all test suites that contain at least one test that should +run. + +##### successful_test_count {#UnitTest::successful_test_count} + +`int UnitTest::successful_test_count() const` + +Gets the number of successful tests. + +##### skipped_test_count {#UnitTest::skipped_test_count} + +`int UnitTest::skipped_test_count() const` + +Gets the number of skipped tests. + +##### failed_test_count {#UnitTest::failed_test_count} + +`int UnitTest::failed_test_count() const` + +Gets the number of failed tests. + +##### reportable_disabled_test_count {#UnitTest::reportable_disabled_test_count} + +`int UnitTest::reportable_disabled_test_count() const` + +Gets the number of disabled tests that will be reported in the XML report. + +##### disabled_test_count {#UnitTest::disabled_test_count} + +`int UnitTest::disabled_test_count() const` + +Gets the number of disabled tests. + +##### reportable_test_count {#UnitTest::reportable_test_count} + +`int UnitTest::reportable_test_count() const` + +Gets the number of tests to be printed in the XML report. + +##### total_test_count {#UnitTest::total_test_count} + +`int UnitTest::total_test_count() const` + +Gets the number of all tests. + +##### test_to_run_count {#UnitTest::test_to_run_count} + +`int UnitTest::test_to_run_count() const` + +Gets the number of tests that should run. + +##### start_timestamp {#UnitTest::start_timestamp} + +`TimeInMillis UnitTest::start_timestamp() const` + +Gets the time of the test program start, in ms from the start of the UNIX epoch. + +##### elapsed_time {#UnitTest::elapsed_time} + +`TimeInMillis UnitTest::elapsed_time() const` + +Gets the elapsed time, in milliseconds. + +##### Passed {#UnitTest::Passed} + +`bool UnitTest::Passed() const` + +Returns true if and only if the unit test passed (i.e. all test suites passed). + +##### Failed {#UnitTest::Failed} + +`bool UnitTest::Failed() const` + +Returns true if and only if the unit test failed (i.e. some test suite failed or +something outside of all tests failed). + +##### GetTestSuite {#UnitTest::GetTestSuite} + +`const TestSuite* UnitTest::GetTestSuite(int i) const` + +Gets the [`TestSuite`](#TestSuite) object for the `i`-th test suite among all +the test suites. `i` can range from 0 to `total_test_suite_count() - 1`. If `i` +is not in that range, returns `NULL`. + +##### ad_hoc_test_result {#UnitTest::ad_hoc_test_result} + +`const TestResult& UnitTest::ad_hoc_test_result() const` + +Returns the [`TestResult`](#TestResult) containing information on test failures +and properties logged outside of individual test suites. + +##### listeners {#UnitTest::listeners} + +`TestEventListeners& UnitTest::listeners()` + +Returns the list of event listeners that can be used to track events inside +GoogleTest. See [`TestEventListeners`](#TestEventListeners). + +### TestEventListener {#TestEventListener} + +`::testing::TestEventListener` + +The interface for tracing execution of tests. The methods below are listed in +the order the corresponding events are fired. + +#### Public Methods {#TestEventListener-public} + +##### OnTestProgramStart {#TestEventListener::OnTestProgramStart} + +`virtual void TestEventListener::OnTestProgramStart(const UnitTest& unit_test)` + +Fired before any test activity starts. + +##### OnTestIterationStart {#TestEventListener::OnTestIterationStart} + +`virtual void TestEventListener::OnTestIterationStart(const UnitTest& unit_test, +int iteration)` + +Fired before each iteration of tests starts. There may be more than one +iteration if `GTEST_FLAG(repeat)` is set. `iteration` is the iteration index, +starting from 0. + +##### OnEnvironmentsSetUpStart {#TestEventListener::OnEnvironmentsSetUpStart} + +`virtual void TestEventListener::OnEnvironmentsSetUpStart(const UnitTest& +unit_test)` + +Fired before environment set-up for each iteration of tests starts. + +##### OnEnvironmentsSetUpEnd {#TestEventListener::OnEnvironmentsSetUpEnd} + +`virtual void TestEventListener::OnEnvironmentsSetUpEnd(const UnitTest& +unit_test)` + +Fired after environment set-up for each iteration of tests ends. + +##### OnTestSuiteStart {#TestEventListener::OnTestSuiteStart} + +`virtual void TestEventListener::OnTestSuiteStart(const TestSuite& test_suite)` + +Fired before the test suite starts. + +##### OnTestStart {#TestEventListener::OnTestStart} + +`virtual void TestEventListener::OnTestStart(const TestInfo& test_info)` + +Fired before the test starts. + +##### OnTestPartResult {#TestEventListener::OnTestPartResult} + +`virtual void TestEventListener::OnTestPartResult(const TestPartResult& +test_part_result)` + +Fired after a failed assertion or a `SUCCEED()` invocation. If you want to throw +an exception from this function to skip to the next test, it must be an +[`AssertionException`](#AssertionException) or inherited from it. + +##### OnTestEnd {#TestEventListener::OnTestEnd} + +`virtual void TestEventListener::OnTestEnd(const TestInfo& test_info)` + +Fired after the test ends. + +##### OnTestSuiteEnd {#TestEventListener::OnTestSuiteEnd} + +`virtual void TestEventListener::OnTestSuiteEnd(const TestSuite& test_suite)` + +Fired after the test suite ends. + +##### OnEnvironmentsTearDownStart {#TestEventListener::OnEnvironmentsTearDownStart} + +`virtual void TestEventListener::OnEnvironmentsTearDownStart(const UnitTest& +unit_test)` + +Fired before environment tear-down for each iteration of tests starts. + +##### OnEnvironmentsTearDownEnd {#TestEventListener::OnEnvironmentsTearDownEnd} + +`virtual void TestEventListener::OnEnvironmentsTearDownEnd(const UnitTest& +unit_test)` + +Fired after environment tear-down for each iteration of tests ends. + +##### OnTestIterationEnd {#TestEventListener::OnTestIterationEnd} + +`virtual void TestEventListener::OnTestIterationEnd(const UnitTest& unit_test, +int iteration)` + +Fired after each iteration of tests finishes. + +##### OnTestProgramEnd {#TestEventListener::OnTestProgramEnd} + +`virtual void TestEventListener::OnTestProgramEnd(const UnitTest& unit_test)` + +Fired after all test activities have ended. + +### TestEventListeners {#TestEventListeners} + +`::testing::TestEventListeners` + +Lets users add listeners to track events in GoogleTest. + +#### Public Methods {#TestEventListeners-public} + +##### Append {#TestEventListeners::Append} + +`void TestEventListeners::Append(TestEventListener* listener)` + +Appends an event listener to the end of the list. GoogleTest assumes ownership +of the listener (i.e. it will delete the listener when the test program +finishes). + +##### Release {#TestEventListeners::Release} + +`TestEventListener* TestEventListeners::Release(TestEventListener* listener)` + +Removes the given event listener from the list and returns it. It then becomes +the caller's responsibility to delete the listener. Returns `NULL` if the +listener is not found in the list. + +##### default_result_printer {#TestEventListeners::default_result_printer} + +`TestEventListener* TestEventListeners::default_result_printer() const` + +Returns the standard listener responsible for the default console output. Can be +removed from the listeners list to shut down default console output. Note that +removing this object from the listener list with +[`Release()`](#TestEventListeners::Release) transfers its ownership to the +caller and makes this function return `NULL` the next time. + +##### default_xml_generator {#TestEventListeners::default_xml_generator} + +`TestEventListener* TestEventListeners::default_xml_generator() const` + +Returns the standard listener responsible for the default XML output controlled +by the `--gtest_output=xml` flag. Can be removed from the listeners list by +users who want to shut down the default XML output controlled by this flag and +substitute it with custom one. Note that removing this object from the listener +list with [`Release()`](#TestEventListeners::Release) transfers its ownership to +the caller and makes this function return `NULL` the next time. + +### TestPartResult {#TestPartResult} + +`::testing::TestPartResult` + +A copyable object representing the result of a test part (i.e. an assertion or +an explicit `FAIL()`, `ADD_FAILURE()`, or `SUCCESS()`). + +#### Public Methods {#TestPartResult-public} + +##### type {#TestPartResult::type} + +`Type TestPartResult::type() const` + +Gets the outcome of the test part. + +The return type `Type` is an enum defined as follows: + +```cpp +enum Type { + kSuccess, // Succeeded. + kNonFatalFailure, // Failed but the test can continue. + kFatalFailure, // Failed and the test should be terminated. + kSkip // Skipped. +}; +``` + +##### file_name {#TestPartResult::file_name} + +`const char* TestPartResult::file_name() const` + +Gets the name of the source file where the test part took place, or `NULL` if +it's unknown. + +##### line_number {#TestPartResult::line_number} + +`int TestPartResult::line_number() const` + +Gets the line in the source file where the test part took place, or `-1` if it's +unknown. + +##### summary {#TestPartResult::summary} + +`const char* TestPartResult::summary() const` + +Gets the summary of the failure message. + +##### message {#TestPartResult::message} + +`const char* TestPartResult::message() const` + +Gets the message associated with the test part. + +##### skipped {#TestPartResult::skipped} + +`bool TestPartResult::skipped() const` + +Returns true if and only if the test part was skipped. + +##### passed {#TestPartResult::passed} + +`bool TestPartResult::passed() const` + +Returns true if and only if the test part passed. + +##### nonfatally_failed {#TestPartResult::nonfatally_failed} + +`bool TestPartResult::nonfatally_failed() const` + +Returns true if and only if the test part non-fatally failed. + +##### fatally_failed {#TestPartResult::fatally_failed} + +`bool TestPartResult::fatally_failed() const` + +Returns true if and only if the test part fatally failed. + +##### failed {#TestPartResult::failed} + +`bool TestPartResult::failed() const` + +Returns true if and only if the test part failed. + +### TestProperty {#TestProperty} + +`::testing::TestProperty` + +A copyable object representing a user-specified test property which can be +output as a key/value string pair. + +#### Public Methods {#TestProperty-public} + +##### key {#key} + +`const char* key() const` + +Gets the user-supplied key. + +##### value {#value} + +`const char* value() const` + +Gets the user-supplied value. + +##### SetValue {#SetValue} + +`void SetValue(const std::string& new_value)` + +Sets a new value, overriding the previous one. + +### TestResult {#TestResult} + +`::testing::TestResult` + +Contains information about the result of a single test. + +`TestResult` is not copyable. + +#### Public Methods {#TestResult-public} + +##### total_part_count {#TestResult::total_part_count} + +`int TestResult::total_part_count() const` + +Gets the number of all test parts. This is the sum of the number of successful +test parts and the number of failed test parts. + +##### test_property_count {#TestResult::test_property_count} + +`int TestResult::test_property_count() const` + +Returns the number of test properties. + +##### Passed {#TestResult::Passed} + +`bool TestResult::Passed() const` + +Returns true if and only if the test passed (i.e. no test part failed). + +##### Skipped {#TestResult::Skipped} + +`bool TestResult::Skipped() const` + +Returns true if and only if the test was skipped. + +##### Failed {#TestResult::Failed} + +`bool TestResult::Failed() const` + +Returns true if and only if the test failed. + +##### HasFatalFailure {#TestResult::HasFatalFailure} + +`bool TestResult::HasFatalFailure() const` + +Returns true if and only if the test fatally failed. + +##### HasNonfatalFailure {#TestResult::HasNonfatalFailure} + +`bool TestResult::HasNonfatalFailure() const` + +Returns true if and only if the test has a non-fatal failure. + +##### elapsed_time {#TestResult::elapsed_time} + +`TimeInMillis TestResult::elapsed_time() const` + +Returns the elapsed time, in milliseconds. + +##### start_timestamp {#TestResult::start_timestamp} + +`TimeInMillis TestResult::start_timestamp() const` + +Gets the time of the test case start, in ms from the start of the UNIX epoch. + +##### GetTestPartResult {#TestResult::GetTestPartResult} + +`const TestPartResult& TestResult::GetTestPartResult(int i) const` + +Returns the [`TestPartResult`](#TestPartResult) for the `i`-th test part result +among all the results. `i` can range from 0 to `total_part_count() - 1`. If `i` +is not in that range, aborts the program. + +##### GetTestProperty {#TestResult::GetTestProperty} + +`const TestProperty& TestResult::GetTestProperty(int i) const` + +Returns the [`TestProperty`](#TestProperty) object for the `i`-th test property. +`i` can range from 0 to `test_property_count() - 1`. If `i` is not in that +range, aborts the program. + +### TimeInMillis {#TimeInMillis} + +`::testing::TimeInMillis` + +An integer type representing time in milliseconds. + +### Types {#Types} + +`::testing::Types` + +Represents a list of types for use in typed tests and type-parameterized tests. + +The template argument `T...` can be any number of types, for example: + +``` +::testing::Types +``` + +See [Typed Tests](../advanced.md#typed-tests) and +[Type-Parameterized Tests](../advanced.md#type-parameterized-tests) for more +information. + +### WithParamInterface {#WithParamInterface} + +`::testing::WithParamInterface` + +The pure interface class that all value-parameterized tests inherit from. + +A value-parameterized test fixture class must inherit from both [`Test`](#Test) +and `WithParamInterface`. In most cases that just means inheriting from +[`TestWithParam`](#TestWithParam), but more complicated test hierarchies may +need to inherit from `Test` and `WithParamInterface` at different levels. + +This interface defines the type alias `ParamType` for the parameter type `T` and +has support for accessing the test parameter value via the `GetParam()` method: + +``` +static const ParamType& GetParam() +``` + +For more information, see +[Value-Parameterized Tests](../advanced.md#value-parameterized-tests). + +## Functions + +GoogleTest defines the following functions to help with writing and running +tests. + +### InitGoogleTest {#InitGoogleTest} + +`void ::testing::InitGoogleTest(int* argc, char** argv)` \ +`void ::testing::InitGoogleTest(int* argc, wchar_t** argv)` \ +`void ::testing::InitGoogleTest()` + +Initializes GoogleTest. This must be called before calling +[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS). In particular, it parses the command line +for the flags that GoogleTest recognizes. Whenever a GoogleTest flag is seen, it +is removed from `argv`, and `*argc` is decremented. + +No value is returned. Instead, the GoogleTest flag variables are updated. + +The `InitGoogleTest(int* argc, wchar_t** argv)` overload can be used in Windows +programs compiled in `UNICODE` mode. + +The argument-less `InitGoogleTest()` overload can be used on Arduino/embedded +platforms where there is no `argc`/`argv`. + +### AddGlobalTestEnvironment {#AddGlobalTestEnvironment} + +`Environment* ::testing::AddGlobalTestEnvironment(Environment* env)` + +Adds a test environment to the test program. Must be called before +[`RUN_ALL_TESTS()`](#RUN_ALL_TESTS) is called. See +[Global Set-Up and Tear-Down](../advanced.md#global-set-up-and-tear-down) for +more information. + +See also [`Environment`](#Environment). + +### RegisterTest {#RegisterTest} + +```cpp +template +TestInfo* ::testing::RegisterTest(const char* test_suite_name, const char* test_name, + const char* type_param, const char* value_param, + const char* file, int line, Factory factory) +``` + +Dynamically registers a test with the framework. + +The `factory` argument is a factory callable (move-constructible) object or +function pointer that creates a new instance of the `Test` object. It handles +ownership to the caller. The signature of the callable is `Fixture*()`, where +`Fixture` is the test fixture class for the test. All tests registered with the +same `test_suite_name` must return the same fixture type. This is checked at +runtime. + +The framework will infer the fixture class from the factory and will call the +`SetUpTestSuite` and `TearDownTestSuite` methods for it. + +Must be called before [`RUN_ALL_TESTS()`](#RUN_ALL_TESTS) is invoked, otherwise +behavior is undefined. + +See +[Registering tests programmatically](../advanced.md#registering-tests-programmatically) +for more information. + +### RUN_ALL_TESTS {#RUN_ALL_TESTS} + +`int RUN_ALL_TESTS()` + +Use this function in `main()` to run all tests. It returns `0` if all tests are +successful, or `1` otherwise. + +`RUN_ALL_TESTS()` should be invoked after the command line has been parsed by +[`InitGoogleTest()`](#InitGoogleTest). + +This function was formerly a macro; thus, it is in the global namespace and has +an all-caps name. + +### AssertionSuccess {#AssertionSuccess} + +`AssertionResult ::testing::AssertionSuccess()` + +Creates a successful assertion result. See +[`AssertionResult`](#AssertionResult). + +### AssertionFailure {#AssertionFailure} + +`AssertionResult ::testing::AssertionFailure()` + +Creates a failed assertion result. Use the `<<` operator to store a failure +message: + +```cpp +::testing::AssertionFailure() << "My failure message"; +``` + +See [`AssertionResult`](#AssertionResult). + +### StaticAssertTypeEq {#StaticAssertTypeEq} + +`::testing::StaticAssertTypeEq()` + +Compile-time assertion for type equality. Compiles if and only if `T1` and `T2` +are the same type. The value it returns is irrelevant. + +See [Type Assertions](../advanced.md#type-assertions) for more information. + +### PrintToString {#PrintToString} + +`std::string ::testing::PrintToString(x)` + +Prints any value `x` using GoogleTest's value printer. + +See +[Teaching GoogleTest How to Print Your Values](../advanced.md#teaching-googletest-how-to-print-your-values) +for more information. + +### PrintToStringParamName {#PrintToStringParamName} + +`std::string ::testing::PrintToStringParamName(TestParamInfo& info)` + +A built-in parameterized test name generator which returns the result of +[`PrintToString`](#PrintToString) called on `info.param`. Does not work when the +test parameter is a `std::string` or C string. See +[Specifying Names for Value-Parameterized Test Parameters](../advanced.md#specifying-names-for-value-parameterized-test-parameters) +for more information. + +See also [`TestParamInfo`](#TestParamInfo) and +[`INSTANTIATE_TEST_SUITE_P`](#INSTANTIATE_TEST_SUITE_P). diff --git a/ext/googletest/googletest/docs/samples.md b/ext/googletest/docs/samples.md similarity index 97% rename from ext/googletest/googletest/docs/samples.md rename to ext/googletest/docs/samples.md index aaa5883830..2d97ca55b2 100644 --- a/ext/googletest/googletest/docs/samples.md +++ b/ext/googletest/docs/samples.md @@ -1,4 +1,4 @@ -# Googletest Samples {#samples} +# Googletest Samples If you're like us, you'd like to look at [googletest samples.](https://github.com/google/googletest/tree/master/googletest/samples) diff --git a/ext/googletest/googlemock/CMakeLists.txt b/ext/googletest/googlemock/CMakeLists.txt index d32b70b5be..e7df8ec53d 100644 --- a/ext/googletest/googlemock/CMakeLists.txt +++ b/ext/googletest/googlemock/CMakeLists.txt @@ -42,7 +42,7 @@ else() cmake_policy(SET CMP0048 NEW) project(gmock VERSION ${GOOGLETEST_VERSION} LANGUAGES CXX C) endif() -cmake_minimum_required(VERSION 2.6.4) +cmake_minimum_required(VERSION 2.8.12) if (COMMAND set_up_hermetic_build) set_up_hermetic_build() @@ -100,8 +100,10 @@ if (MSVC) else() cxx_library(gmock "${cxx_strict}" src/gmock-all.cc) target_link_libraries(gmock PUBLIC gtest) + set_target_properties(gmock PROPERTIES VERSION ${GOOGLETEST_VERSION}) cxx_library(gmock_main "${cxx_strict}" src/gmock_main.cc) target_link_libraries(gmock_main PUBLIC gmock) + set_target_properties(gmock_main PROPERTIES VERSION ${GOOGLETEST_VERSION}) endif() # If the CMake version supports it, attach header directory information # to the targets for when we are part of a parent build (ie being pulled @@ -136,20 +138,6 @@ if (gmock_build_tests) # 'make test' or ctest. enable_testing() - if (WIN32) - file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/$/RunTest.ps1" - CONTENT -"$project_bin = \"${CMAKE_BINARY_DIR}/bin/$\" -$env:Path = \"$project_bin;$env:Path\" -& $args") - elseif (MINGW OR CYGWIN) - file(GENERATE OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/RunTest.ps1" - CONTENT -"$project_bin = (cygpath --windows ${CMAKE_BINARY_DIR}/bin) -$env:Path = \"$project_bin;$env:Path\" -& $args") - endif() - if (MINGW OR CYGWIN) if (CMAKE_VERSION VERSION_LESS "2.8.12") add_compile_options("-Wa,-mbig-obj") @@ -165,9 +153,6 @@ $env:Path = \"$project_bin;$env:Path\" cxx_test(gmock-cardinalities_test gmock_main) cxx_test(gmock_ex_test gmock_main) cxx_test(gmock-function-mocker_test gmock_main) - cxx_test(gmock-generated-actions_test gmock_main) - cxx_test(gmock-generated-function-mockers_test gmock_main) - cxx_test(gmock-generated-matchers_test gmock_main) cxx_test(gmock-internal-utils_test gmock_main) cxx_test(gmock-matchers_test gmock_main) cxx_test(gmock-more-actions_test gmock_main) diff --git a/ext/googletest/googlemock/CONTRIBUTORS b/ext/googletest/googlemock/CONTRIBUTORS deleted file mode 100644 index 6e9ae362b6..0000000000 --- a/ext/googletest/googlemock/CONTRIBUTORS +++ /dev/null @@ -1,40 +0,0 @@ -# This file contains a list of people who've made non-trivial -# contribution to the Google C++ Mocking Framework project. People -# who commit code to the project are encouraged to add their names -# here. Please keep the list sorted by first names. - -Benoit Sigoure -Bogdan Piloca -Chandler Carruth -Dave MacLachlan -David Anderson -Dean Sturtevant -Gene Volovich -Hal Burch -Jeffrey Yasskin -Jim Keller -Joe Walnes -Jon Wray -Keir Mierle -Keith Ray -Kostya Serebryany -Lev Makhlis -Manuel Klimek -Mario Tanev -Mark Paskin -Markus Heule -Matthew Simmons -Mike Bland -Neal Norwitz -Nermin Ozkiranartli -Owen Carlsen -Paneendra Ba -Paul Menage -Piotr Kaminski -Russ Rufer -Sverre Sundsdal -Takeshi Yoshino -Vadim Berman -Vlad Losev -Wolfgang Klier -Zhanyong Wan diff --git a/ext/googletest/googlemock/LICENSE b/ext/googletest/googlemock/LICENSE deleted file mode 100644 index 1941a11f8c..0000000000 --- a/ext/googletest/googlemock/LICENSE +++ /dev/null @@ -1,28 +0,0 @@ -Copyright 2008, Google Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/ext/googletest/googlemock/README.md b/ext/googletest/googlemock/README.md index 183fdb81d9..ead688325d 100644 --- a/ext/googletest/googlemock/README.md +++ b/ext/googletest/googlemock/README.md @@ -7,38 +7,38 @@ derive better designs of your system and write better tests. It is inspired by: -* [jMock](http://www.jmock.org/), -* [EasyMock](http://www.easymock.org/), and -* [Hamcrest](http://code.google.com/p/hamcrest/), +* [jMock](http://www.jmock.org/) +* [EasyMock](http://www.easymock.org/) +* [Hamcrest](http://code.google.com/p/hamcrest/) -and designed with C++'s specifics in mind. +It is designed with C++'s specifics in mind. gMock: -- provides a declarative syntax for defining mocks, -- can define partial (hybrid) mocks, which are a cross of real and mock - objects, -- handles functions of arbitrary types and overloaded functions, -- comes with a rich set of matchers for validating function arguments, -- uses an intuitive syntax for controlling the behavior of a mock, -- does automatic verification of expectations (no record-and-replay needed), -- allows arbitrary (partial) ordering constraints on function calls to be - expressed, -- lets a user extend it by defining new matchers and actions. -- does not use exceptions, and -- is easy to learn and use. +- Provides a declarative syntax for defining mocks. +- Can define partial (hybrid) mocks, which are a cross of real and mock + objects. +- Handles functions of arbitrary types and overloaded functions. +- Comes with a rich set of matchers for validating function arguments. +- Uses an intuitive syntax for controlling the behavior of a mock. +- Does automatic verification of expectations (no record-and-replay needed). +- Allows arbitrary (partial) ordering constraints on function calls to be + expressed. +- Lets a user extend it by defining new matchers and actions. +- Does not use exceptions. +- Is easy to learn and use. Details and examples can be found here: -* [gMock for Dummies](docs/for_dummies.md) -* [Legacy gMock FAQ](docs/gmock_faq.md) -* [gMock Cookbook](docs/cook_book.md) -* [gMock Cheat Sheet](docs/cheat_sheet.md) +* [gMock for Dummies](https://google.github.io/googletest/gmock_for_dummies.html) +* [Legacy gMock FAQ](https://google.github.io/googletest/gmock_faq.html) +* [gMock Cookbook](https://google.github.io/googletest/gmock_cook_book.html) +* [gMock Cheat Sheet](https://google.github.io/googletest/gmock_cheat_sheet.html) -Please note that code under scripts/generator/ is from the [cppclean -project](http://code.google.com/p/cppclean/) and under the Apache -License, which is different from Google Mock's license. +Please note that code under scripts/generator/ is from the +[cppclean project](http://code.google.com/p/cppclean/) and under the Apache +License, which is different from GoogleMock's license. -Google Mock is a part of -[Google Test C++ testing framework](http://github.com/google/googletest/) and a +GoogleMock is a part of +[GoogleTest C++ testing framework](http://github.com/google/googletest/) and a subject to the same requirements. diff --git a/ext/googletest/googlemock/cmake/gmock.pc.in b/ext/googletest/googlemock/cmake/gmock.pc.in index 08e0454749..23c67b5c88 100644 --- a/ext/googletest/googlemock/cmake/gmock.pc.in +++ b/ext/googletest/googlemock/cmake/gmock.pc.in @@ -1,11 +1,10 @@ -prefix=${pcfiledir}/../.. -libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ -includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ Name: gmock Description: GoogleMock (without main() function) Version: @PROJECT_VERSION@ URL: https://github.com/google/googletest -Requires: gtest +Requires: gtest = @PROJECT_VERSION@ Libs: -L${libdir} -lgmock @CMAKE_THREAD_LIBS_INIT@ -Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ @CMAKE_THREAD_LIBS_INIT@ +Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ diff --git a/ext/googletest/googlemock/cmake/gmock_main.pc.in b/ext/googletest/googlemock/cmake/gmock_main.pc.in index b22fe61482..66ffea7f44 100644 --- a/ext/googletest/googlemock/cmake/gmock_main.pc.in +++ b/ext/googletest/googlemock/cmake/gmock_main.pc.in @@ -1,11 +1,10 @@ -prefix=${pcfiledir}/../.. -libdir=${prefix}/@CMAKE_INSTALL_LIBDIR@ -includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ Name: gmock_main Description: GoogleMock (with main() function) Version: @PROJECT_VERSION@ URL: https://github.com/google/googletest -Requires: gmock +Requires: gmock = @PROJECT_VERSION@ Libs: -L${libdir} -lgmock_main @CMAKE_THREAD_LIBS_INIT@ -Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ @CMAKE_THREAD_LIBS_INIT@ +Cflags: -I${includedir} @GTEST_HAS_PTHREAD_MACRO@ diff --git a/ext/googletest/googlemock/docs/README.md b/ext/googletest/googlemock/docs/README.md new file mode 100644 index 0000000000..1bc57b799c --- /dev/null +++ b/ext/googletest/googlemock/docs/README.md @@ -0,0 +1,4 @@ +# Content Moved + +We are working on updates to the GoogleTest documentation, which has moved to +the top-level [docs](../../docs) directory. diff --git a/ext/googletest/googlemock/docs/cheat_sheet.md b/ext/googletest/googlemock/docs/cheat_sheet.md deleted file mode 100644 index 850963af28..0000000000 --- a/ext/googletest/googlemock/docs/cheat_sheet.md +++ /dev/null @@ -1,781 +0,0 @@ -## gMock Cheat Sheet - - - - - -### Defining a Mock Class - -#### Mocking a Normal Class {#MockClass} - -Given - -```cpp -class Foo { - ... - virtual ~Foo(); - virtual int GetSize() const = 0; - virtual string Describe(const char* name) = 0; - virtual string Describe(int type) = 0; - virtual bool Process(Bar elem, int count) = 0; -}; -``` - -(note that `~Foo()` **must** be virtual) we can define its mock as - -```cpp -#include "gmock/gmock.h" - -class MockFoo : public Foo { - ... - MOCK_METHOD(int, GetSize, (), (const, override)); - MOCK_METHOD(string, Describe, (const char* name), (override)); - MOCK_METHOD(string, Describe, (int type), (override)); - MOCK_METHOD(bool, Process, (Bar elem, int count), (override)); -}; -``` - -To create a "nice" mock, which ignores all uninteresting calls, a "naggy" mock, -which warns on all uninteresting calls, or a "strict" mock, which treats them as -failures: - -```cpp -using ::testing::NiceMock; -using ::testing::NaggyMock; -using ::testing::StrictMock; - -NiceMock nice_foo; // The type is a subclass of MockFoo. -NaggyMock naggy_foo; // The type is a subclass of MockFoo. -StrictMock strict_foo; // The type is a subclass of MockFoo. -``` - -**Note:** A mock object is currently naggy by default. We may make it nice by -default in the future. - -#### Mocking a Class Template {#MockTemplate} - -Class templates can be mocked just like any class. - -To mock - -```cpp -template -class StackInterface { - ... - virtual ~StackInterface(); - virtual int GetSize() const = 0; - virtual void Push(const Elem& x) = 0; -}; -``` - -(note that all member functions that are mocked, including `~StackInterface()` -**must** be virtual). - -```cpp -template -class MockStack : public StackInterface { - ... - MOCK_METHOD(int, GetSize, (), (const, override)); - MOCK_METHOD(void, Push, (const Elem& x), (override)); -}; -``` - -#### Specifying Calling Conventions for Mock Functions - -If your mock function doesn't use the default calling convention, you can -specify it by adding `Calltype(convention)` to `MOCK_METHOD`'s 4th parameter. -For example, - -```cpp - MOCK_METHOD(bool, Foo, (int n), (Calltype(STDMETHODCALLTYPE))); - MOCK_METHOD(int, Bar, (double x, double y), - (const, Calltype(STDMETHODCALLTYPE))); -``` - -where `STDMETHODCALLTYPE` is defined by `` on Windows. - -### Using Mocks in Tests {#UsingMocks} - -The typical work flow is: - -1. Import the gMock names you need to use. All gMock symbols are in the - `testing` namespace unless they are macros or otherwise noted. -2. Create the mock objects. -3. Optionally, set the default actions of the mock objects. -4. Set your expectations on the mock objects (How will they be called? What - will they do?). -5. Exercise code that uses the mock objects; if necessary, check the result - using googletest assertions. -6. When a mock object is destructed, gMock automatically verifies that all - expectations on it have been satisfied. - -Here's an example: - -```cpp -using ::testing::Return; // #1 - -TEST(BarTest, DoesThis) { - MockFoo foo; // #2 - - ON_CALL(foo, GetSize()) // #3 - .WillByDefault(Return(1)); - // ... other default actions ... - - EXPECT_CALL(foo, Describe(5)) // #4 - .Times(3) - .WillRepeatedly(Return("Category 5")); - // ... other expectations ... - - EXPECT_EQ("good", MyProductionFunction(&foo)); // #5 -} // #6 -``` - -### Setting Default Actions {#OnCall} - -gMock has a **built-in default action** for any function that returns `void`, -`bool`, a numeric value, or a pointer. In C++11, it will additionally returns -the default-constructed value, if one exists for the given type. - -To customize the default action for functions with return type *`T`*: - -```cpp -using ::testing::DefaultValue; - -// Sets the default value to be returned. T must be CopyConstructible. -DefaultValue::Set(value); -// Sets a factory. Will be invoked on demand. T must be MoveConstructible. -// T MakeT(); -DefaultValue::SetFactory(&MakeT); -// ... use the mocks ... -// Resets the default value. -DefaultValue::Clear(); -``` - -Example usage: - -```cpp - // Sets the default action for return type std::unique_ptr to - // creating a new Buzz every time. - DefaultValue>::SetFactory( - [] { return MakeUnique(AccessLevel::kInternal); }); - - // When this fires, the default action of MakeBuzz() will run, which - // will return a new Buzz object. - EXPECT_CALL(mock_buzzer_, MakeBuzz("hello")).Times(AnyNumber()); - - auto buzz1 = mock_buzzer_.MakeBuzz("hello"); - auto buzz2 = mock_buzzer_.MakeBuzz("hello"); - EXPECT_NE(nullptr, buzz1); - EXPECT_NE(nullptr, buzz2); - EXPECT_NE(buzz1, buzz2); - - // Resets the default action for return type std::unique_ptr, - // to avoid interfere with other tests. - DefaultValue>::Clear(); -``` - -To customize the default action for a particular method of a specific mock -object, use `ON_CALL()`. `ON_CALL()` has a similar syntax to `EXPECT_CALL()`, -but it is used for setting default behaviors (when you do not require that the -mock method is called). See [here](cook_book.md#UseOnCall) for a more detailed -discussion. - -```cpp -ON_CALL(mock-object, method(matchers)) - .With(multi-argument-matcher) ? - .WillByDefault(action); -``` - -### Setting Expectations {#ExpectCall} - -`EXPECT_CALL()` sets **expectations** on a mock method (How will it be called? -What will it do?): - -```cpp -EXPECT_CALL(mock-object, method (matchers)?) - .With(multi-argument-matcher) ? - .Times(cardinality) ? - .InSequence(sequences) * - .After(expectations) * - .WillOnce(action) * - .WillRepeatedly(action) ? - .RetiresOnSaturation(); ? -``` - -For each item above, `?` means it can be used at most once, while `*` means it -can be used any number of times. - -In order to pass, `EXPECT_CALL` must be used before the calls are actually made. - -The `(matchers)` is a comma-separated list of matchers that correspond to each -of the arguments of `method`, and sets the expectation only for calls of -`method` that matches all of the matchers. - -If `(matchers)` is omitted, the expectation is the same as if the matchers were -set to anything matchers (for example, `(_, _, _, _)` for a four-arg method). - -If `Times()` is omitted, the cardinality is assumed to be: - -* `Times(1)` when there is neither `WillOnce()` nor `WillRepeatedly()`; -* `Times(n)` when there are `n` `WillOnce()`s but no `WillRepeatedly()`, where - `n` >= 1; or -* `Times(AtLeast(n))` when there are `n` `WillOnce()`s and a - `WillRepeatedly()`, where `n` >= 0. - -A method with no `EXPECT_CALL()` is free to be invoked *any number of times*, -and the default action will be taken each time. - -### Matchers {#MatcherList} - - - -A **matcher** matches a *single* argument. You can use it inside `ON_CALL()` or -`EXPECT_CALL()`, or use it to validate a value directly using two macros: - - -| Macro | Description | -| :----------------------------------- | :------------------------------------ | -| `EXPECT_THAT(actual_value, matcher)` | Asserts that `actual_value` matches `matcher`. | -| `ASSERT_THAT(actual_value, matcher)` | The same as `EXPECT_THAT(actual_value, matcher)`, except that it generates a **fatal** failure. | - - -Built-in matchers (where `argument` is the function argument, e.g. -`actual_value` in the example above, or when used in the context of -`EXPECT_CALL(mock_object, method(matchers))`, the arguments of `method`) are -divided into several categories: - -#### Wildcard - -Matcher | Description -:-------------------------- | :----------------------------------------------- -`_` | `argument` can be any value of the correct type. -`A()` or `An()` | `argument` can be any value of type `type`. - -#### Generic Comparison - - -| Matcher | Description | -| :--------------------- | :-------------------------------------------------- | -| `Eq(value)` or `value` | `argument == value` | -| `Ge(value)` | `argument >= value` | -| `Gt(value)` | `argument > value` | -| `Le(value)` | `argument <= value` | -| `Lt(value)` | `argument < value` | -| `Ne(value)` | `argument != value` | -| `IsFalse()` | `argument` evaluates to `false` in a Boolean context. | -| `IsTrue()` | `argument` evaluates to `true` in a Boolean context. | -| `IsNull()` | `argument` is a `NULL` pointer (raw or smart). | -| `NotNull()` | `argument` is a non-null pointer (raw or smart). | -| `Optional(m)` | `argument` is `optional<>` that contains a value matching `m`. | -| `VariantWith(m)` | `argument` is `variant<>` that holds the alternative of type T with a value matching `m`. | -| `Ref(variable)` | `argument` is a reference to `variable`. | -| `TypedEq(value)` | `argument` has type `type` and is equal to `value`. You may need to use this instead of `Eq(value)` when the mock function is overloaded. | - - -Except `Ref()`, these matchers make a *copy* of `value` in case it's modified or -destructed later. If the compiler complains that `value` doesn't have a public -copy constructor, try wrap it in `ByRef()`, e.g. -`Eq(ByRef(non_copyable_value))`. If you do that, make sure `non_copyable_value` -is not changed afterwards, or the meaning of your matcher will be changed. - -#### Floating-Point Matchers {#FpMatchers} - - -| Matcher | Description | -| :------------------------------- | :--------------------------------- | -| `DoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as unequal. | -| `FloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal. | -| `NanSensitiveDoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal. | -| `NanSensitiveFloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal. | - - -The above matchers use ULP-based comparison (the same as used in googletest). -They automatically pick a reasonable error bound based on the absolute value of -the expected value. `DoubleEq()` and `FloatEq()` conform to the IEEE standard, -which requires comparing two NaNs for equality to return false. The -`NanSensitive*` version instead treats two NaNs as equal, which is often what a -user wants. - - -| Matcher | Description | -| :------------------------------------------------ | :----------------------- | -| `DoubleNear(a_double, max_abs_error)` | `argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as unequal. | -| `FloatNear(a_float, max_abs_error)` | `argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as unequal. | -| `NanSensitiveDoubleNear(a_double, max_abs_error)` | `argument` is a `double` value close to `a_double` (absolute error <= `max_abs_error`), treating two NaNs as equal. | -| `NanSensitiveFloatNear(a_float, max_abs_error)` | `argument` is a `float` value close to `a_float` (absolute error <= `max_abs_error`), treating two NaNs as equal. | - - -#### String Matchers - -The `argument` can be either a C string or a C++ string object: - - -| Matcher | Description | -| :---------------------- | :------------------------------------------------- | -| `ContainsRegex(string)` | `argument` matches the given regular expression. | -| `EndsWith(suffix)` | `argument` ends with string `suffix`. | -| `HasSubstr(string)` | `argument` contains `string` as a sub-string. | -| `MatchesRegex(string)` | `argument` matches the given regular expression with the match starting at the first character and ending at the last character. | -| `StartsWith(prefix)` | `argument` starts with string `prefix`. | -| `StrCaseEq(string)` | `argument` is equal to `string`, ignoring case. | -| `StrCaseNe(string)` | `argument` is not equal to `string`, ignoring case. | -| `StrEq(string)` | `argument` is equal to `string`. | -| `StrNe(string)` | `argument` is not equal to `string`. | - - -`ContainsRegex()` and `MatchesRegex()` take ownership of the `RE` object. They -use the regular expression syntax defined -[here](../../googletest/docs/advanced.md#regular-expression-syntax). -`StrCaseEq()`, `StrCaseNe()`, `StrEq()`, and `StrNe()` work for wide strings as -well. - -#### Container Matchers - -Most STL-style containers support `==`, so you can use `Eq(expected_container)` -or simply `expected_container` to match a container exactly. If you want to -write the elements in-line, match them more flexibly, or get more informative -messages, you can use: - - -| Matcher | Description | -| :---------------------------------------- | :------------------------------- | -| `BeginEndDistanceIs(m)` | `argument` is a container whose `begin()` and `end()` iterators are separated by a number of increments matching `m`. E.g. `BeginEndDistanceIs(2)` or `BeginEndDistanceIs(Lt(2))`. For containers that define a `size()` method, `SizeIs(m)` may be more efficient. | -| `ContainerEq(container)` | The same as `Eq(container)` except that the failure message also includes which elements are in one container but not the other. | -| `Contains(e)` | `argument` contains an element that matches `e`, which can be either a value or a matcher. | -| `Each(e)` | `argument` is a container where *every* element matches `e`, which can be either a value or a matcher. | -| `ElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, where the *i*-th element matches `ei`, which can be a value or a matcher. | -| `ElementsAreArray({e0, e1, ..., en})`, `ElementsAreArray(a_container)`, `ElementsAreArray(begin, end)`, `ElementsAreArray(array)`, or `ElementsAreArray(array, count)` | The same as `ElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. | -| `IsEmpty()` | `argument` is an empty container (`container.empty()`). | -| `IsSubsetOf({e0, e1, ..., en})`, `IsSubsetOf(a_container)`, `IsSubsetOf(begin, end)`, `IsSubsetOf(array)`, or `IsSubsetOf(array, count)` | `argument` matches `UnorderedElementsAre(x0, x1, ..., xk)` for some subset `{x0, x1, ..., xk}` of the expected matchers. | -| `IsSupersetOf({e0, e1, ..., en})`, `IsSupersetOf(a_container)`, `IsSupersetOf(begin, end)`, `IsSupersetOf(array)`, or `IsSupersetOf(array, count)` | Some subset of `argument` matches `UnorderedElementsAre(`expected matchers`)`. | -| `Pointwise(m, container)`, `Pointwise(m, {e0, e1, ..., en})` | `argument` contains the same number of elements as in `container`, and for all i, (the i-th element in `argument`, the i-th element in `container`) match `m`, which is a matcher on 2-tuples. E.g. `Pointwise(Le(), upper_bounds)` verifies that each element in `argument` doesn't exceed the corresponding element in `upper_bounds`. See more detail below. | -| `SizeIs(m)` | `argument` is a container whose size matches `m`. E.g. `SizeIs(2)` or `SizeIs(Lt(2))`. | -| `UnorderedElementsAre(e0, e1, ..., en)` | `argument` has `n + 1` elements, and under *some* permutation of the elements, each element matches an `ei` (for a different `i`), which can be a value or a matcher. | -| `UnorderedElementsAreArray({e0, e1, ..., en})`, `UnorderedElementsAreArray(a_container)`, `UnorderedElementsAreArray(begin, end)`, `UnorderedElementsAreArray(array)`, or `UnorderedElementsAreArray(array, count)` | The same as `UnorderedElementsAre()` except that the expected element values/matchers come from an initializer list, STL-style container, iterator range, or C-style array. | -| `UnorderedPointwise(m, container)`, `UnorderedPointwise(m, {e0, e1, ..., en})` | Like `Pointwise(m, container)`, but ignores the order of elements. | -| `WhenSorted(m)` | When `argument` is sorted using the `<` operator, it matches container matcher `m`. E.g. `WhenSorted(ElementsAre(1, 2, 3))` verifies that `argument` contains elements 1, 2, and 3, ignoring order. | -| `WhenSortedBy(comparator, m)` | The same as `WhenSorted(m)`, except that the given comparator instead of `<` is used to sort `argument`. E.g. `WhenSortedBy(std::greater(), ElementsAre(3, 2, 1))`. | - - -**Notes:** - -* These matchers can also match: - 1. a native array passed by reference (e.g. in `Foo(const int (&a)[5])`), - and - 2. an array passed as a pointer and a count (e.g. in `Bar(const T* buffer, - int len)` -- see [Multi-argument Matchers](#MultiArgMatchers)). -* The array being matched may be multi-dimensional (i.e. its elements can be - arrays). -* `m` in `Pointwise(m, ...)` should be a matcher for `::std::tuple` - where `T` and `U` are the element type of the actual container and the - expected container, respectively. For example, to compare two `Foo` - containers where `Foo` doesn't support `operator==`, one might write: - - ```cpp - using ::std::get; - MATCHER(FooEq, "") { - return std::get<0>(arg).Equals(std::get<1>(arg)); - } - ... - EXPECT_THAT(actual_foos, Pointwise(FooEq(), expected_foos)); - ``` - -#### Member Matchers - - -| Matcher | Description | -| :------------------------------ | :----------------------------------------- | -| `Field(&class::field, m)` | `argument.field` (or `argument->field` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. | -| `Key(e)` | `argument.first` matches `e`, which can be either a value or a matcher. E.g. `Contains(Key(Le(5)))` can verify that a `map` contains a key `<= 5`. | -| `Pair(m1, m2)` | `argument` is an `std::pair` whose `first` field matches `m1` and `second` field matches `m2`. | -| `Property(&class::property, m)` | `argument.property()` (or `argument->property()` when `argument` is a plain pointer) matches matcher `m`, where `argument` is an object of type _class_. | - - -#### Matching the Result of a Function, Functor, or Callback - - -| Matcher | Description | -| :--------------- | :------------------------------------------------ | -| `ResultOf(f, m)` | `f(argument)` matches matcher `m`, where `f` is a function or functor. | - - -#### Pointer Matchers - - -| Matcher | Description | -| :------------------------ | :---------------------------------------------- | -| `Pointee(m)` | `argument` (either a smart pointer or a raw pointer) points to a value that matches matcher `m`. | -| `WhenDynamicCastTo(m)` | when `argument` is passed through `dynamic_cast()`, it matches matcher `m`. | - - - - - - -#### Multi-argument Matchers {#MultiArgMatchers} - -Technically, all matchers match a *single* value. A "multi-argument" matcher is -just one that matches a *tuple*. The following matchers can be used to match a -tuple `(x, y)`: - -Matcher | Description -:------ | :---------- -`Eq()` | `x == y` -`Ge()` | `x >= y` -`Gt()` | `x > y` -`Le()` | `x <= y` -`Lt()` | `x < y` -`Ne()` | `x != y` - -You can use the following selectors to pick a subset of the arguments (or -reorder them) to participate in the matching: - - -| Matcher | Description | -| :------------------------- | :---------------------------------------------- | -| `AllArgs(m)` | Equivalent to `m`. Useful as syntactic sugar in `.With(AllArgs(m))`. | -| `Args(m)` | The tuple of the `k` selected (using 0-based indices) arguments matches `m`, e.g. `Args<1, 2>(Eq())`. | - - -#### Composite Matchers - -You can make a matcher from one or more other matchers: - - -| Matcher | Description | -| :------------------------------- | :-------------------------------------- | -| `AllOf(m1, m2, ..., mn)` | `argument` matches all of the matchers `m1` to `mn`. | -| `AllOfArray({m0, m1, ..., mn})`, `AllOfArray(a_container)`, `AllOfArray(begin, end)`, `AllOfArray(array)`, or `AllOfArray(array, count)` | The same as `AllOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. | -| `AnyOf(m1, m2, ..., mn)` | `argument` matches at least one of the matchers `m1` to `mn`. | -| `AnyOfArray({m0, m1, ..., mn})`, `AnyOfArray(a_container)`, `AnyOfArray(begin, end)`, `AnyOfArray(array)`, or `AnyOfArray(array, count)` | The same as `AnyOf()` except that the matchers come from an initializer list, STL-style container, iterator range, or C-style array. | -| `Not(m)` | `argument` doesn't match matcher `m`. | - - - - -#### Adapters for Matchers - - -| Matcher | Description | -| :---------------------- | :------------------------------------ | -| `MatcherCast(m)` | casts matcher `m` to type `Matcher`. | -| `SafeMatcherCast(m)` | [safely casts](cook_book.md#casting-matchers) matcher `m` to type `Matcher`. | -| `Truly(predicate)` | `predicate(argument)` returns something considered by C++ to be true, where `predicate` is a function or functor. | - - -`AddressSatisfies(callback)` and `Truly(callback)` take ownership of `callback`, -which must be a permanent callback. - -#### Using Matchers as Predicates {#MatchersAsPredicatesCheat} - - -| Matcher | Description | -| :---------------------------- | :------------------------------------------ | -| `Matches(m)(value)` | evaluates to `true` if `value` matches `m`. You can use `Matches(m)` alone as a unary functor. | -| `ExplainMatchResult(m, value, result_listener)` | evaluates to `true` if `value` matches `m`, explaining the result to `result_listener`. | -| `Value(value, m)` | evaluates to `true` if `value` matches `m`. | - - -#### Defining Matchers - - -| Matcher | Description | -| :----------------------------------- | :------------------------------------ | -| `MATCHER(IsEven, "") { return (arg % 2) == 0; }` | Defines a matcher `IsEven()` to match an even number. | -| `MATCHER_P(IsDivisibleBy, n, "") { *result_listener << "where the remainder is " << (arg % n); return (arg % n) == 0; }` | Defines a macher `IsDivisibleBy(n)` to match a number divisible by `n`. | -| `MATCHER_P2(IsBetween, a, b, std::string(negation ? "isn't" : "is") + " between " + PrintToString(a) + " and " + PrintToString(b)) { return a <= arg && arg <= b; }` | Defines a matcher `IsBetween(a, b)` to match a value in the range [`a`, `b`]. | - - -**Notes:** - -1. The `MATCHER*` macros cannot be used inside a function or class. -2. The matcher body must be *purely functional* (i.e. it cannot have any side - effect, and the result must not depend on anything other than the value - being matched and the matcher parameters). -3. You can use `PrintToString(x)` to convert a value `x` of any type to a - string. - -### Actions {#ActionList} - -**Actions** specify what a mock function should do when invoked. - -#### Returning a Value - - -| | | -| :-------------------------- | :-------------------------------------------- | -| `Return()` | Return from a `void` mock function. | -| `Return(value)` | Return `value`. If the type of `value` is different to the mock function's return type, `value` is converted to the latter type at the time the expectation is set, not when the action is executed. | -| `ReturnArg()` | Return the `N`-th (0-based) argument. | -| `ReturnNew(a1, ..., ak)` | Return `new T(a1, ..., ak)`; a different object is created each time. | -| `ReturnNull()` | Return a null pointer. | -| `ReturnPointee(ptr)` | Return the value pointed to by `ptr`. | -| `ReturnRef(variable)` | Return a reference to `variable`. | -| `ReturnRefOfCopy(value)` | Return a reference to a copy of `value`; the copy lives as long as the action. | - - -#### Side Effects - - -| | | -| :--------------------------------- | :-------------------------------------- | -| `Assign(&variable, value)` | Assign `value` to variable. | -| `DeleteArg()` | Delete the `N`-th (0-based) argument, which must be a pointer. | -| `SaveArg(pointer)` | Save the `N`-th (0-based) argument to `*pointer`. | -| `SaveArgPointee(pointer)` | Save the value pointed to by the `N`-th (0-based) argument to `*pointer`. | -| `SetArgReferee(value)` | Assign value to the variable referenced by the `N`-th (0-based) argument. | -| `SetArgPointee(value)` | Assign `value` to the variable pointed by the `N`-th (0-based) argument. | -| `SetArgumentPointee(value)` | Same as `SetArgPointee(value)`. Deprecated. Will be removed in v1.7.0. | -| `SetArrayArgument(first, last)` | Copies the elements in source range [`first`, `last`) to the array pointed to by the `N`-th (0-based) argument, which can be either a pointer or an iterator. The action does not take ownership of the elements in the source range. | -| `SetErrnoAndReturn(error, value)` | Set `errno` to `error` and return `value`. | -| `Throw(exception)` | Throws the given exception, which can be any copyable value. Available since v1.1.0. | - - -#### Using a Function, Functor, or Lambda as an Action - -In the following, by "callable" we mean a free function, `std::function`, -functor, or lambda. - - -| | | -| :---------------------------------- | :------------------------------------- | -| `f` | Invoke f with the arguments passed to the mock function, where f is a callable. | -| `Invoke(f)` | Invoke `f` with the arguments passed to the mock function, where `f` can be a global/static function or a functor. | -| `Invoke(object_pointer, &class::method)` | Invoke the method on the object with the arguments passed to the mock function. | -| `InvokeWithoutArgs(f)` | Invoke `f`, which can be a global/static function or a functor. `f` must take no arguments. | -| `InvokeWithoutArgs(object_pointer, &class::method)` | Invoke the method on the object, which takes no arguments. | -| `InvokeArgument(arg1, arg2, ..., argk)` | Invoke the mock function's `N`-th (0-based) argument, which must be a function or a functor, with the `k` arguments. | - - -The return value of the invoked function is used as the return value of the -action. - -When defining a callable to be used with `Invoke*()`, you can declare any unused -parameters as `Unused`: - -```cpp -using ::testing::Invoke; -double Distance(Unused, double x, double y) { return sqrt(x*x + y*y); } -... -EXPECT_CALL(mock, Foo("Hi", _, _)).WillOnce(Invoke(Distance)); -``` - -`Invoke(callback)` and `InvokeWithoutArgs(callback)` take ownership of -`callback`, which must be permanent. The type of `callback` must be a base -callback type instead of a derived one, e.g. - -```cpp - BlockingClosure* done = new BlockingClosure; - ... Invoke(done) ...; // This won't compile! - - Closure* done2 = new BlockingClosure; - ... Invoke(done2) ...; // This works. -``` - -In `InvokeArgument(...)`, if an argument needs to be passed by reference, -wrap it inside `ByRef()`. For example, - -```cpp -using ::testing::ByRef; -using ::testing::InvokeArgument; -... -InvokeArgument<2>(5, string("Hi"), ByRef(foo)) -``` - -calls the mock function's #2 argument, passing to it `5` and `string("Hi")` by -value, and `foo` by reference. - -#### Default Action - - -| Matcher | Description | -| :------------ | :----------------------------------------------------- | -| `DoDefault()` | Do the default action (specified by `ON_CALL()` or the built-in one). | - - -**Note:** due to technical reasons, `DoDefault()` cannot be used inside a -composite action - trying to do so will result in a run-time error. - - - -#### Composite Actions - - -| | | -| :----------------------------- | :------------------------------------------ | -| `DoAll(a1, a2, ..., an)` | Do all actions `a1` to `an` and return the result of `an` in each invocation. The first `n - 1` sub-actions must return void. | -| `IgnoreResult(a)` | Perform action `a` and ignore its result. `a` must not return void. | -| `WithArg(a)` | Pass the `N`-th (0-based) argument of the mock function to action `a` and perform it. | -| `WithArgs(a)` | Pass the selected (0-based) arguments of the mock function to action `a` and perform it. | -| `WithoutArgs(a)` | Perform action `a` without any arguments. | - - -#### Defining Actions - - - - - - - -
`struct SumAction {`
-  `template `
-  `T operator()(T x, Ty) { return x + y; }`
- `};` - 		Defines a generic functor that can be used as an action summing its - arguments.
- - -| | | -| :--------------------------------- | :-------------------------------------- | -| `ACTION(Sum) { return arg0 + arg1; }` | Defines an action `Sum()` to return the sum of the mock function's argument #0 and #1. | -| `ACTION_P(Plus, n) { return arg0 + n; }` | Defines an action `Plus(n)` to return the sum of the mock function's argument #0 and `n`. | -| `ACTION_Pk(Foo, p1, ..., pk) { statements; }` | Defines a parameterized action `Foo(p1, ..., pk)` to execute the given `statements`. | - - -The `ACTION*` macros cannot be used inside a function or class. - -### Cardinalities {#CardinalityList} - -These are used in `Times()` to specify how many times a mock function will be -called: - - -| | | -| :---------------- | :----------------------------------------------------- | -| `AnyNumber()` | The function can be called any number of times. | -| `AtLeast(n)` | The call is expected at least `n` times. | -| `AtMost(n)` | The call is expected at most `n` times. | -| `Between(m, n)` | The call is expected between `m` and `n` (inclusive) times. | -| `Exactly(n) or n` | The call is expected exactly `n` times. In particular, the call should never happen when `n` is 0. | - - -### Expectation Order - -By default, the expectations can be matched in *any* order. If some or all -expectations must be matched in a given order, there are two ways to specify it. -They can be used either independently or together. - -#### The After Clause {#AfterClause} - -```cpp -using ::testing::Expectation; -... -Expectation init_x = EXPECT_CALL(foo, InitX()); -Expectation init_y = EXPECT_CALL(foo, InitY()); -EXPECT_CALL(foo, Bar()) - .After(init_x, init_y); -``` - -says that `Bar()` can be called only after both `InitX()` and `InitY()` have -been called. - -If you don't know how many pre-requisites an expectation has when you write it, -you can use an `ExpectationSet` to collect them: - -```cpp -using ::testing::ExpectationSet; -... -ExpectationSet all_inits; -for (int i = 0; i < element_count; i++) { - all_inits += EXPECT_CALL(foo, InitElement(i)); -} -EXPECT_CALL(foo, Bar()) - .After(all_inits); -``` - -says that `Bar()` can be called only after all elements have been initialized -(but we don't care about which elements get initialized before the others). - -Modifying an `ExpectationSet` after using it in an `.After()` doesn't affect the -meaning of the `.After()`. - -#### Sequences {#UsingSequences} - -When you have a long chain of sequential expectations, it's easier to specify -the order using **sequences**, which don't require you to given each expectation -in the chain a different name. *All expected calls* in the same sequence must -occur in the order they are specified. - -```cpp -using ::testing::Return; -using ::testing::Sequence; -Sequence s1, s2; -... -EXPECT_CALL(foo, Reset()) - .InSequence(s1, s2) - .WillOnce(Return(true)); -EXPECT_CALL(foo, GetSize()) - .InSequence(s1) - .WillOnce(Return(1)); -EXPECT_CALL(foo, Describe(A())) - .InSequence(s2) - .WillOnce(Return("dummy")); -``` - -says that `Reset()` must be called before *both* `GetSize()` *and* `Describe()`, -and the latter two can occur in any order. - -To put many expectations in a sequence conveniently: - -```cpp -using ::testing::InSequence; -{ - InSequence seq; - - EXPECT_CALL(...)...; - EXPECT_CALL(...)...; - ... - EXPECT_CALL(...)...; -} -``` - -says that all expected calls in the scope of `seq` must occur in strict order. -The name `seq` is irrelevant. - -### Verifying and Resetting a Mock - -gMock will verify the expectations on a mock object when it is destructed, or -you can do it earlier: - -```cpp -using ::testing::Mock; -... -// Verifies and removes the expectations on mock_obj; -// returns true if and only if successful. -Mock::VerifyAndClearExpectations(&mock_obj); -... -// Verifies and removes the expectations on mock_obj; -// also removes the default actions set by ON_CALL(); -// returns true if and only if successful. -Mock::VerifyAndClear(&mock_obj); -``` - -You can also tell gMock that a mock object can be leaked and doesn't need to be -verified: - -```cpp -Mock::AllowLeak(&mock_obj); -``` - -### Mock Classes - -gMock defines a convenient mock class template - -```cpp -class MockFunction { - public: - MOCK_METHOD(R, Call, (A1, ..., An)); -}; -``` - -See this [recipe](cook_book.md#using-check-points) for one application of it. - -### Flags - - -| Flag | Description | -| :----------------------------- | :---------------------------------------- | -| `--gmock_catch_leaked_mocks=0` | Don't report leaked mock objects as failures. | -| `--gmock_verbose=LEVEL` | Sets the default verbosity level (`info`, `warning`, or `error`) of Google Mock messages. | - diff --git a/ext/googletest/googlemock/include/gmock/gmock-actions.h b/ext/googletest/googlemock/include/gmock/gmock-actions.h index f12d39be06..f2393bd3af 100644 --- a/ext/googletest/googlemock/include/gmock/gmock-actions.h +++ b/ext/googletest/googlemock/include/gmock/gmock-actions.h @@ -30,12 +30,105 @@ // Google Mock - a framework for writing C++ mock classes. // -// This file implements some commonly used actions. +// The ACTION* family of macros can be used in a namespace scope to +// define custom actions easily. The syntax: +// +// ACTION(name) { statements; } +// +// will define an action with the given name that executes the +// statements. The value returned by the statements will be used as +// the return value of the action. Inside the statements, you can +// refer to the K-th (0-based) argument of the mock function by +// 'argK', and refer to its type by 'argK_type'. For example: +// +// ACTION(IncrementArg1) { +// arg1_type temp = arg1; +// return ++(*temp); +// } +// +// allows you to write +// +// ...WillOnce(IncrementArg1()); +// +// You can also refer to the entire argument tuple and its type by +// 'args' and 'args_type', and refer to the mock function type and its +// return type by 'function_type' and 'return_type'. +// +// Note that you don't need to specify the types of the mock function +// arguments. However rest assured that your code is still type-safe: +// you'll get a compiler error if *arg1 doesn't support the ++ +// operator, or if the type of ++(*arg1) isn't compatible with the +// mock function's return type, for example. +// +// Sometimes you'll want to parameterize the action. For that you can use +// another macro: +// +// ACTION_P(name, param_name) { statements; } +// +// For example: +// +// ACTION_P(Add, n) { return arg0 + n; } +// +// will allow you to write: +// +// ...WillOnce(Add(5)); +// +// Note that you don't need to provide the type of the parameter +// either. If you need to reference the type of a parameter named +// 'foo', you can write 'foo_type'. For example, in the body of +// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type +// of 'n'. +// +// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support +// multi-parameter actions. +// +// For the purpose of typing, you can view +// +// ACTION_Pk(Foo, p1, ..., pk) { ... } +// +// as shorthand for +// +// template +// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } +// +// In particular, you can provide the template type arguments +// explicitly when invoking Foo(), as in Foo(5, false); +// although usually you can rely on the compiler to infer the types +// for you automatically. You can assign the result of expression +// Foo(p1, ..., pk) to a variable of type FooActionPk. This can be useful when composing actions. +// +// You can also overload actions with different numbers of parameters: +// +// ACTION_P(Plus, a) { ... } +// ACTION_P2(Plus, a, b) { ... } +// +// While it's tempting to always use the ACTION* macros when defining +// a new action, you should also consider implementing ActionInterface +// or using MakePolymorphicAction() instead, especially if you need to +// use the action a lot. While these approaches require more work, +// they give you more control on the types of the mock function +// arguments and the action parameters, which in general leads to +// better compiler error messages that pay off in the long run. They +// also allow overloading actions based on parameter types (as opposed +// to just based on the number of parameters). +// +// CAVEAT: +// +// ACTION*() can only be used in a namespace scope as templates cannot be +// declared inside of a local class. +// Users can, however, define any local functors (e.g. a lambda) that +// can be used as actions. +// +// MORE INFORMATION: +// +// To learn more about using these macros, please search for 'ACTION' on +// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md // GOOGLETEST_CM0002 DO NOT DELETE -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ #ifndef _WIN32_WCE # include @@ -45,11 +138,13 @@ #include #include #include +#include #include #include #include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-port.h" +#include "gmock/internal/gmock-pp.h" #ifdef _MSC_VER # pragma warning(push) @@ -162,13 +257,17 @@ GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned int, 0U); GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed int, 0); GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long, 0UL); // NOLINT GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long, 0L); // NOLINT -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(UInt64, 0); -GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(Int64, 0); +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(unsigned long long, 0); // NOLINT +GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(signed long long, 0); // NOLINT GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(float, 0); GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_(double, 0); #undef GMOCK_DEFINE_DEFAULT_ACTION_FOR_RETURN_TYPE_ +// Simple two-arg form of std::disjunction. +template +using disjunction = typename ::std::conditional::type; + } // namespace internal // When an unexpected function call is encountered, Google Mock will @@ -350,6 +449,9 @@ class Action { } }; + template + using IsCompatibleFunctor = std::is_constructible, G>; + public: typedef typename internal::Function::Result Result; typedef typename internal::Function::ArgumentTuple ArgumentTuple; @@ -361,10 +463,14 @@ class Action { // Construct an Action from a specified callable. // This cannot take std::function directly, because then Action would not be // directly constructible from lambda (it would require two conversions). - template , G>::value>::type> - Action(G&& fun) : fun_(::std::forward(fun)) {} // NOLINT + template < + typename G, + typename = typename std::enable_if, std::is_constructible, + G>>::value>::type> + Action(G&& fun) { // NOLINT + Init(::std::forward(fun), IsCompatibleFunctor()); + } // Constructs an Action from its implementation. explicit Action(ActionInterface* impl) @@ -396,6 +502,26 @@ class Action { template friend class Action; + template + void Init(G&& g, ::std::true_type) { + fun_ = ::std::forward(g); + } + + template + void Init(G&& g, ::std::false_type) { + fun_ = IgnoreArgs::type>{::std::forward(g)}; + } + + template + struct IgnoreArgs { + template + Result operator()(const Args&...) const { + return function_impl(); + } + + FunctionImpl function_impl; + }; + // fun_ is an empty function if and only if this is the DoDefault() action. ::std::function fun_; }; @@ -446,13 +572,9 @@ class PolymorphicAction { private: Impl impl_; - - GTEST_DISALLOW_ASSIGN_(MonomorphicImpl); }; Impl impl_; - - GTEST_DISALLOW_ASSIGN_(PolymorphicAction); }; // Creates an Action from its implementation and returns it. The @@ -593,13 +715,9 @@ class ReturnAction { private: bool performed_; const std::shared_ptr wrapper_; - - GTEST_DISALLOW_ASSIGN_(Impl); }; const std::shared_ptr value_; - - GTEST_DISALLOW_ASSIGN_(ReturnAction); }; // Implements the ReturnNull() action. @@ -660,13 +778,9 @@ class ReturnRefAction { private: T& ref_; - - GTEST_DISALLOW_ASSIGN_(Impl); }; T& ref_; - - GTEST_DISALLOW_ASSIGN_(ReturnRefAction); }; // Implements the polymorphic ReturnRefOfCopy(x) action, which can be @@ -707,13 +821,39 @@ class ReturnRefOfCopyAction { private: T value_; - - GTEST_DISALLOW_ASSIGN_(Impl); }; const T value_; +}; - GTEST_DISALLOW_ASSIGN_(ReturnRefOfCopyAction); +// Implements the polymorphic ReturnRoundRobin(v) action, which can be +// used in any function that returns the element_type of v. +template +class ReturnRoundRobinAction { + public: + explicit ReturnRoundRobinAction(std::vector values) { + GTEST_CHECK_(!values.empty()) + << "ReturnRoundRobin requires at least one element."; + state_->values = std::move(values); + } + + template + T operator()(Args&&...) const { + return state_->Next(); + } + + private: + struct State { + T Next() { + T ret_val = values[i++]; + if (i == values.size()) i = 0; + return ret_val; + } + + std::vector values; + size_t i = 0; + }; + std::shared_ptr state_ = std::make_shared(); }; // Implements the polymorphic DoDefault() action. @@ -740,8 +880,6 @@ class AssignAction { private: T1* const ptr_; const T2 value_; - - GTEST_DISALLOW_ASSIGN_(AssignAction); }; #if !GTEST_OS_WINDOWS_MOBILE @@ -763,8 +901,6 @@ class SetErrnoAndReturnAction { private: const int errno_; const T result_; - - GTEST_DISALLOW_ASSIGN_(SetErrnoAndReturnAction); }; #endif // !GTEST_OS_WINDOWS_MOBILE @@ -816,7 +952,8 @@ struct InvokeMethodWithoutArgsAction { Class* const obj_ptr; const MethodPtr method_ptr; - using ReturnType = typename std::result_of::type; + using ReturnType = + decltype((std::declval()->*std::declval())()); template ReturnType operator()(const Args&...) const { @@ -869,13 +1006,9 @@ class IgnoreResultAction { OriginalFunction; const Action action_; - - GTEST_DISALLOW_ASSIGN_(Impl); }; const A action_; - - GTEST_DISALLOW_ASSIGN_(IgnoreResultAction); }; template @@ -886,7 +1019,8 @@ struct WithArgsAction { // We use the conversion operator to detect the signature of the inner Action. template operator Action() const { // NOLINT - Action>::type...)> + using TupleType = std::tuple; + Action::type...)> converted(action); return [converted](Args... args) -> R { @@ -899,9 +1033,13 @@ struct WithArgsAction { template struct DoAllAction { private: - template - std::vector> Convert(IndexSequence) const { - return {std::get(actions)...}; + template + using NonFinalType = + typename std::conditional::value, T, const T&>::type; + + template + std::vector Convert(IndexSequence) const { + return {ActionT(std::get(actions))...}; } public: @@ -910,21 +1048,121 @@ struct DoAllAction { template operator Action() const { // NOLINT struct Op { - std::vector> converted; + std::vector...)>> converted; Action last; R operator()(Args... args) const { auto tuple_args = std::forward_as_tuple(std::forward(args)...); for (auto& a : converted) { a.Perform(tuple_args); } - return last.Perform(tuple_args); + return last.Perform(std::move(tuple_args)); } }; - return Op{Convert(MakeIndexSequence()), + return Op{Convert...)>>( + MakeIndexSequence()), std::get(actions)}; } }; +template +struct ReturnNewAction { + T* operator()() const { + return internal::Apply( + [](const Params&... unpacked_params) { + return new T(unpacked_params...); + }, + params); + } + std::tuple params; +}; + +template +struct ReturnArgAction { + template + auto operator()(const Args&... args) const -> + typename std::tuple_element>::type { + return std::get(std::tie(args...)); + } +}; + +template +struct SaveArgAction { + Ptr pointer; + + template + void operator()(const Args&... args) const { + *pointer = std::get(std::tie(args...)); + } +}; + +template +struct SaveArgPointeeAction { + Ptr pointer; + + template + void operator()(const Args&... args) const { + *pointer = *std::get(std::tie(args...)); + } +}; + +template +struct SetArgRefereeAction { + T value; + + template + void operator()(Args&&... args) const { + using argk_type = + typename ::std::tuple_element>::type; + static_assert(std::is_lvalue_reference::value, + "Argument must be a reference type."); + std::get(std::tie(args...)) = value; + } +}; + +template +struct SetArrayArgumentAction { + I1 first; + I2 last; + + template + void operator()(const Args&... args) const { + auto value = std::get(std::tie(args...)); + for (auto it = first; it != last; ++it, (void)++value) { + *value = *it; + } + } +}; + +template +struct DeleteArgAction { + template + void operator()(const Args&... args) const { + delete std::get(std::tie(args...)); + } +}; + +template +struct ReturnPointeeAction { + Ptr pointer; + template + auto operator()(const Args&...) const -> decltype(*pointer) { + return *pointer; + } +}; + +#if GTEST_HAS_EXCEPTIONS +template +struct ThrowAction { + T exception; + // We use a conversion operator to adapt to any return type. + template + operator Action() const { // NOLINT + T copy = exception; + return [copy](Args...) -> R { throw copy; }; + } +}; +#endif // GTEST_HAS_EXCEPTIONS + } // namespace internal // An Unused object can be implicitly constructed from ANY value. @@ -960,7 +1198,8 @@ struct DoAllAction { typedef internal::IgnoredValue Unused; // Creates an action that does actions a1, a2, ..., sequentially in -// each invocation. +// each invocation. All but the last action will have a readonly view of the +// arguments. template internal::DoAllAction::type...> DoAll( Action&&... action) { @@ -1022,6 +1261,10 @@ inline internal::ReturnRefAction ReturnRef(R& x) { // NOLINT return internal::ReturnRefAction(x); } +// Prevent using ReturnRef on reference to temporary. +template +internal::ReturnRefAction ReturnRef(R&&) = delete; + // Creates an action that returns the reference to a copy of the // argument. The copy is created when the action is constructed and // lives as long as the action. @@ -1039,6 +1282,23 @@ internal::ByMoveWrapper ByMove(R x) { return internal::ByMoveWrapper(std::move(x)); } +// Creates an action that returns an element of `vals`. Calling this action will +// repeatedly return the next value from `vals` until it reaches the end and +// will restart from the beginning. +template +internal::ReturnRoundRobinAction ReturnRoundRobin(std::vector vals) { + return internal::ReturnRoundRobinAction(std::move(vals)); +} + +// Creates an action that returns an element of `vals`. Calling this action will +// repeatedly return the next value from `vals` until it reaches the end and +// will restart from the beginning. +template +internal::ReturnRoundRobinAction ReturnRoundRobin( + std::initializer_list vals) { + return internal::ReturnRoundRobinAction(std::vector(vals)); +} + // Creates an action that does the default action for the give mock function. inline internal::DoDefaultAction DoDefault() { return internal::DoDefaultAction(); @@ -1047,14 +1307,14 @@ inline internal::DoDefaultAction DoDefault() { // Creates an action that sets the variable pointed by the N-th // (0-based) function argument to 'value'. template -internal::SetArgumentPointeeAction SetArgPointee(T x) { - return {std::move(x)}; +internal::SetArgumentPointeeAction SetArgPointee(T value) { + return {std::move(value)}; } // The following version is DEPRECATED. template -internal::SetArgumentPointeeAction SetArgumentPointee(T x) { - return {std::move(x)}; +internal::SetArgumentPointeeAction SetArgumentPointee(T value) { + return {std::move(value)}; } // Creates an action that sets a pointer referent to a given value. @@ -1132,11 +1392,296 @@ inline ::std::reference_wrapper ByRef(T& l_value) { // NOLINT return ::std::reference_wrapper(l_value); } +// The ReturnNew(a1, a2, ..., a_k) action returns a pointer to a new +// instance of type T, constructed on the heap with constructor arguments +// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. +template +internal::ReturnNewAction::type...> ReturnNew( + Params&&... params) { + return {std::forward_as_tuple(std::forward(params)...)}; +} + +// Action ReturnArg() returns the k-th argument of the mock function. +template +internal::ReturnArgAction ReturnArg() { + return {}; +} + +// Action SaveArg(pointer) saves the k-th (0-based) argument of the +// mock function to *pointer. +template +internal::SaveArgAction SaveArg(Ptr pointer) { + return {pointer}; +} + +// Action SaveArgPointee(pointer) saves the value pointed to +// by the k-th (0-based) argument of the mock function to *pointer. +template +internal::SaveArgPointeeAction SaveArgPointee(Ptr pointer) { + return {pointer}; +} + +// Action SetArgReferee(value) assigns 'value' to the variable +// referenced by the k-th (0-based) argument of the mock function. +template +internal::SetArgRefereeAction::type> SetArgReferee( + T&& value) { + return {std::forward(value)}; +} + +// Action SetArrayArgument(first, last) copies the elements in +// source range [first, last) to the array pointed to by the k-th +// (0-based) argument, which can be either a pointer or an +// iterator. The action does not take ownership of the elements in the +// source range. +template +internal::SetArrayArgumentAction SetArrayArgument(I1 first, + I2 last) { + return {first, last}; +} + +// Action DeleteArg() deletes the k-th (0-based) argument of the mock +// function. +template +internal::DeleteArgAction DeleteArg() { + return {}; +} + +// This action returns the value pointed to by 'pointer'. +template +internal::ReturnPointeeAction ReturnPointee(Ptr pointer) { + return {pointer}; +} + +// Action Throw(exception) can be used in a mock function of any type +// to throw the given exception. Any copyable value can be thrown. +#if GTEST_HAS_EXCEPTIONS +template +internal::ThrowAction::type> Throw(T&& exception) { + return {std::forward(exception)}; +} +#endif // GTEST_HAS_EXCEPTIONS + +namespace internal { + +// A macro from the ACTION* family (defined later in gmock-generated-actions.h) +// defines an action that can be used in a mock function. Typically, +// these actions only care about a subset of the arguments of the mock +// function. For example, if such an action only uses the second +// argument, it can be used in any mock function that takes >= 2 +// arguments where the type of the second argument is compatible. +// +// Therefore, the action implementation must be prepared to take more +// arguments than it needs. The ExcessiveArg type is used to +// represent those excessive arguments. In order to keep the compiler +// error messages tractable, we define it in the testing namespace +// instead of testing::internal. However, this is an INTERNAL TYPE +// and subject to change without notice, so a user MUST NOT USE THIS +// TYPE DIRECTLY. +struct ExcessiveArg {}; + +// Builds an implementation of an Action<> for some particular signature, using +// a class defined by an ACTION* macro. +template struct ActionImpl; + +template +struct ImplBase { + struct Holder { + // Allows each copy of the Action<> to get to the Impl. + explicit operator const Impl&() const { return *ptr; } + std::shared_ptr ptr; + }; + using type = typename std::conditional::value, + Impl, Holder>::type; +}; + +template +struct ActionImpl : ImplBase::type { + using Base = typename ImplBase::type; + using function_type = R(Args...); + using args_type = std::tuple; + + ActionImpl() = default; // Only defined if appropriate for Base. + explicit ActionImpl(std::shared_ptr impl) : Base{std::move(impl)} { } + + R operator()(Args&&... arg) const { + static constexpr size_t kMaxArgs = + sizeof...(Args) <= 10 ? sizeof...(Args) : 10; + return Apply(MakeIndexSequence{}, + MakeIndexSequence<10 - kMaxArgs>{}, + args_type{std::forward(arg)...}); + } + + template + R Apply(IndexSequence, IndexSequence, + const args_type& args) const { + // Impl need not be specific to the signature of action being implemented; + // only the implementing function body needs to have all of the specific + // types instantiated. Up to 10 of the args that are provided by the + // args_type get passed, followed by a dummy of unspecified type for the + // remainder up to 10 explicit args. + static constexpr ExcessiveArg kExcessArg{}; + return static_cast(*this).template gmock_PerformImpl< + /*function_type=*/function_type, /*return_type=*/R, + /*args_type=*/args_type, + /*argN_type=*/typename std::tuple_element::type...>( + /*args=*/args, std::get(args)..., + ((void)excess_id, kExcessArg)...); + } +}; + +// Stores a default-constructed Impl as part of the Action<>'s +// std::function<>. The Impl should be trivial to copy. +template +::testing::Action MakeAction() { + return ::testing::Action(ActionImpl()); +} + +// Stores just the one given instance of Impl. +template +::testing::Action MakeAction(std::shared_ptr impl) { + return ::testing::Action(ActionImpl(std::move(impl))); +} + +#define GMOCK_INTERNAL_ARG_UNUSED(i, data, el) \ + , const arg##i##_type& arg##i GTEST_ATTRIBUTE_UNUSED_ +#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_ \ + const args_type& args GTEST_ATTRIBUTE_UNUSED_ GMOCK_PP_REPEAT( \ + GMOCK_INTERNAL_ARG_UNUSED, , 10) + +#define GMOCK_INTERNAL_ARG(i, data, el) , const arg##i##_type& arg##i +#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_ \ + const args_type& args GMOCK_PP_REPEAT(GMOCK_INTERNAL_ARG, , 10) + +#define GMOCK_INTERNAL_TEMPLATE_ARG(i, data, el) , typename arg##i##_type +#define GMOCK_ACTION_TEMPLATE_ARGS_NAMES_ \ + GMOCK_PP_TAIL(GMOCK_PP_REPEAT(GMOCK_INTERNAL_TEMPLATE_ARG, , 10)) + +#define GMOCK_INTERNAL_TYPENAME_PARAM(i, data, param) , typename param##_type +#define GMOCK_ACTION_TYPENAME_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPENAME_PARAM, , params)) + +#define GMOCK_INTERNAL_TYPE_PARAM(i, data, param) , param##_type +#define GMOCK_ACTION_TYPE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_PARAM, , params)) + +#define GMOCK_INTERNAL_TYPE_GVALUE_PARAM(i, data, param) \ + , param##_type gmock_p##i +#define GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_TYPE_GVALUE_PARAM, , params)) + +#define GMOCK_INTERNAL_GVALUE_PARAM(i, data, param) \ + , std::forward(gmock_p##i) +#define GMOCK_ACTION_GVALUE_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GVALUE_PARAM, , params)) + +#define GMOCK_INTERNAL_INIT_PARAM(i, data, param) \ + , param(::std::forward(gmock_p##i)) +#define GMOCK_ACTION_INIT_PARAMS_(params) \ + GMOCK_PP_TAIL(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_INIT_PARAM, , params)) + +#define GMOCK_INTERNAL_FIELD_PARAM(i, data, param) param##_type param; +#define GMOCK_ACTION_FIELD_PARAMS_(params) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_FIELD_PARAM, , params) + +#define GMOCK_INTERNAL_ACTION(name, full_name, params) \ + template \ + class full_name { \ + public: \ + explicit full_name(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ + : impl_(std::make_shared( \ + GMOCK_ACTION_GVALUE_PARAMS_(params))) { } \ + full_name(const full_name&) = default; \ + full_name(full_name&&) noexcept = default; \ + template \ + operator ::testing::Action() const { \ + return ::testing::internal::MakeAction(impl_); \ + } \ + private: \ + class gmock_Impl { \ + public: \ + explicit gmock_Impl(GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) \ + : GMOCK_ACTION_INIT_PARAMS_(params) {} \ + template \ + return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ + GMOCK_ACTION_FIELD_PARAMS_(params) \ + }; \ + std::shared_ptr impl_; \ + }; \ + template \ + inline full_name name( \ + GMOCK_ACTION_TYPE_GVALUE_PARAMS_(params)) { \ + return full_name( \ + GMOCK_ACTION_GVALUE_PARAMS_(params)); \ + } \ + template \ + template \ + return_type full_name::gmock_Impl:: \ + gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const + +} // namespace internal + +// Similar to GMOCK_INTERNAL_ACTION, but no bound parameters are stored. +#define ACTION(name) \ + class name##Action { \ + public: \ + explicit name##Action() noexcept {} \ + name##Action(const name##Action&) noexcept {} \ + template \ + operator ::testing::Action() const { \ + return ::testing::internal::MakeAction(); \ + } \ + private: \ + class gmock_Impl { \ + public: \ + template \ + return_type gmock_PerformImpl(GMOCK_ACTION_ARG_TYPES_AND_NAMES_) const; \ + }; \ + }; \ + inline name##Action name() GTEST_MUST_USE_RESULT_; \ + inline name##Action name() { return name##Action(); } \ + template \ + return_type name##Action::gmock_Impl::gmock_PerformImpl( \ + GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const + +#define ACTION_P(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP, (__VA_ARGS__)) + +#define ACTION_P2(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP2, (__VA_ARGS__)) + +#define ACTION_P3(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP3, (__VA_ARGS__)) + +#define ACTION_P4(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP4, (__VA_ARGS__)) + +#define ACTION_P5(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP5, (__VA_ARGS__)) + +#define ACTION_P6(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP6, (__VA_ARGS__)) + +#define ACTION_P7(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP7, (__VA_ARGS__)) + +#define ACTION_P8(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP8, (__VA_ARGS__)) + +#define ACTION_P9(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP9, (__VA_ARGS__)) + +#define ACTION_P10(name, ...) \ + GMOCK_INTERNAL_ACTION(name, name##ActionP10, (__VA_ARGS__)) + } // namespace testing #ifdef _MSC_VER # pragma warning(pop) #endif - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_ACTIONS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-cardinalities.h b/ext/googletest/googlemock/include/gmock/gmock-cardinalities.h index 46e01e102d..fc7f803a7a 100644 --- a/ext/googletest/googlemock/include/gmock/gmock-cardinalities.h +++ b/ext/googletest/googlemock/include/gmock/gmock-cardinalities.h @@ -36,8 +36,8 @@ // GOOGLETEST_CM0002 DO NOT DELETE -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ #include #include @@ -154,4 +154,4 @@ inline Cardinality MakeCardinality(const CardinalityInterface* c) { GTEST_DISABLE_MSC_WARNINGS_POP_() // 4251 -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ +#endif // GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_CARDINALITIES_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-function-mocker.h b/ext/googletest/googlemock/include/gmock/gmock-function-mocker.h index cc1535c806..0fc6f6f3f1 100644 --- a/ext/googletest/googlemock/include/gmock/gmock-function-mocker.h +++ b/ext/googletest/googlemock/include/gmock/gmock-function-mocker.h @@ -33,12 +33,47 @@ // GOOGLETEST_CM0002 DO NOT DELETE -#ifndef THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT -#define THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT +#define GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ // NOLINT -#include "gmock/gmock-generated-function-mockers.h" // NOLINT +#include // IWYU pragma: keep +#include // IWYU pragma: keep + +#include "gmock/gmock-spec-builders.h" +#include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-pp.h" +namespace testing { +namespace internal { +template +using identity_t = T; + +template +struct ThisRefAdjuster { + template + using AdjustT = typename std::conditional< + std::is_const::type>::value, + typename std::conditional::value, + const T&, const T&&>::type, + typename std::conditional::value, T&, + T&&>::type>::type; + + template + static AdjustT Adjust(const MockType& mock) { + return static_cast>(const_cast(mock)); + } +}; + +} // namespace internal + +// The style guide prohibits "using" statements in a namespace scope +// inside a header file. However, the FunctionMocker class template +// is meant to be defined in the ::testing namespace. The following +// line is just a trick for working around a bug in MSVC 8.0, which +// cannot handle it if we define FunctionMocker in ::testing. +using internal::FunctionMocker; +} // namespace testing + #define MOCK_METHOD(...) \ GMOCK_PP_VARIADIC_CALL(GMOCK_INTERNAL_MOCK_METHOD_ARG_, __VA_ARGS__) @@ -60,7 +95,8 @@ GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ GMOCK_PP_NARG0 _Args, _MethodName, GMOCK_INTERNAL_HAS_CONST(_Spec), \ GMOCK_INTERNAL_HAS_OVERRIDE(_Spec), GMOCK_INTERNAL_HAS_FINAL(_Spec), \ - GMOCK_INTERNAL_HAS_NOEXCEPT(_Spec), GMOCK_INTERNAL_GET_CALLTYPE(_Spec), \ + GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Spec), \ + GMOCK_INTERNAL_GET_CALLTYPE(_Spec), GMOCK_INTERNAL_GET_REF_SPEC(_Spec), \ (GMOCK_INTERNAL_SIGNATURE(_Ret, _Args))) #define GMOCK_INTERNAL_MOCK_METHOD_ARG_5(...) \ @@ -94,21 +130,20 @@ ::testing::tuple_size::ArgumentTuple>::value == _N, \ "This method does not take " GMOCK_PP_STRINGIZE( \ - _N) " arguments. Parenthesize all types with unproctected commas.") + _N) " arguments. Parenthesize all types with unprotected commas.") #define GMOCK_INTERNAL_ASSERT_VALID_SPEC(_Spec) \ GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_ASSERT_VALID_SPEC_ELEMENT, ~, _Spec) #define GMOCK_INTERNAL_MOCK_METHOD_IMPL(_N, _MethodName, _Constness, \ - _Override, _Final, _Noexcept, \ - _CallType, _Signature) \ + _Override, _Final, _NoexceptSpec, \ + _CallType, _RefSpec, _Signature) \ typename ::testing::internal::Function::Result \ GMOCK_INTERNAL_EXPAND(_CallType) \ _MethodName(GMOCK_PP_REPEAT(GMOCK_INTERNAL_PARAMETER, _Signature, _N)) \ - GMOCK_PP_IF(_Constness, const, ) GMOCK_PP_IF(_Noexcept, noexcept, ) \ - GMOCK_PP_IF(_Override, override, ) \ - GMOCK_PP_IF(_Final, final, ) { \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec _NoexceptSpec \ + GMOCK_PP_IF(_Override, override, ) GMOCK_PP_IF(_Final, final, ) { \ GMOCK_MOCKER_(_N, _Constness, _MethodName) \ .SetOwnerAndName(this, #_MethodName); \ return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ @@ -116,7 +151,7 @@ } \ ::testing::MockSpec gmock_##_MethodName( \ GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_PARAMETER, _Signature, _N)) \ - GMOCK_PP_IF(_Constness, const, ) { \ + GMOCK_PP_IF(_Constness, const, ) _RefSpec { \ GMOCK_MOCKER_(_N, _Constness, _MethodName).RegisterOwner(this); \ return GMOCK_MOCKER_(_N, _Constness, _MethodName) \ .With(GMOCK_PP_REPEAT(GMOCK_INTERNAL_MATCHER_ARGUMENT, , _N)); \ @@ -124,11 +159,10 @@ ::testing::MockSpec gmock_##_MethodName( \ const ::testing::internal::WithoutMatchers&, \ GMOCK_PP_IF(_Constness, const, )::testing::internal::Function< \ - GMOCK_PP_REMOVE_PARENS(_Signature)>*) \ - const GMOCK_PP_IF(_Noexcept, noexcept, ) { \ - return GMOCK_PP_CAT(::testing::internal::AdjustConstness_, \ - GMOCK_PP_IF(_Constness, const, ))(this) \ - ->gmock_##_MethodName(GMOCK_PP_REPEAT( \ + GMOCK_PP_REMOVE_PARENS(_Signature)>*) const _RefSpec _NoexceptSpec { \ + return ::testing::internal::ThisRefAdjuster::Adjust(*this) \ + .gmock_##_MethodName(GMOCK_PP_REPEAT( \ GMOCK_INTERNAL_A_MATCHER_ARGUMENT, _Signature, _N)); \ } \ mutable ::testing::FunctionMocker \ @@ -147,9 +181,20 @@ #define GMOCK_INTERNAL_HAS_FINAL(_Tuple) \ GMOCK_PP_HAS_COMMA(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_FINAL, ~, _Tuple)) -#define GMOCK_INTERNAL_HAS_NOEXCEPT(_Tuple) \ - GMOCK_PP_HAS_COMMA( \ - GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_DETECT_NOEXCEPT, ~, _Tuple)) +#define GMOCK_INTERNAL_GET_NOEXCEPT_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT, ~, _Tuple) + +#define GMOCK_INTERNAL_NOEXCEPT_SPEC_IF_NOEXCEPT(_i, _, _elem) \ + GMOCK_PP_IF( \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)), \ + _elem, ) + +#define GMOCK_INTERNAL_GET_REF_SPEC(_Tuple) \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_REF_SPEC_IF_REF, ~, _Tuple) + +#define GMOCK_INTERNAL_REF_SPEC_IF_REF(_i, _, _elem) \ + GMOCK_PP_IF(GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)), \ + GMOCK_PP_CAT(GMOCK_INTERNAL_UNPACK_, _elem), ) #define GMOCK_INTERNAL_GET_CALLTYPE(_Tuple) \ GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_CALLTYPE_IMPL, ~, _Tuple) @@ -160,6 +205,7 @@ GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_OVERRIDE(_i, _, _elem)) + \ GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_FINAL(_i, _, _elem)) + \ GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem)) + \ + GMOCK_PP_HAS_COMMA(GMOCK_INTERNAL_DETECT_REF(_i, _, _elem)) + \ GMOCK_INTERNAL_IS_CALLTYPE(_elem)) == 1, \ GMOCK_PP_STRINGIZE( \ _elem) " cannot be recognized as a valid specification modifier."); @@ -180,12 +226,18 @@ #define GMOCK_INTERNAL_DETECT_FINAL_I_final , -// TODO(iserna): Maybe noexcept should accept an argument here as well. #define GMOCK_INTERNAL_DETECT_NOEXCEPT(_i, _, _elem) \ GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_NOEXCEPT_I_, _elem) #define GMOCK_INTERNAL_DETECT_NOEXCEPT_I_noexcept , +#define GMOCK_INTERNAL_DETECT_REF(_i, _, _elem) \ + GMOCK_PP_CAT(GMOCK_INTERNAL_DETECT_REF_I_, _elem) + +#define GMOCK_INTERNAL_DETECT_REF_I_ref , + +#define GMOCK_INTERNAL_UNPACK_ref(x) x + #define GMOCK_INTERNAL_GET_CALLTYPE_IMPL(_i, _, _elem) \ GMOCK_PP_IF(GMOCK_INTERNAL_IS_CALLTYPE(_elem), \ GMOCK_INTERNAL_GET_VALUE_CALLTYPE, GMOCK_PP_EMPTY) \ @@ -203,14 +255,28 @@ GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I( \ GMOCK_PP_CAT(GMOCK_INTERNAL_IS_CALLTYPE_HELPER_, _arg)) #define GMOCK_INTERNAL_GET_VALUE_CALLTYPE_I(_arg) \ - GMOCK_PP_CAT(GMOCK_PP_IDENTITY, _arg) + GMOCK_PP_IDENTITY _arg #define GMOCK_INTERNAL_IS_CALLTYPE_HELPER_Calltype -#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ - GMOCK_PP_IF(GMOCK_PP_IS_BEGIN_PARENS(_Ret), GMOCK_PP_REMOVE_PARENS, \ - GMOCK_PP_IDENTITY) \ - (_Ret)(GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) +// Note: The use of `identity_t` here allows _Ret to represent return types that +// would normally need to be specified in a different way. For example, a method +// returning a function pointer must be written as +// +// fn_ptr_return_t (*method(method_args_t...))(fn_ptr_args_t...) +// +// But we only support placing the return type at the beginning. To handle this, +// we wrap all calls in identity_t, so that a declaration will be expanded to +// +// identity_t method(method_args_t...) +// +// This allows us to work around the syntactic oddities of function/method +// types. +#define GMOCK_INTERNAL_SIGNATURE(_Ret, _Args) \ + ::testing::internal::identity_t( \ + GMOCK_PP_FOR_EACH(GMOCK_INTERNAL_GET_TYPE, _, _Args)) #define GMOCK_INTERNAL_GET_TYPE(_i, _, _elem) \ GMOCK_PP_COMMA_IF(_i) \ @@ -218,36 +284,196 @@ GMOCK_PP_IDENTITY) \ (_elem) -#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_INTERNAL_ARG_O(typename, GMOCK_PP_INC(_i), \ - GMOCK_PP_REMOVE_PARENS(_Signature)) \ +#define GMOCK_INTERNAL_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_ARG_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ gmock_a##_i -#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - ::std::forward( \ - gmock_a##_i) +#define GMOCK_INTERNAL_FORWARD_ARG(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::std::forward(gmock_a##_i) -#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - GMOCK_INTERNAL_MATCHER_O(typename, GMOCK_PP_INC(_i), \ - GMOCK_PP_REMOVE_PARENS(_Signature)) \ +#define GMOCK_INTERNAL_MATCHER_PARAMETER(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + GMOCK_INTERNAL_MATCHER_O(_i, GMOCK_PP_REMOVE_PARENS(_Signature)) \ gmock_a##_i #define GMOCK_INTERNAL_MATCHER_ARGUMENT(_i, _1, _2) \ GMOCK_PP_COMMA_IF(_i) \ gmock_a##_i -#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ - GMOCK_PP_COMMA_IF(_i) \ - ::testing::A() +#define GMOCK_INTERNAL_A_MATCHER_ARGUMENT(_i, _Signature, _) \ + GMOCK_PP_COMMA_IF(_i) \ + ::testing::A() -#define GMOCK_INTERNAL_ARG_O(_tn, _i, ...) GMOCK_ARG_(_tn, _i, __VA_ARGS__) +#define GMOCK_INTERNAL_ARG_O(_i, ...) \ + typename ::testing::internal::Function<__VA_ARGS__>::template Arg<_i>::type -#define GMOCK_INTERNAL_MATCHER_O(_tn, _i, ...) \ - GMOCK_MATCHER_(_tn, _i, __VA_ARGS__) +#define GMOCK_INTERNAL_MATCHER_O(_i, ...) \ + const ::testing::Matcher::template Arg<_i>::type>& -#endif // THIRD_PARTY_GOOGLETEST_GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ +#define MOCK_METHOD0(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 0, __VA_ARGS__) +#define MOCK_METHOD1(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 1, __VA_ARGS__) +#define MOCK_METHOD2(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 2, __VA_ARGS__) +#define MOCK_METHOD3(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 3, __VA_ARGS__) +#define MOCK_METHOD4(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 4, __VA_ARGS__) +#define MOCK_METHOD5(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 5, __VA_ARGS__) +#define MOCK_METHOD6(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 6, __VA_ARGS__) +#define MOCK_METHOD7(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 7, __VA_ARGS__) +#define MOCK_METHOD8(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 8, __VA_ARGS__) +#define MOCK_METHOD9(m, ...) GMOCK_INTERNAL_MOCK_METHODN(, , m, 9, __VA_ARGS__) +#define MOCK_METHOD10(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, , m, 10, __VA_ARGS__) + +#define MOCK_CONST_METHOD0(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 0, __VA_ARGS__) +#define MOCK_CONST_METHOD1(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 1, __VA_ARGS__) +#define MOCK_CONST_METHOD2(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 2, __VA_ARGS__) +#define MOCK_CONST_METHOD3(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 3, __VA_ARGS__) +#define MOCK_CONST_METHOD4(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 4, __VA_ARGS__) +#define MOCK_CONST_METHOD5(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 5, __VA_ARGS__) +#define MOCK_CONST_METHOD6(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 6, __VA_ARGS__) +#define MOCK_CONST_METHOD7(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 7, __VA_ARGS__) +#define MOCK_CONST_METHOD8(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 8, __VA_ARGS__) +#define MOCK_CONST_METHOD9(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 9, __VA_ARGS__) +#define MOCK_CONST_METHOD10(m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, , m, 10, __VA_ARGS__) + +#define MOCK_METHOD0_T(m, ...) MOCK_METHOD0(m, __VA_ARGS__) +#define MOCK_METHOD1_T(m, ...) MOCK_METHOD1(m, __VA_ARGS__) +#define MOCK_METHOD2_T(m, ...) MOCK_METHOD2(m, __VA_ARGS__) +#define MOCK_METHOD3_T(m, ...) MOCK_METHOD3(m, __VA_ARGS__) +#define MOCK_METHOD4_T(m, ...) MOCK_METHOD4(m, __VA_ARGS__) +#define MOCK_METHOD5_T(m, ...) MOCK_METHOD5(m, __VA_ARGS__) +#define MOCK_METHOD6_T(m, ...) MOCK_METHOD6(m, __VA_ARGS__) +#define MOCK_METHOD7_T(m, ...) MOCK_METHOD7(m, __VA_ARGS__) +#define MOCK_METHOD8_T(m, ...) MOCK_METHOD8(m, __VA_ARGS__) +#define MOCK_METHOD9_T(m, ...) MOCK_METHOD9(m, __VA_ARGS__) +#define MOCK_METHOD10_T(m, ...) MOCK_METHOD10(m, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_T(m, ...) MOCK_CONST_METHOD0(m, __VA_ARGS__) +#define MOCK_CONST_METHOD1_T(m, ...) MOCK_CONST_METHOD1(m, __VA_ARGS__) +#define MOCK_CONST_METHOD2_T(m, ...) MOCK_CONST_METHOD2(m, __VA_ARGS__) +#define MOCK_CONST_METHOD3_T(m, ...) MOCK_CONST_METHOD3(m, __VA_ARGS__) +#define MOCK_CONST_METHOD4_T(m, ...) MOCK_CONST_METHOD4(m, __VA_ARGS__) +#define MOCK_CONST_METHOD5_T(m, ...) MOCK_CONST_METHOD5(m, __VA_ARGS__) +#define MOCK_CONST_METHOD6_T(m, ...) MOCK_CONST_METHOD6(m, __VA_ARGS__) +#define MOCK_CONST_METHOD7_T(m, ...) MOCK_CONST_METHOD7(m, __VA_ARGS__) +#define MOCK_CONST_METHOD8_T(m, ...) MOCK_CONST_METHOD8(m, __VA_ARGS__) +#define MOCK_CONST_METHOD9_T(m, ...) MOCK_CONST_METHOD9(m, __VA_ARGS__) +#define MOCK_CONST_METHOD10_T(m, ...) MOCK_CONST_METHOD10(m, __VA_ARGS__) + +#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 0, __VA_ARGS__) +#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 1, __VA_ARGS__) +#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 2, __VA_ARGS__) +#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 3, __VA_ARGS__) +#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 4, __VA_ARGS__) +#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 5, __VA_ARGS__) +#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 6, __VA_ARGS__) +#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 7, __VA_ARGS__) +#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 8, __VA_ARGS__) +#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 9, __VA_ARGS__) +#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(, ct, m, 10, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 0, __VA_ARGS__) +#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 1, __VA_ARGS__) +#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 2, __VA_ARGS__) +#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 3, __VA_ARGS__) +#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 4, __VA_ARGS__) +#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 5, __VA_ARGS__) +#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 6, __VA_ARGS__) +#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 7, __VA_ARGS__) +#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 8, __VA_ARGS__) +#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 9, __VA_ARGS__) +#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ + GMOCK_INTERNAL_MOCK_METHODN(const, ct, m, 10, __VA_ARGS__) + +#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, __VA_ARGS__) +#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ + MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, __VA_ARGS__) + +#define GMOCK_INTERNAL_MOCK_METHODN(constness, ct, Method, args_num, ...) \ + GMOCK_INTERNAL_ASSERT_VALID_SIGNATURE( \ + args_num, ::testing::internal::identity_t<__VA_ARGS__>); \ + GMOCK_INTERNAL_MOCK_METHOD_IMPL( \ + args_num, Method, GMOCK_PP_NARG0(constness), 0, 0, , ct, , \ + (::testing::internal::identity_t<__VA_ARGS__>)) + +#define GMOCK_MOCKER_(arity, constness, Method) \ + GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) + +#endif // GOOGLEMOCK_INCLUDE_GMOCK_INTERNAL_GMOCK_FUNCTION_MOCKER_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-generated-actions.h b/ext/googletest/googlemock/include/gmock/gmock-generated-actions.h deleted file mode 100644 index 981af78ff9..0000000000 --- a/ext/googletest/googlemock/include/gmock/gmock-generated-actions.h +++ /dev/null @@ -1,1884 +0,0 @@ -// This file was GENERATED by command: -// pump.py gmock-generated-actions.h.pump -// DO NOT EDIT BY HAND!!! - -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used variadic actions. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ - -#include -#include - -#include "gmock/gmock-actions.h" -#include "gmock/internal/gmock-port.h" - -namespace testing { -namespace internal { - -// A macro from the ACTION* family (defined later in this file) -// defines an action that can be used in a mock function. Typically, -// these actions only care about a subset of the arguments of the mock -// function. For example, if such an action only uses the second -// argument, it can be used in any mock function that takes >= 2 -// arguments where the type of the second argument is compatible. -// -// Therefore, the action implementation must be prepared to take more -// arguments than it needs. The ExcessiveArg type is used to -// represent those excessive arguments. In order to keep the compiler -// error messages tractable, we define it in the testing namespace -// instead of testing::internal. However, this is an INTERNAL TYPE -// and subject to change without notice, so a user MUST NOT USE THIS -// TYPE DIRECTLY. -struct ExcessiveArg {}; - -// A helper class needed for implementing the ACTION* macros. -template -class ActionHelper { - public: - static Result Perform(Impl* impl, const ::std::tuple<>& args) { - return impl->template gmock_PerformImpl<>(args, ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, std::get<0>(args), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, std::get<0>(args), - std::get<1>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, - std::get<0>(args), std::get<1>(args), std::get<2>(args), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, - std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, - std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), std::get<4>(args), ExcessiveArg(), ExcessiveArg(), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, - std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), std::get<4>(args), std::get<5>(args), - ExcessiveArg(), ExcessiveArg(), ExcessiveArg(), ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, - std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), std::get<4>(args), std::get<5>(args), - std::get<6>(args), ExcessiveArg(), ExcessiveArg(), ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), std::get<4>(args), std::get<5>(args), - std::get<6>(args), std::get<7>(args), ExcessiveArg(), ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), std::get<4>(args), std::get<5>(args), - std::get<6>(args), std::get<7>(args), std::get<8>(args), - ExcessiveArg()); - } - - template - static Result Perform(Impl* impl, const ::std::tuple& args) { - return impl->template gmock_PerformImpl(args, std::get<0>(args), std::get<1>(args), std::get<2>(args), - std::get<3>(args), std::get<4>(args), std::get<5>(args), - std::get<6>(args), std::get<7>(args), std::get<8>(args), - std::get<9>(args)); - } -}; - -} // namespace internal -} // namespace testing - -// The ACTION* family of macros can be used in a namespace scope to -// define custom actions easily. The syntax: -// -// ACTION(name) { statements; } -// -// will define an action with the given name that executes the -// statements. The value returned by the statements will be used as -// the return value of the action. Inside the statements, you can -// refer to the K-th (0-based) argument of the mock function by -// 'argK', and refer to its type by 'argK_type'. For example: -// -// ACTION(IncrementArg1) { -// arg1_type temp = arg1; -// return ++(*temp); -// } -// -// allows you to write -// -// ...WillOnce(IncrementArg1()); -// -// You can also refer to the entire argument tuple and its type by -// 'args' and 'args_type', and refer to the mock function type and its -// return type by 'function_type' and 'return_type'. -// -// Note that you don't need to specify the types of the mock function -// arguments. However rest assured that your code is still type-safe: -// you'll get a compiler error if *arg1 doesn't support the ++ -// operator, or if the type of ++(*arg1) isn't compatible with the -// mock function's return type, for example. -// -// Sometimes you'll want to parameterize the action. For that you can use -// another macro: -// -// ACTION_P(name, param_name) { statements; } -// -// For example: -// -// ACTION_P(Add, n) { return arg0 + n; } -// -// will allow you to write: -// -// ...WillOnce(Add(5)); -// -// Note that you don't need to provide the type of the parameter -// either. If you need to reference the type of a parameter named -// 'foo', you can write 'foo_type'. For example, in the body of -// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type -// of 'n'. -// -// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P10 to support -// multi-parameter actions. -// -// For the purpose of typing, you can view -// -// ACTION_Pk(Foo, p1, ..., pk) { ... } -// -// as shorthand for -// -// template -// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } -// -// In particular, you can provide the template type arguments -// explicitly when invoking Foo(), as in Foo(5, false); -// although usually you can rely on the compiler to infer the types -// for you automatically. You can assign the result of expression -// Foo(p1, ..., pk) to a variable of type FooActionPk. This can be useful when composing actions. -// -// You can also overload actions with different numbers of parameters: -// -// ACTION_P(Plus, a) { ... } -// ACTION_P2(Plus, a, b) { ... } -// -// While it's tempting to always use the ACTION* macros when defining -// a new action, you should also consider implementing ActionInterface -// or using MakePolymorphicAction() instead, especially if you need to -// use the action a lot. While these approaches require more work, -// they give you more control on the types of the mock function -// arguments and the action parameters, which in general leads to -// better compiler error messages that pay off in the long run. They -// also allow overloading actions based on parameter types (as opposed -// to just based on the number of parameters). -// -// CAVEAT: -// -// ACTION*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// Users can, however, define any local functors (e.g. a lambda) that -// can be used as actions. -// -// MORE INFORMATION: -// -// To learn more about using these macros, please search for 'ACTION' on -// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md - -// An internal macro needed for implementing ACTION*(). -#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ - const args_type& args GTEST_ATTRIBUTE_UNUSED_, \ - const arg0_type& arg0 GTEST_ATTRIBUTE_UNUSED_, \ - const arg1_type& arg1 GTEST_ATTRIBUTE_UNUSED_, \ - const arg2_type& arg2 GTEST_ATTRIBUTE_UNUSED_, \ - const arg3_type& arg3 GTEST_ATTRIBUTE_UNUSED_, \ - const arg4_type& arg4 GTEST_ATTRIBUTE_UNUSED_, \ - const arg5_type& arg5 GTEST_ATTRIBUTE_UNUSED_, \ - const arg6_type& arg6 GTEST_ATTRIBUTE_UNUSED_, \ - const arg7_type& arg7 GTEST_ATTRIBUTE_UNUSED_, \ - const arg8_type& arg8 GTEST_ATTRIBUTE_UNUSED_, \ - const arg9_type& arg9 GTEST_ATTRIBUTE_UNUSED_ - -// Sometimes you want to give an action explicit template parameters -// that cannot be inferred from its value parameters. ACTION() and -// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that -// and can be viewed as an extension to ACTION() and ACTION_P*(). -// -// The syntax: -// -// ACTION_TEMPLATE(ActionName, -// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), -// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } -// -// defines an action template that takes m explicit template -// parameters and n value parameters. name_i is the name of the i-th -// template parameter, and kind_i specifies whether it's a typename, -// an integral constant, or a template. p_i is the name of the i-th -// value parameter. -// -// Example: -// -// // DuplicateArg(output) converts the k-th argument of the mock -// // function to type T and copies it to *output. -// ACTION_TEMPLATE(DuplicateArg, -// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), -// AND_1_VALUE_PARAMS(output)) { -// *output = T(::std::get(args)); -// } -// ... -// int n; -// EXPECT_CALL(mock, Foo(_, _)) -// .WillOnce(DuplicateArg<1, unsigned char>(&n)); -// -// To create an instance of an action template, write: -// -// ActionName(v1, ..., v_n) -// -// where the ts are the template arguments and the vs are the value -// arguments. The value argument types are inferred by the compiler. -// If you want to explicitly specify the value argument types, you can -// provide additional template arguments: -// -// ActionName(v1, ..., v_n) -// -// where u_i is the desired type of v_i. -// -// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the -// number of value parameters, but not on the number of template -// parameters. Without the restriction, the meaning of the following -// is unclear: -// -// OverloadedAction(x); -// -// Are we using a single-template-parameter action where 'bool' refers -// to the type of x, or are we using a two-template-parameter action -// where the compiler is asked to infer the type of x? -// -// Implementation notes: -// -// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and -// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for -// implementing ACTION_TEMPLATE. The main trick we use is to create -// new macro invocations when expanding a macro. For example, we have -// -// #define ACTION_TEMPLATE(name, template_params, value_params) -// ... GMOCK_INTERNAL_DECL_##template_params ... -// -// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) -// to expand to -// -// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... -// -// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the -// preprocessor will continue to expand it to -// -// ... typename T ... -// -// This technique conforms to the C++ standard and is portable. It -// allows us to implement action templates using O(N) code, where N is -// the maximum number of template/value parameters supported. Without -// using it, we'd have to devote O(N^2) amount of code to implement all -// combinations of m and n. - -// Declares the template parameters. -#define GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(kind0, name0) kind0 name0 -#define GMOCK_INTERNAL_DECL_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1) kind0 name0, kind1 name1 -#define GMOCK_INTERNAL_DECL_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2) kind0 name0, kind1 name1, kind2 name2 -#define GMOCK_INTERNAL_DECL_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3) kind0 name0, kind1 name1, kind2 name2, \ - kind3 name3 -#define GMOCK_INTERNAL_DECL_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4) kind0 name0, kind1 name1, \ - kind2 name2, kind3 name3, kind4 name4 -#define GMOCK_INTERNAL_DECL_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5) kind0 name0, \ - kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5 -#define GMOCK_INTERNAL_DECL_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6) kind0 name0, kind1 name1, kind2 name2, kind3 name3, kind4 name4, \ - kind5 name5, kind6 name6 -#define GMOCK_INTERNAL_DECL_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7) kind0 name0, kind1 name1, kind2 name2, kind3 name3, \ - kind4 name4, kind5 name5, kind6 name6, kind7 name7 -#define GMOCK_INTERNAL_DECL_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7, kind8, name8) kind0 name0, kind1 name1, kind2 name2, \ - kind3 name3, kind4 name4, kind5 name5, kind6 name6, kind7 name7, \ - kind8 name8 -#define GMOCK_INTERNAL_DECL_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6, kind7, name7, kind8, name8, kind9, name9) kind0 name0, \ - kind1 name1, kind2 name2, kind3 name3, kind4 name4, kind5 name5, \ - kind6 name6, kind7 name7, kind8 name8, kind9 name9 - -// Lists the template parameters. -#define GMOCK_INTERNAL_LIST_HAS_1_TEMPLATE_PARAMS(kind0, name0) name0 -#define GMOCK_INTERNAL_LIST_HAS_2_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1) name0, name1 -#define GMOCK_INTERNAL_LIST_HAS_3_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2) name0, name1, name2 -#define GMOCK_INTERNAL_LIST_HAS_4_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3) name0, name1, name2, name3 -#define GMOCK_INTERNAL_LIST_HAS_5_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4) name0, name1, name2, name3, \ - name4 -#define GMOCK_INTERNAL_LIST_HAS_6_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5) name0, name1, \ - name2, name3, name4, name5 -#define GMOCK_INTERNAL_LIST_HAS_7_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6) name0, name1, name2, name3, name4, name5, name6 -#define GMOCK_INTERNAL_LIST_HAS_8_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7) name0, name1, name2, name3, name4, name5, name6, name7 -#define GMOCK_INTERNAL_LIST_HAS_9_TEMPLATE_PARAMS(kind0, name0, kind1, name1, \ - kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, name6, \ - kind7, name7, kind8, name8) name0, name1, name2, name3, name4, name5, \ - name6, name7, name8 -#define GMOCK_INTERNAL_LIST_HAS_10_TEMPLATE_PARAMS(kind0, name0, kind1, \ - name1, kind2, name2, kind3, name3, kind4, name4, kind5, name5, kind6, \ - name6, kind7, name7, kind8, name8, kind9, name9) name0, name1, name2, \ - name3, name4, name5, name6, name7, name8, name9 - -// Declares the types of value parameters. -#define GMOCK_INTERNAL_DECL_TYPE_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DECL_TYPE_AND_1_VALUE_PARAMS(p0) , typename p0##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_2_VALUE_PARAMS(p0, p1) , \ - typename p0##_type, typename p1##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , \ - typename p0##_type, typename p1##_type, typename p2##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ - typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ - typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ - typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7) , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8) , typename p0##_type, typename p1##_type, typename p2##_type, \ - typename p3##_type, typename p4##_type, typename p5##_type, \ - typename p6##_type, typename p7##_type, typename p8##_type -#define GMOCK_INTERNAL_DECL_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9) , typename p0##_type, typename p1##_type, \ - typename p2##_type, typename p3##_type, typename p4##_type, \ - typename p5##_type, typename p6##_type, typename p7##_type, \ - typename p8##_type, typename p9##_type - -// Initializes the value parameters. -#define GMOCK_INTERNAL_INIT_AND_0_VALUE_PARAMS()\ - () -#define GMOCK_INTERNAL_INIT_AND_1_VALUE_PARAMS(p0)\ - (p0##_type gmock_p0) : p0(::std::move(gmock_p0)) -#define GMOCK_INTERNAL_INIT_AND_2_VALUE_PARAMS(p0, p1)\ - (p0##_type gmock_p0, p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)) -#define GMOCK_INTERNAL_INIT_AND_3_VALUE_PARAMS(p0, p1, p2)\ - (p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) -#define GMOCK_INTERNAL_INIT_AND_4_VALUE_PARAMS(p0, p1, p2, p3)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)) -#define GMOCK_INTERNAL_INIT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) -#define GMOCK_INTERNAL_INIT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)) -#define GMOCK_INTERNAL_INIT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) -#define GMOCK_INTERNAL_INIT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)) -#define GMOCK_INTERNAL_INIT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) -#define GMOCK_INTERNAL_INIT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9)\ - (p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ - p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \ - p9(::std::move(gmock_p9)) - -// Declares the fields for storing the value parameters. -#define GMOCK_INTERNAL_DEFN_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DEFN_AND_1_VALUE_PARAMS(p0) p0##_type p0; -#define GMOCK_INTERNAL_DEFN_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0; \ - p1##_type p1; -#define GMOCK_INTERNAL_DEFN_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0; \ - p1##_type p1; p2##_type p2; -#define GMOCK_INTERNAL_DEFN_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0; \ - p1##_type p1; p2##_type p2; p3##_type p3; -#define GMOCK_INTERNAL_DEFN_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ - p4) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; -#define GMOCK_INTERNAL_DEFN_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ - p5) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ - p5##_type p5; -#define GMOCK_INTERNAL_DEFN_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ - p5##_type p5; p6##_type p6; -#define GMOCK_INTERNAL_DEFN_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; p4##_type p4; \ - p5##_type p5; p6##_type p6; p7##_type p7; -#define GMOCK_INTERNAL_DEFN_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ - p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; -#define GMOCK_INTERNAL_DEFN_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) p0##_type p0; p1##_type p1; p2##_type p2; p3##_type p3; \ - p4##_type p4; p5##_type p5; p6##_type p6; p7##_type p7; p8##_type p8; \ - p9##_type p9; - -// Lists the value parameters. -#define GMOCK_INTERNAL_LIST_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_LIST_AND_1_VALUE_PARAMS(p0) p0 -#define GMOCK_INTERNAL_LIST_AND_2_VALUE_PARAMS(p0, p1) p0, p1 -#define GMOCK_INTERNAL_LIST_AND_3_VALUE_PARAMS(p0, p1, p2) p0, p1, p2 -#define GMOCK_INTERNAL_LIST_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0, p1, p2, p3 -#define GMOCK_INTERNAL_LIST_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) p0, p1, \ - p2, p3, p4 -#define GMOCK_INTERNAL_LIST_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) p0, \ - p1, p2, p3, p4, p5 -#define GMOCK_INTERNAL_LIST_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) p0, p1, p2, p3, p4, p5, p6 -#define GMOCK_INTERNAL_LIST_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) p0, p1, p2, p3, p4, p5, p6, p7 -#define GMOCK_INTERNAL_LIST_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) p0, p1, p2, p3, p4, p5, p6, p7, p8 -#define GMOCK_INTERNAL_LIST_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) p0, p1, p2, p3, p4, p5, p6, p7, p8, p9 - -// Lists the value parameter types. -#define GMOCK_INTERNAL_LIST_TYPE_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_LIST_TYPE_AND_1_VALUE_PARAMS(p0) , p0##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_2_VALUE_PARAMS(p0, p1) , p0##_type, \ - p1##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_3_VALUE_PARAMS(p0, p1, p2) , p0##_type, \ - p1##_type, p2##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_4_VALUE_PARAMS(p0, p1, p2, p3) , \ - p0##_type, p1##_type, p2##_type, p3##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) , \ - p0##_type, p1##_type, p2##_type, p3##_type, p4##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) , \ - p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, p5##_type, \ - p6##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ - p5##_type, p6##_type, p7##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ - p5##_type, p6##_type, p7##_type, p8##_type -#define GMOCK_INTERNAL_LIST_TYPE_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9) , p0##_type, p1##_type, p2##_type, p3##_type, p4##_type, \ - p5##_type, p6##_type, p7##_type, p8##_type, p9##_type - -// Declares the value parameters. -#define GMOCK_INTERNAL_DECL_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_DECL_AND_1_VALUE_PARAMS(p0) p0##_type p0 -#define GMOCK_INTERNAL_DECL_AND_2_VALUE_PARAMS(p0, p1) p0##_type p0, \ - p1##_type p1 -#define GMOCK_INTERNAL_DECL_AND_3_VALUE_PARAMS(p0, p1, p2) p0##_type p0, \ - p1##_type p1, p2##_type p2 -#define GMOCK_INTERNAL_DECL_AND_4_VALUE_PARAMS(p0, p1, p2, p3) p0##_type p0, \ - p1##_type p1, p2##_type p2, p3##_type p3 -#define GMOCK_INTERNAL_DECL_AND_5_VALUE_PARAMS(p0, p1, p2, p3, \ - p4) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4 -#define GMOCK_INTERNAL_DECL_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, \ - p5) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5 -#define GMOCK_INTERNAL_DECL_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, \ - p6) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6 -#define GMOCK_INTERNAL_DECL_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, \ - p5##_type p5, p6##_type p6, p7##_type p7 -#define GMOCK_INTERNAL_DECL_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8 -#define GMOCK_INTERNAL_DECL_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ - p9##_type p9 - -// The suffix of the class template implementing the action template. -#define GMOCK_INTERNAL_COUNT_AND_0_VALUE_PARAMS() -#define GMOCK_INTERNAL_COUNT_AND_1_VALUE_PARAMS(p0) P -#define GMOCK_INTERNAL_COUNT_AND_2_VALUE_PARAMS(p0, p1) P2 -#define GMOCK_INTERNAL_COUNT_AND_3_VALUE_PARAMS(p0, p1, p2) P3 -#define GMOCK_INTERNAL_COUNT_AND_4_VALUE_PARAMS(p0, p1, p2, p3) P4 -#define GMOCK_INTERNAL_COUNT_AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4) P5 -#define GMOCK_INTERNAL_COUNT_AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5) P6 -#define GMOCK_INTERNAL_COUNT_AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6) P7 -#define GMOCK_INTERNAL_COUNT_AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7) P8 -#define GMOCK_INTERNAL_COUNT_AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8) P9 -#define GMOCK_INTERNAL_COUNT_AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, \ - p7, p8, p9) P10 - -// The name of the class template implementing the action template. -#define GMOCK_ACTION_CLASS_(name, value_params)\ - GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) - -#define ACTION_TEMPLATE(name, template_params, value_params)\ - template \ - class GMOCK_ACTION_CLASS_(name, value_params) {\ - public:\ - explicit GMOCK_ACTION_CLASS_(name, value_params)\ - GMOCK_INTERNAL_INIT_##value_params {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - GMOCK_INTERNAL_DEFN_##value_params\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(\ - new gmock_Impl(GMOCK_INTERNAL_LIST_##value_params));\ - }\ - GMOCK_INTERNAL_DEFN_##value_params\ - private:\ - GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ - };\ - template \ - inline GMOCK_ACTION_CLASS_(name, value_params)<\ - GMOCK_INTERNAL_LIST_##template_params\ - GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ - GMOCK_INTERNAL_DECL_##value_params) {\ - return GMOCK_ACTION_CLASS_(name, value_params)<\ - GMOCK_INTERNAL_LIST_##template_params\ - GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ - GMOCK_INTERNAL_LIST_##value_params);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - GMOCK_ACTION_CLASS_(name, value_params)<\ - GMOCK_INTERNAL_LIST_##template_params\ - GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::\ - gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION(name)\ - class name##Action {\ - public:\ - name##Action() {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl() {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl());\ - }\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##Action);\ - };\ - inline name##Action name() {\ - return name##Action();\ - }\ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##Action::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P(name, p0)\ - template \ - class name##ActionP {\ - public:\ - explicit name##ActionP(p0##_type gmock_p0) : \ - p0(::std::forward(gmock_p0)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - explicit gmock_Impl(p0##_type gmock_p0) : \ - p0(::std::forward(gmock_p0)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0));\ - }\ - p0##_type p0;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP);\ - };\ - template \ - inline name##ActionP name(p0##_type p0) {\ - return name##ActionP(p0);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P2(name, p0, p1)\ - template \ - class name##ActionP2 {\ - public:\ - name##ActionP2(p0##_type gmock_p0, \ - p1##_type gmock_p1) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, \ - p1##_type gmock_p1) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP2);\ - };\ - template \ - inline name##ActionP2 name(p0##_type p0, \ - p1##_type p1) {\ - return name##ActionP2(p0, p1);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP2::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P3(name, p0, p1, p2)\ - template \ - class name##ActionP3 {\ - public:\ - name##ActionP3(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP3);\ - };\ - template \ - inline name##ActionP3 name(p0##_type p0, \ - p1##_type p1, p2##_type p2) {\ - return name##ActionP3(p0, p1, p2);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP3::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P4(name, p0, p1, p2, p3)\ - template \ - class name##ActionP4 {\ - public:\ - name##ActionP4(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, \ - p3##_type gmock_p3) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP4);\ - };\ - template \ - inline name##ActionP4 name(p0##_type p0, p1##_type p1, p2##_type p2, \ - p3##_type p3) {\ - return name##ActionP4(p0, p1, \ - p2, p3);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP4::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P5(name, p0, p1, p2, p3, p4)\ - template \ - class name##ActionP5 {\ - public:\ - name##ActionP5(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, \ - p4##_type gmock_p4) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, \ - p4##_type gmock_p4) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP5);\ - };\ - template \ - inline name##ActionP5 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4) {\ - return name##ActionP5(p0, p1, p2, p3, p4);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP5::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P6(name, p0, p1, p2, p3, p4, p5)\ - template \ - class name##ActionP6 {\ - public:\ - name##ActionP6(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP6);\ - };\ - template \ - inline name##ActionP6 name(p0##_type p0, p1##_type p1, p2##_type p2, \ - p3##_type p3, p4##_type p4, p5##_type p5) {\ - return name##ActionP6(p0, p1, p2, p3, p4, p5);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP6::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P7(name, p0, p1, p2, p3, p4, p5, p6)\ - template \ - class name##ActionP7 {\ - public:\ - name##ActionP7(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, \ - p6##_type gmock_p6) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ - p6));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP7);\ - };\ - template \ - inline name##ActionP7 name(p0##_type p0, p1##_type p1, \ - p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ - p6##_type p6) {\ - return name##ActionP7(p0, p1, p2, p3, p4, p5, p6);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP7::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P8(name, p0, p1, p2, p3, p4, p5, p6, p7)\ - template \ - class name##ActionP8 {\ - public:\ - name##ActionP8(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6, \ - p7##_type gmock_p7) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)), \ - p7(::std::forward(gmock_p7)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, \ - p7##_type gmock_p7) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)), \ - p7(::std::forward(gmock_p7)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - p7##_type p7;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ - p6, p7));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - p7##_type p7;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP8);\ - };\ - template \ - inline name##ActionP8 name(p0##_type p0, \ - p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ - p6##_type p6, p7##_type p7) {\ - return name##ActionP8(p0, p1, p2, p3, p4, p5, \ - p6, p7);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP8::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8)\ - template \ - class name##ActionP9 {\ - public:\ - name##ActionP9(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)), \ - p7(::std::forward(gmock_p7)), \ - p8(::std::forward(gmock_p8)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)), \ - p7(::std::forward(gmock_p7)), \ - p8(::std::forward(gmock_p8)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - p7##_type p7;\ - p8##_type p8;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - p7##_type p7;\ - p8##_type p8;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP9);\ - };\ - template \ - inline name##ActionP9 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ - p8##_type p8) {\ - return name##ActionP9(p0, p1, p2, \ - p3, p4, p5, p6, p7, p8);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP9::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -#define ACTION_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)\ - template \ - class name##ActionP10 {\ - public:\ - name##ActionP10(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8, \ - p9##_type gmock_p9) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)), \ - p7(::std::forward(gmock_p7)), \ - p8(::std::forward(gmock_p8)), \ - p9(::std::forward(gmock_p9)) {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ - p9##_type gmock_p9) : p0(::std::forward(gmock_p0)), \ - p1(::std::forward(gmock_p1)), \ - p2(::std::forward(gmock_p2)), \ - p3(::std::forward(gmock_p3)), \ - p4(::std::forward(gmock_p4)), \ - p5(::std::forward(gmock_p5)), \ - p6(::std::forward(gmock_p6)), \ - p7(::std::forward(gmock_p7)), \ - p8(::std::forward(gmock_p8)), \ - p9(::std::forward(gmock_p9)) {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template \ - return_type gmock_PerformImpl(const args_type& args, \ - const arg0_type& arg0, const arg1_type& arg1, \ - const arg2_type& arg2, const arg3_type& arg3, \ - const arg4_type& arg4, const arg5_type& arg5, \ - const arg6_type& arg6, const arg7_type& arg7, \ - const arg8_type& arg8, const arg9_type& arg9) const;\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - p7##_type p7;\ - p8##_type p8;\ - p9##_type p9;\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl(p0, p1, p2, p3, p4, p5, \ - p6, p7, p8, p9));\ - }\ - p0##_type p0;\ - p1##_type p1;\ - p2##_type p2;\ - p3##_type p3;\ - p4##_type p4;\ - p5##_type p5;\ - p6##_type p6;\ - p7##_type p7;\ - p8##_type p8;\ - p9##_type p9;\ - private:\ - GTEST_DISALLOW_ASSIGN_(name##ActionP10);\ - };\ - template \ - inline name##ActionP10 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ - p9##_type p9) {\ - return name##ActionP10(p0, \ - p1, p2, p3, p4, p5, p6, p7, p8, p9);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - name##ActionP10::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -namespace testing { - - -// The ACTION*() macros trigger warning C4100 (unreferenced formal -// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in -// the macro definition, as the warnings are generated when the macro -// is expanded and macro expansion cannot contain #pragma. Therefore -// we suppress them here. -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4100) -#endif - -// Various overloads for InvokeArgument(). -// -// The InvokeArgument(a1, a2, ..., a_k) action invokes the N-th -// (0-based) argument, which must be a k-ary callable, of the mock -// function, with arguments a1, a2, ..., a_k. -// -// Notes: -// -// 1. The arguments are passed by value by default. If you need to -// pass an argument by reference, wrap it inside ByRef(). For -// example, -// -// InvokeArgument<1>(5, string("Hello"), ByRef(foo)) -// -// passes 5 and string("Hello") by value, and passes foo by -// reference. -// -// 2. If the callable takes an argument by reference but ByRef() is -// not used, it will receive the reference to a copy of the value, -// instead of the original value. For example, when the 0-th -// argument of the mock function takes a const string&, the action -// -// InvokeArgument<0>(string("Hello")) -// -// makes a copy of the temporary string("Hello") object and passes a -// reference of the copy, instead of the original temporary object, -// to the callable. This makes it easy for a user to define an -// InvokeArgument action from temporary values and have it performed -// later. - -namespace internal { -namespace invoke_argument { - -// Appears in InvokeArgumentAdl's argument list to help avoid -// accidental calls to user functions of the same name. -struct AdlTag {}; - -// InvokeArgumentAdl - a helper for InvokeArgument. -// The basic overloads are provided here for generic functors. -// Overloads for other custom-callables are provided in the -// internal/custom/callback-actions.h header. - -template -R InvokeArgumentAdl(AdlTag, F f) { - return f(); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1) { - return f(a1); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2) { - return f(a1, a2); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3) { - return f(a1, a2, a3); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4) { - return f(a1, a2, a3, a4); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { - return f(a1, a2, a3, a4, a5); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { - return f(a1, a2, a3, a4, a5, a6); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, - A7 a7) { - return f(a1, a2, a3, a4, a5, a6, a7); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, - A7 a7, A8 a8) { - return f(a1, a2, a3, a4, a5, a6, a7, a8); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, - A7 a7, A8 a8, A9 a9) { - return f(a1, a2, a3, a4, a5, a6, a7, a8, a9); -} -template -R InvokeArgumentAdl(AdlTag, F f, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, - A7 a7, A8 a8, A9 a9, A10 a10) { - return f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); -} -} // namespace invoke_argument -} // namespace internal - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_0_VALUE_PARAMS()) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args)); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_1_VALUE_PARAMS(p0)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_2_VALUE_PARAMS(p0, p1)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_3_VALUE_PARAMS(p0, p1, p2)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_4_VALUE_PARAMS(p0, p1, p2, p3)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3, p4); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3, p4, p5); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3, p4, p5, p6); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3, p4, p5, p6, p7); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3, p4, p5, p6, p7, p8); -} - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args), p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); -} - -// Various overloads for ReturnNew(). -// -// The ReturnNew(a1, a2, ..., a_k) action returns a pointer to a new -// instance of type T, constructed on the heap with constructor arguments -// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_0_VALUE_PARAMS()) { - return new T(); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_1_VALUE_PARAMS(p0)) { - return new T(p0); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_2_VALUE_PARAMS(p0, p1)) { - return new T(p0, p1); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_3_VALUE_PARAMS(p0, p1, p2)) { - return new T(p0, p1, p2); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_4_VALUE_PARAMS(p0, p1, p2, p3)) { - return new T(p0, p1, p2, p3); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_5_VALUE_PARAMS(p0, p1, p2, p3, p4)) { - return new T(p0, p1, p2, p3, p4); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_6_VALUE_PARAMS(p0, p1, p2, p3, p4, p5)) { - return new T(p0, p1, p2, p3, p4, p5); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_7_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6)) { - return new T(p0, p1, p2, p3, p4, p5, p6); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_8_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7)) { - return new T(p0, p1, p2, p3, p4, p5, p6, p7); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_9_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8)) { - return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8); -} - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_10_VALUE_PARAMS(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)) { - return new T(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9); -} - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -} // namespace testing - -// Include any custom callback actions added by the local installation. -// We must include this header at the end to make sure it can use the -// declarations from this file. -#include "gmock/internal/custom/gmock-generated-actions.h" - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump b/ext/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump deleted file mode 100644 index 209603c5a9..0000000000 --- a/ext/googletest/googlemock/include/gmock/gmock-generated-actions.h.pump +++ /dev/null @@ -1,627 +0,0 @@ -$$ -*- mode: c++; -*- -$$ This is a Pump source file. Please use Pump to convert it to -$$ gmock-generated-actions.h. -$$ -$var n = 10 $$ The maximum arity we support. -$$}} This meta comment fixes auto-indentation in editors. -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used variadic actions. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ - -#include -#include - -#include "gmock/gmock-actions.h" -#include "gmock/internal/gmock-port.h" - -namespace testing { -namespace internal { - -// A macro from the ACTION* family (defined later in this file) -// defines an action that can be used in a mock function. Typically, -// these actions only care about a subset of the arguments of the mock -// function. For example, if such an action only uses the second -// argument, it can be used in any mock function that takes >= 2 -// arguments where the type of the second argument is compatible. -// -// Therefore, the action implementation must be prepared to take more -// arguments than it needs. The ExcessiveArg type is used to -// represent those excessive arguments. In order to keep the compiler -// error messages tractable, we define it in the testing namespace -// instead of testing::internal. However, this is an INTERNAL TYPE -// and subject to change without notice, so a user MUST NOT USE THIS -// TYPE DIRECTLY. -struct ExcessiveArg {}; - -// A helper class needed for implementing the ACTION* macros. -template -class ActionHelper { - public: -$range i 0..n -$for i - -[[ -$var template = [[$if i==0 [[]] $else [[ -$range j 0..i-1 - template <$for j, [[typename A$j]]> -]]]] -$range j 0..i-1 -$var As = [[$for j, [[A$j]]]] -$var as = [[$for j, [[std::get<$j>(args)]]]] -$range k 1..n-i -$var eas = [[$for k, [[ExcessiveArg()]]]] -$var arg_list = [[$if (i==0) | (i==n) [[$as$eas]] $else [[$as, $eas]]]] -$template - static Result Perform(Impl* impl, const ::std::tuple<$As>& args) { - return impl->template gmock_PerformImpl<$As>(args, $arg_list); - } - -]] -}; - -} // namespace internal -} // namespace testing - -// The ACTION* family of macros can be used in a namespace scope to -// define custom actions easily. The syntax: -// -// ACTION(name) { statements; } -// -// will define an action with the given name that executes the -// statements. The value returned by the statements will be used as -// the return value of the action. Inside the statements, you can -// refer to the K-th (0-based) argument of the mock function by -// 'argK', and refer to its type by 'argK_type'. For example: -// -// ACTION(IncrementArg1) { -// arg1_type temp = arg1; -// return ++(*temp); -// } -// -// allows you to write -// -// ...WillOnce(IncrementArg1()); -// -// You can also refer to the entire argument tuple and its type by -// 'args' and 'args_type', and refer to the mock function type and its -// return type by 'function_type' and 'return_type'. -// -// Note that you don't need to specify the types of the mock function -// arguments. However rest assured that your code is still type-safe: -// you'll get a compiler error if *arg1 doesn't support the ++ -// operator, or if the type of ++(*arg1) isn't compatible with the -// mock function's return type, for example. -// -// Sometimes you'll want to parameterize the action. For that you can use -// another macro: -// -// ACTION_P(name, param_name) { statements; } -// -// For example: -// -// ACTION_P(Add, n) { return arg0 + n; } -// -// will allow you to write: -// -// ...WillOnce(Add(5)); -// -// Note that you don't need to provide the type of the parameter -// either. If you need to reference the type of a parameter named -// 'foo', you can write 'foo_type'. For example, in the body of -// ACTION_P(Add, n) above, you can write 'n_type' to refer to the type -// of 'n'. -// -// We also provide ACTION_P2, ACTION_P3, ..., up to ACTION_P$n to support -// multi-parameter actions. -// -// For the purpose of typing, you can view -// -// ACTION_Pk(Foo, p1, ..., pk) { ... } -// -// as shorthand for -// -// template -// FooActionPk Foo(p1_type p1, ..., pk_type pk) { ... } -// -// In particular, you can provide the template type arguments -// explicitly when invoking Foo(), as in Foo(5, false); -// although usually you can rely on the compiler to infer the types -// for you automatically. You can assign the result of expression -// Foo(p1, ..., pk) to a variable of type FooActionPk. This can be useful when composing actions. -// -// You can also overload actions with different numbers of parameters: -// -// ACTION_P(Plus, a) { ... } -// ACTION_P2(Plus, a, b) { ... } -// -// While it's tempting to always use the ACTION* macros when defining -// a new action, you should also consider implementing ActionInterface -// or using MakePolymorphicAction() instead, especially if you need to -// use the action a lot. While these approaches require more work, -// they give you more control on the types of the mock function -// arguments and the action parameters, which in general leads to -// better compiler error messages that pay off in the long run. They -// also allow overloading actions based on parameter types (as opposed -// to just based on the number of parameters). -// -// CAVEAT: -// -// ACTION*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// Users can, however, define any local functors (e.g. a lambda) that -// can be used as actions. -// -// MORE INFORMATION: -// -// To learn more about using these macros, please search for 'ACTION' on -// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md - -$range i 0..n -$range k 0..n-1 - -// An internal macro needed for implementing ACTION*(). -#define GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_\ - const args_type& args GTEST_ATTRIBUTE_UNUSED_ -$for k [[, \ - const arg$k[[]]_type& arg$k GTEST_ATTRIBUTE_UNUSED_]] - - -// Sometimes you want to give an action explicit template parameters -// that cannot be inferred from its value parameters. ACTION() and -// ACTION_P*() don't support that. ACTION_TEMPLATE() remedies that -// and can be viewed as an extension to ACTION() and ACTION_P*(). -// -// The syntax: -// -// ACTION_TEMPLATE(ActionName, -// HAS_m_TEMPLATE_PARAMS(kind1, name1, ..., kind_m, name_m), -// AND_n_VALUE_PARAMS(p1, ..., p_n)) { statements; } -// -// defines an action template that takes m explicit template -// parameters and n value parameters. name_i is the name of the i-th -// template parameter, and kind_i specifies whether it's a typename, -// an integral constant, or a template. p_i is the name of the i-th -// value parameter. -// -// Example: -// -// // DuplicateArg(output) converts the k-th argument of the mock -// // function to type T and copies it to *output. -// ACTION_TEMPLATE(DuplicateArg, -// HAS_2_TEMPLATE_PARAMS(int, k, typename, T), -// AND_1_VALUE_PARAMS(output)) { -// *output = T(::std::get(args)); -// } -// ... -// int n; -// EXPECT_CALL(mock, Foo(_, _)) -// .WillOnce(DuplicateArg<1, unsigned char>(&n)); -// -// To create an instance of an action template, write: -// -// ActionName(v1, ..., v_n) -// -// where the ts are the template arguments and the vs are the value -// arguments. The value argument types are inferred by the compiler. -// If you want to explicitly specify the value argument types, you can -// provide additional template arguments: -// -// ActionName(v1, ..., v_n) -// -// where u_i is the desired type of v_i. -// -// ACTION_TEMPLATE and ACTION/ACTION_P* can be overloaded on the -// number of value parameters, but not on the number of template -// parameters. Without the restriction, the meaning of the following -// is unclear: -// -// OverloadedAction(x); -// -// Are we using a single-template-parameter action where 'bool' refers -// to the type of x, or are we using a two-template-parameter action -// where the compiler is asked to infer the type of x? -// -// Implementation notes: -// -// GMOCK_INTERNAL_*_HAS_m_TEMPLATE_PARAMS and -// GMOCK_INTERNAL_*_AND_n_VALUE_PARAMS are internal macros for -// implementing ACTION_TEMPLATE. The main trick we use is to create -// new macro invocations when expanding a macro. For example, we have -// -// #define ACTION_TEMPLATE(name, template_params, value_params) -// ... GMOCK_INTERNAL_DECL_##template_params ... -// -// which causes ACTION_TEMPLATE(..., HAS_1_TEMPLATE_PARAMS(typename, T), ...) -// to expand to -// -// ... GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS(typename, T) ... -// -// Since GMOCK_INTERNAL_DECL_HAS_1_TEMPLATE_PARAMS is a macro, the -// preprocessor will continue to expand it to -// -// ... typename T ... -// -// This technique conforms to the C++ standard and is portable. It -// allows us to implement action templates using O(N) code, where N is -// the maximum number of template/value parameters supported. Without -// using it, we'd have to devote O(N^2) amount of code to implement all -// combinations of m and n. - -// Declares the template parameters. - -$range j 1..n -$for j [[ -$range m 0..j-1 -#define GMOCK_INTERNAL_DECL_HAS_$j[[]] -_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[kind$m name$m]] - - -]] - -// Lists the template parameters. - -$for j [[ -$range m 0..j-1 -#define GMOCK_INTERNAL_LIST_HAS_$j[[]] -_TEMPLATE_PARAMS($for m, [[kind$m, name$m]]) $for m, [[name$m]] - - -]] - -// Declares the types of value parameters. - -$for i [[ -$range j 0..i-1 -#define GMOCK_INTERNAL_DECL_TYPE_AND_$i[[]] -_VALUE_PARAMS($for j, [[p$j]]) $for j [[, typename p$j##_type]] - - -]] - -// Initializes the value parameters. - -$for i [[ -$range j 0..i-1 -#define GMOCK_INTERNAL_INIT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])\ - ($for j, [[p$j##_type gmock_p$j]])$if i>0 [[ : ]]$for j, [[p$j(::std::move(gmock_p$j))]] - - -]] - -// Declares the fields for storing the value parameters. - -$for i [[ -$range j 0..i-1 -#define GMOCK_INTERNAL_DEFN_AND_$i[[]] -_VALUE_PARAMS($for j, [[p$j]]) $for j [[p$j##_type p$j; ]] - - -]] - -// Lists the value parameters. - -$for i [[ -$range j 0..i-1 -#define GMOCK_INTERNAL_LIST_AND_$i[[]] -_VALUE_PARAMS($for j, [[p$j]]) $for j, [[p$j]] - - -]] - -// Lists the value parameter types. - -$for i [[ -$range j 0..i-1 -#define GMOCK_INTERNAL_LIST_TYPE_AND_$i[[]] -_VALUE_PARAMS($for j, [[p$j]]) $for j [[, p$j##_type]] - - -]] - -// Declares the value parameters. - -$for i [[ -$range j 0..i-1 -#define GMOCK_INTERNAL_DECL_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] -$for j, [[p$j##_type p$j]] - - -]] - -// The suffix of the class template implementing the action template. -$for i [[ - - -$range j 0..i-1 -#define GMOCK_INTERNAL_COUNT_AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]]) [[]] -$if i==1 [[P]] $elif i>=2 [[P$i]] -]] - - -// The name of the class template implementing the action template. -#define GMOCK_ACTION_CLASS_(name, value_params)\ - GTEST_CONCAT_TOKEN_(name##Action, GMOCK_INTERNAL_COUNT_##value_params) - -$range k 0..n-1 - -#define ACTION_TEMPLATE(name, template_params, value_params)\ - template \ - class GMOCK_ACTION_CLASS_(name, value_params) {\ - public:\ - explicit GMOCK_ACTION_CLASS_(name, value_params)\ - GMOCK_INTERNAL_INIT_##value_params {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - explicit gmock_Impl GMOCK_INTERNAL_INIT_##value_params {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template <$for k, [[typename arg$k[[]]_type]]>\ - return_type gmock_PerformImpl(const args_type& args[[]] -$for k [[, const arg$k[[]]_type& arg$k]]) const;\ - GMOCK_INTERNAL_DEFN_##value_params\ - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(\ - new gmock_Impl(GMOCK_INTERNAL_LIST_##value_params));\ - }\ - GMOCK_INTERNAL_DEFN_##value_params\ - private:\ - GTEST_DISALLOW_ASSIGN_(GMOCK_ACTION_CLASS_(name, value_params));\ - };\ - template \ - inline GMOCK_ACTION_CLASS_(name, value_params)<\ - GMOCK_INTERNAL_LIST_##template_params\ - GMOCK_INTERNAL_LIST_TYPE_##value_params> name(\ - GMOCK_INTERNAL_DECL_##value_params) {\ - return GMOCK_ACTION_CLASS_(name, value_params)<\ - GMOCK_INTERNAL_LIST_##template_params\ - GMOCK_INTERNAL_LIST_TYPE_##value_params>(\ - GMOCK_INTERNAL_LIST_##value_params);\ - }\ - template \ - template \ - template \ - typename ::testing::internal::Function::Result\ - GMOCK_ACTION_CLASS_(name, value_params)<\ - GMOCK_INTERNAL_LIST_##template_params\ - GMOCK_INTERNAL_LIST_TYPE_##value_params>::gmock_Impl::\ - gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const - -$for i - -[[ -$var template = [[$if i==0 [[]] $else [[ -$range j 0..i-1 - - template <$for j, [[typename p$j##_type]]>\ -]]]] -$var class_name = [[name##Action[[$if i==0 [[]] $elif i==1 [[P]] - $else [[P$i]]]]]] -$range j 0..i-1 -$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] -$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]] -$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::forward(gmock_p$j))]]]]]] -$var param_field_decls = [[$for j -[[ - - p$j##_type p$j;\ -]]]] -$var param_field_decls2 = [[$for j -[[ - - p$j##_type p$j;\ -]]]] -$var params = [[$for j, [[p$j]]]] -$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]] -$var typename_arg_types = [[$for k, [[typename arg$k[[]]_type]]]] -$var arg_types_and_names = [[$for k, [[const arg$k[[]]_type& arg$k]]]] -$var macro_name = [[$if i==0 [[ACTION]] $elif i==1 [[ACTION_P]] - $else [[ACTION_P$i]]]] - -#define $macro_name(name$for j [[, p$j]])\$template - class $class_name {\ - public:\ - [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {}\ - template \ - class gmock_Impl : public ::testing::ActionInterface {\ - public:\ - typedef F function_type;\ - typedef typename ::testing::internal::Function::Result return_type;\ - typedef typename ::testing::internal::Function::ArgumentTuple\ - args_type;\ - [[$if i==1 [[explicit ]]]]gmock_Impl($ctor_param_list)$inits {}\ - virtual return_type Perform(const args_type& args) {\ - return ::testing::internal::ActionHelper::\ - Perform(this, args);\ - }\ - template <$typename_arg_types>\ - return_type gmock_PerformImpl(const args_type& args, [[]] -$arg_types_and_names) const;\$param_field_decls - private:\ - GTEST_DISALLOW_ASSIGN_(gmock_Impl);\ - };\ - template operator ::testing::Action() const {\ - return ::testing::Action(new gmock_Impl($params));\ - }\$param_field_decls2 - private:\ - GTEST_DISALLOW_ASSIGN_($class_name);\ - };\$template - inline $class_name$param_types name($param_types_and_names) {\ - return $class_name$param_types($params);\ - }\$template - template \ - template <$typename_arg_types>\ - typename ::testing::internal::Function::Result\ - $class_name$param_types::gmock_Impl::gmock_PerformImpl(\ - GMOCK_ACTION_ARG_TYPES_AND_NAMES_UNUSED_) const -]] -$$ } // This meta comment fixes auto-indentation in Emacs. It won't -$$ // show up in the generated code. - - -namespace testing { - - -// The ACTION*() macros trigger warning C4100 (unreferenced formal -// parameter) in MSVC with -W4. Unfortunately they cannot be fixed in -// the macro definition, as the warnings are generated when the macro -// is expanded and macro expansion cannot contain #pragma. Therefore -// we suppress them here. -#ifdef _MSC_VER -# pragma warning(push) -# pragma warning(disable:4100) -#endif - -// Various overloads for InvokeArgument(). -// -// The InvokeArgument(a1, a2, ..., a_k) action invokes the N-th -// (0-based) argument, which must be a k-ary callable, of the mock -// function, with arguments a1, a2, ..., a_k. -// -// Notes: -// -// 1. The arguments are passed by value by default. If you need to -// pass an argument by reference, wrap it inside ByRef(). For -// example, -// -// InvokeArgument<1>(5, string("Hello"), ByRef(foo)) -// -// passes 5 and string("Hello") by value, and passes foo by -// reference. -// -// 2. If the callable takes an argument by reference but ByRef() is -// not used, it will receive the reference to a copy of the value, -// instead of the original value. For example, when the 0-th -// argument of the mock function takes a const string&, the action -// -// InvokeArgument<0>(string("Hello")) -// -// makes a copy of the temporary string("Hello") object and passes a -// reference of the copy, instead of the original temporary object, -// to the callable. This makes it easy for a user to define an -// InvokeArgument action from temporary values and have it performed -// later. - -namespace internal { -namespace invoke_argument { - -// Appears in InvokeArgumentAdl's argument list to help avoid -// accidental calls to user functions of the same name. -struct AdlTag {}; - -// InvokeArgumentAdl - a helper for InvokeArgument. -// The basic overloads are provided here for generic functors. -// Overloads for other custom-callables are provided in the -// internal/custom/callback-actions.h header. - -$range i 0..n -$for i -[[ -$range j 1..i - -template -R InvokeArgumentAdl(AdlTag, F f[[$for j [[, A$j a$j]]]]) { - return f([[$for j, [[a$j]]]]); -} -]] - -} // namespace invoke_argument -} // namespace internal - -$range i 0..n -$for i [[ -$range j 0..i-1 - -ACTION_TEMPLATE(InvokeArgument, - HAS_1_TEMPLATE_PARAMS(int, k), - AND_$i[[]]_VALUE_PARAMS($for j, [[p$j]])) { - using internal::invoke_argument::InvokeArgumentAdl; - return InvokeArgumentAdl( - internal::invoke_argument::AdlTag(), - ::std::get(args)$for j [[, p$j]]); -} - -]] - -// Various overloads for ReturnNew(). -// -// The ReturnNew(a1, a2, ..., a_k) action returns a pointer to a new -// instance of type T, constructed on the heap with constructor arguments -// a1, a2, ..., and a_k. The caller assumes ownership of the returned value. -$range i 0..n -$for i [[ -$range j 0..i-1 -$var ps = [[$for j, [[p$j]]]] - -ACTION_TEMPLATE(ReturnNew, - HAS_1_TEMPLATE_PARAMS(typename, T), - AND_$i[[]]_VALUE_PARAMS($ps)) { - return new T($ps); -} - -]] - -#ifdef _MSC_VER -# pragma warning(pop) -#endif - -} // namespace testing - -// Include any custom callback actions added by the local installation. -// We must include this header at the end to make sure it can use the -// declarations from this file. -#include "gmock/internal/custom/gmock-generated-actions.h" - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_ACTIONS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h b/ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h deleted file mode 100644 index cd9578178c..0000000000 --- a/ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h +++ /dev/null @@ -1,752 +0,0 @@ -// This file was GENERATED by command: -// pump.py gmock-generated-function-mockers.h.pump -// DO NOT EDIT BY HAND!!! - -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements function mockers of various arities. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ - -#include -#include - -#include "gmock/gmock-spec-builders.h" -#include "gmock/internal/gmock-internal-utils.h" - -namespace testing { -namespace internal { -// Removes the given pointer; this is a helper for the expectation setter method -// for parameterless matchers. -// -// We want to make sure that the user cannot set a parameterless expectation on -// overloaded methods, including methods which are overloaded on const. Example: -// -// class MockClass { -// MOCK_METHOD0(GetName, string&()); -// MOCK_CONST_METHOD0(GetName, const string&()); -// }; -// -// TEST() { -// // This should be an error, as it's not clear which overload is expected. -// EXPECT_CALL(mock, GetName).WillOnce(ReturnRef(value)); -// } -// -// Here are the generated expectation-setter methods: -// -// class MockClass { -// // Overload 1 -// MockSpec gmock_GetName() { ... } -// // Overload 2. Declared const so that the compiler will generate an -// // error when trying to resolve between this and overload 4 in -// // 'gmock_GetName(WithoutMatchers(), nullptr)'. -// MockSpec gmock_GetName( -// const WithoutMatchers&, const Function*) const { -// // Removes const from this, calls overload 1 -// return AdjustConstness_(this)->gmock_GetName(); -// } -// -// // Overload 3 -// const string& gmock_GetName() const { ... } -// // Overload 4 -// MockSpec gmock_GetName( -// const WithoutMatchers&, const Function*) const { -// // Does not remove const, calls overload 3 -// return AdjustConstness_const(this)->gmock_GetName(); -// } -// } -// -template -const MockType* AdjustConstness_const(const MockType* mock) { - return mock; -} - -// Removes const from and returns the given pointer; this is a helper for the -// expectation setter method for parameterless matchers. -template -MockType* AdjustConstness_(const MockType* mock) { - return const_cast(mock); -} - -} // namespace internal - -// The style guide prohibits "using" statements in a namespace scope -// inside a header file. However, the FunctionMocker class template -// is meant to be defined in the ::testing namespace. The following -// line is just a trick for working around a bug in MSVC 8.0, which -// cannot handle it if we define FunctionMocker in ::testing. -using internal::FunctionMocker; - -// GMOCK_RESULT_(tn, F) expands to the result type of function type F. -// We define this as a variadic macro in case F contains unprotected -// commas (the same reason that we use variadic macros in other places -// in this file). -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_RESULT_(tn, ...) \ - tn ::testing::internal::Function<__VA_ARGS__>::Result - -// The type of argument N of the given function type. -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_ARG_(tn, N, ...) \ - tn ::testing::internal::Function<__VA_ARGS__>::template Arg::type - -// The matcher type for argument N of the given function type. -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_MATCHER_(tn, N, ...) \ - const ::testing::Matcher& - -// The variable for mocking the given method. -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_MOCKER_(arity, constness, Method) \ - GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD0_(tn, constness, ct, Method, ...) \ - static_assert(0 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - ) constness { \ - GMOCK_MOCKER_(0, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(0, constness, Method).Invoke(); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method() constness { \ - GMOCK_MOCKER_(0, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(0, constness, Method).With(); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(0, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD1_(tn, constness, ct, Method, ...) \ - static_assert(1 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1) constness { \ - GMOCK_MOCKER_(1, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(1, constness, \ - Method).Invoke(::std::forward(gmock_a1)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1) constness { \ - GMOCK_MOCKER_(1, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(1, constness, Method).With(gmock_a1); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(1, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD2_(tn, constness, ct, Method, ...) \ - static_assert(2 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2) constness { \ - GMOCK_MOCKER_(2, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(2, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2) constness { \ - GMOCK_MOCKER_(2, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(2, constness, Method).With(gmock_a1, gmock_a2); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(2, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD3_(tn, constness, ct, Method, ...) \ - static_assert(3 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, \ - __VA_ARGS__) gmock_a3) constness { \ - GMOCK_MOCKER_(3, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(3, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3) constness { \ - GMOCK_MOCKER_(3, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(3, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(3, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD4_(tn, constness, ct, Method, ...) \ - static_assert(4 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4) constness { \ - GMOCK_MOCKER_(4, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(4, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4) constness { \ - GMOCK_MOCKER_(4, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(4, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(4, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD5_(tn, constness, ct, Method, ...) \ - static_assert(5 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \ - __VA_ARGS__) gmock_a5) constness { \ - GMOCK_MOCKER_(5, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(5, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4), \ - ::std::forward(gmock_a5)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5) constness { \ - GMOCK_MOCKER_(5, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(5, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4, gmock_a5); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(5, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD6_(tn, constness, ct, Method, ...) \ - static_assert(6 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \ - __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, \ - __VA_ARGS__) gmock_a6) constness { \ - GMOCK_MOCKER_(6, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(6, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4), \ - ::std::forward(gmock_a5), \ - ::std::forward(gmock_a6)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6) constness { \ - GMOCK_MOCKER_(6, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(6, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4, gmock_a5, gmock_a6); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(6, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD7_(tn, constness, ct, Method, ...) \ - static_assert(7 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \ - __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7) constness { \ - GMOCK_MOCKER_(7, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(7, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4), \ - ::std::forward(gmock_a5), \ - ::std::forward(gmock_a6), \ - ::std::forward(gmock_a7)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7) constness { \ - GMOCK_MOCKER_(7, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(7, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(7, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD8_(tn, constness, ct, Method, ...) \ - static_assert(8 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \ - __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, GMOCK_ARG_(tn, 8, \ - __VA_ARGS__) gmock_a8) constness { \ - GMOCK_MOCKER_(8, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(8, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4), \ - ::std::forward(gmock_a5), \ - ::std::forward(gmock_a6), \ - ::std::forward(gmock_a7), \ - ::std::forward(gmock_a8)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ - GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8) constness { \ - GMOCK_MOCKER_(8, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(8, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(8, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD9_(tn, constness, ct, Method, ...) \ - static_assert(9 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \ - __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, GMOCK_ARG_(tn, 8, \ - __VA_ARGS__) gmock_a8, GMOCK_ARG_(tn, 9, \ - __VA_ARGS__) gmock_a9) constness { \ - GMOCK_MOCKER_(9, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(9, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4), \ - ::std::forward(gmock_a5), \ - ::std::forward(gmock_a6), \ - ::std::forward(gmock_a7), \ - ::std::forward(gmock_a8), \ - ::std::forward(gmock_a9)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ - GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \ - GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9) constness { \ - GMOCK_MOCKER_(9, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(9, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, \ - gmock_a9); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(9, constness, \ - Method) - -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD10_(tn, constness, ct, Method, ...) \ - static_assert(10 == \ - ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, \ - "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - GMOCK_ARG_(tn, 1, __VA_ARGS__) gmock_a1, GMOCK_ARG_(tn, 2, \ - __VA_ARGS__) gmock_a2, GMOCK_ARG_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_ARG_(tn, 4, __VA_ARGS__) gmock_a4, GMOCK_ARG_(tn, 5, \ - __VA_ARGS__) gmock_a5, GMOCK_ARG_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_ARG_(tn, 7, __VA_ARGS__) gmock_a7, GMOCK_ARG_(tn, 8, \ - __VA_ARGS__) gmock_a8, GMOCK_ARG_(tn, 9, __VA_ARGS__) gmock_a9, \ - GMOCK_ARG_(tn, 10, __VA_ARGS__) gmock_a10) constness { \ - GMOCK_MOCKER_(10, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_(10, constness, \ - Method).Invoke(::std::forward(gmock_a1), \ - ::std::forward(gmock_a2), \ - ::std::forward(gmock_a3), \ - ::std::forward(gmock_a4), \ - ::std::forward(gmock_a5), \ - ::std::forward(gmock_a6), \ - ::std::forward(gmock_a7), \ - ::std::forward(gmock_a8), \ - ::std::forward(gmock_a9), \ - ::std::forward(gmock_a10)); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method(GMOCK_MATCHER_(tn, 1, __VA_ARGS__) gmock_a1, \ - GMOCK_MATCHER_(tn, 2, __VA_ARGS__) gmock_a2, \ - GMOCK_MATCHER_(tn, 3, __VA_ARGS__) gmock_a3, \ - GMOCK_MATCHER_(tn, 4, __VA_ARGS__) gmock_a4, \ - GMOCK_MATCHER_(tn, 5, __VA_ARGS__) gmock_a5, \ - GMOCK_MATCHER_(tn, 6, __VA_ARGS__) gmock_a6, \ - GMOCK_MATCHER_(tn, 7, __VA_ARGS__) gmock_a7, \ - GMOCK_MATCHER_(tn, 8, __VA_ARGS__) gmock_a8, \ - GMOCK_MATCHER_(tn, 9, __VA_ARGS__) gmock_a9, \ - GMOCK_MATCHER_(tn, 10, \ - __VA_ARGS__) gmock_a10) constness { \ - GMOCK_MOCKER_(10, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_(10, constness, Method).With(gmock_a1, gmock_a2, \ - gmock_a3, gmock_a4, gmock_a5, gmock_a6, gmock_a7, gmock_a8, gmock_a9, \ - gmock_a10); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method(::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A(), \ - ::testing::A()); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_(10, constness, \ - Method) - -#define MOCK_METHOD0(m, ...) GMOCK_METHOD0_(, , , m, __VA_ARGS__) -#define MOCK_METHOD1(m, ...) GMOCK_METHOD1_(, , , m, __VA_ARGS__) -#define MOCK_METHOD2(m, ...) GMOCK_METHOD2_(, , , m, __VA_ARGS__) -#define MOCK_METHOD3(m, ...) GMOCK_METHOD3_(, , , m, __VA_ARGS__) -#define MOCK_METHOD4(m, ...) GMOCK_METHOD4_(, , , m, __VA_ARGS__) -#define MOCK_METHOD5(m, ...) GMOCK_METHOD5_(, , , m, __VA_ARGS__) -#define MOCK_METHOD6(m, ...) GMOCK_METHOD6_(, , , m, __VA_ARGS__) -#define MOCK_METHOD7(m, ...) GMOCK_METHOD7_(, , , m, __VA_ARGS__) -#define MOCK_METHOD8(m, ...) GMOCK_METHOD8_(, , , m, __VA_ARGS__) -#define MOCK_METHOD9(m, ...) GMOCK_METHOD9_(, , , m, __VA_ARGS__) -#define MOCK_METHOD10(m, ...) GMOCK_METHOD10_(, , , m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0(m, ...) GMOCK_METHOD0_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD1(m, ...) GMOCK_METHOD1_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD2(m, ...) GMOCK_METHOD2_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD3(m, ...) GMOCK_METHOD3_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD4(m, ...) GMOCK_METHOD4_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD5(m, ...) GMOCK_METHOD5_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD6(m, ...) GMOCK_METHOD6_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD7(m, ...) GMOCK_METHOD7_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD8(m, ...) GMOCK_METHOD8_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD9(m, ...) GMOCK_METHOD9_(, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD10(m, ...) GMOCK_METHOD10_(, const, , m, __VA_ARGS__) - -#define MOCK_METHOD0_T(m, ...) GMOCK_METHOD0_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD1_T(m, ...) GMOCK_METHOD1_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD2_T(m, ...) GMOCK_METHOD2_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD3_T(m, ...) GMOCK_METHOD3_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD4_T(m, ...) GMOCK_METHOD4_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD5_T(m, ...) GMOCK_METHOD5_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD6_T(m, ...) GMOCK_METHOD6_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD7_T(m, ...) GMOCK_METHOD7_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD8_T(m, ...) GMOCK_METHOD8_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD9_T(m, ...) GMOCK_METHOD9_(typename, , , m, __VA_ARGS__) -#define MOCK_METHOD10_T(m, ...) GMOCK_METHOD10_(typename, , , m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_T(m, ...) \ - GMOCK_METHOD0_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_T(m, ...) \ - GMOCK_METHOD1_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_T(m, ...) \ - GMOCK_METHOD2_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_T(m, ...) \ - GMOCK_METHOD3_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_T(m, ...) \ - GMOCK_METHOD4_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_T(m, ...) \ - GMOCK_METHOD5_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_T(m, ...) \ - GMOCK_METHOD6_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_T(m, ...) \ - GMOCK_METHOD7_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_T(m, ...) \ - GMOCK_METHOD8_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_T(m, ...) \ - GMOCK_METHOD9_(typename, const, , m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_T(m, ...) \ - GMOCK_METHOD10_(typename, const, , m, __VA_ARGS__) - -#define MOCK_METHOD0_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD0_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD1_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD1_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD2_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD2_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD3_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD3_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD4_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD4_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD5_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD5_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD6_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD6_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD7_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD7_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD8_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD8_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD9_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD9_(, , ct, m, __VA_ARGS__) -#define MOCK_METHOD10_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD10_(, , ct, m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD0_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD1_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD2_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD3_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD4_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD5_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD6_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD7_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD8_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD9_(, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD10_(, const, ct, m, __VA_ARGS__) - -#define MOCK_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD0_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD1_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD2_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD3_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD4_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD5_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD6_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD7_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD8_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD9_(typename, , ct, m, __VA_ARGS__) -#define MOCK_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD10_(typename, , ct, m, __VA_ARGS__) - -#define MOCK_CONST_METHOD0_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD0_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD1_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD1_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD2_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD2_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD3_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD3_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD4_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD4_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD5_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD5_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD6_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD6_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD7_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD7_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD8_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD8_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD9_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD9_(typename, const, ct, m, __VA_ARGS__) -#define MOCK_CONST_METHOD10_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD10_(typename, const, ct, m, __VA_ARGS__) - -} // namespace testing - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump b/ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump deleted file mode 100644 index a56e132f34..0000000000 --- a/ext/googletest/googlemock/include/gmock/gmock-generated-function-mockers.h.pump +++ /dev/null @@ -1,227 +0,0 @@ -$$ -*- mode: c++; -*- -$$ This is a Pump source file. Please use Pump to convert -$$ it to gmock-generated-function-mockers.h. -$$ -$var n = 10 $$ The maximum arity we support. -// Copyright 2007, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements function mockers of various arities. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ - -#include -#include - -#include "gmock/gmock-spec-builders.h" -#include "gmock/internal/gmock-internal-utils.h" - -namespace testing { -namespace internal { - -$range i 0..n -// Removes the given pointer; this is a helper for the expectation setter method -// for parameterless matchers. -// -// We want to make sure that the user cannot set a parameterless expectation on -// overloaded methods, including methods which are overloaded on const. Example: -// -// class MockClass { -// MOCK_METHOD0(GetName, string&()); -// MOCK_CONST_METHOD0(GetName, const string&()); -// }; -// -// TEST() { -// // This should be an error, as it's not clear which overload is expected. -// EXPECT_CALL(mock, GetName).WillOnce(ReturnRef(value)); -// } -// -// Here are the generated expectation-setter methods: -// -// class MockClass { -// // Overload 1 -// MockSpec gmock_GetName() { ... } -// // Overload 2. Declared const so that the compiler will generate an -// // error when trying to resolve between this and overload 4 in -// // 'gmock_GetName(WithoutMatchers(), nullptr)'. -// MockSpec gmock_GetName( -// const WithoutMatchers&, const Function*) const { -// // Removes const from this, calls overload 1 -// return AdjustConstness_(this)->gmock_GetName(); -// } -// -// // Overload 3 -// const string& gmock_GetName() const { ... } -// // Overload 4 -// MockSpec gmock_GetName( -// const WithoutMatchers&, const Function*) const { -// // Does not remove const, calls overload 3 -// return AdjustConstness_const(this)->gmock_GetName(); -// } -// } -// -template -const MockType* AdjustConstness_const(const MockType* mock) { - return mock; -} - -// Removes const from and returns the given pointer; this is a helper for the -// expectation setter method for parameterless matchers. -template -MockType* AdjustConstness_(const MockType* mock) { - return const_cast(mock); -} - -} // namespace internal - -// The style guide prohibits "using" statements in a namespace scope -// inside a header file. However, the FunctionMocker class template -// is meant to be defined in the ::testing namespace. The following -// line is just a trick for working around a bug in MSVC 8.0, which -// cannot handle it if we define FunctionMocker in ::testing. -using internal::FunctionMocker; - -// GMOCK_RESULT_(tn, F) expands to the result type of function type F. -// We define this as a variadic macro in case F contains unprotected -// commas (the same reason that we use variadic macros in other places -// in this file). -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_RESULT_(tn, ...) \ - tn ::testing::internal::Function<__VA_ARGS__>::Result - -// The type of argument N of the given function type. -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_ARG_(tn, N, ...) \ - tn ::testing::internal::Function<__VA_ARGS__>::template Arg::type - -// The matcher type for argument N of the given function type. -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_MATCHER_(tn, N, ...) \ - const ::testing::Matcher& - -// The variable for mocking the given method. -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_MOCKER_(arity, constness, Method) \ - GTEST_CONCAT_TOKEN_(gmock##constness##arity##_##Method##_, __LINE__) - - -$for i [[ -$range j 1..i -$var arg_as = [[$for j, [[GMOCK_ARG_(tn, $j, __VA_ARGS__) gmock_a$j]]]] -$var as = [[$for j, \ - [[::std::forward(gmock_a$j)]]]] -$var matcher_arg_as = [[$for j, \ - [[GMOCK_MATCHER_(tn, $j, __VA_ARGS__) gmock_a$j]]]] -$var matcher_as = [[$for j, [[gmock_a$j]]]] -$var anything_matchers = [[$for j, \ - [[::testing::A()]]]] -// INTERNAL IMPLEMENTATION - DON'T USE IN USER CODE!!! -#define GMOCK_METHOD$i[[]]_(tn, constness, ct, Method, ...) \ - static_assert($i == ::testing::internal::Function<__VA_ARGS__>::ArgumentCount, "MOCK_METHOD must match argument count.");\ - GMOCK_RESULT_(tn, __VA_ARGS__) ct Method( \ - $arg_as) constness { \ - GMOCK_MOCKER_($i, constness, Method).SetOwnerAndName(this, #Method); \ - return GMOCK_MOCKER_($i, constness, Method).Invoke($as); \ - } \ - ::testing::MockSpec<__VA_ARGS__> \ - gmock_##Method($matcher_arg_as) constness { \ - GMOCK_MOCKER_($i, constness, Method).RegisterOwner(this); \ - return GMOCK_MOCKER_($i, constness, Method).With($matcher_as); \ - } \ - ::testing::MockSpec<__VA_ARGS__> gmock_##Method( \ - const ::testing::internal::WithoutMatchers&, \ - constness ::testing::internal::Function<__VA_ARGS__>* ) const { \ - return ::testing::internal::AdjustConstness_##constness(this)-> \ - gmock_##Method($anything_matchers); \ - } \ - mutable ::testing::FunctionMocker<__VA_ARGS__> GMOCK_MOCKER_($i, constness, Method) - - -]] -$for i [[ -#define MOCK_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, , , m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_CONST_METHOD$i(m, ...) GMOCK_METHOD$i[[]]_(, const, , m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_METHOD$i[[]]_T(m, ...) GMOCK_METHOD$i[[]]_(typename, , , m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_CONST_METHOD$i[[]]_T(m, ...) \ - GMOCK_METHOD$i[[]]_(typename, const, , m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD$i[[]]_(, , ct, m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_CONST_METHOD$i[[]]_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD$i[[]]_(, const, ct, m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD$i[[]]_(typename, , ct, m, __VA_ARGS__) - -]] - - -$for i [[ -#define MOCK_CONST_METHOD$i[[]]_T_WITH_CALLTYPE(ct, m, ...) \ - GMOCK_METHOD$i[[]]_(typename, const, ct, m, __VA_ARGS__) - -]] - -} // namespace testing - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_FUNCTION_MOCKERS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h b/ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h deleted file mode 100644 index 690a57f1c9..0000000000 --- a/ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h +++ /dev/null @@ -1,1097 +0,0 @@ -// This file was GENERATED by command: -// pump.py gmock-generated-matchers.h.pump -// DO NOT EDIT BY HAND!!! - -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used variadic matchers. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ - -#include -#include -#include -#include -#include -#include "gmock/gmock-matchers.h" - -// The MATCHER* family of macros can be used in a namespace scope to -// define custom matchers easily. -// -// Basic Usage -// =========== -// -// The syntax -// -// MATCHER(name, description_string) { statements; } -// -// defines a matcher with the given name that executes the statements, -// which must return a bool to indicate if the match succeeds. Inside -// the statements, you can refer to the value being matched by 'arg', -// and refer to its type by 'arg_type'. -// -// The description string documents what the matcher does, and is used -// to generate the failure message when the match fails. Since a -// MATCHER() is usually defined in a header file shared by multiple -// C++ source files, we require the description to be a C-string -// literal to avoid possible side effects. It can be empty, in which -// case we'll use the sequence of words in the matcher name as the -// description. -// -// For example: -// -// MATCHER(IsEven, "") { return (arg % 2) == 0; } -// -// allows you to write -// -// // Expects mock_foo.Bar(n) to be called where n is even. -// EXPECT_CALL(mock_foo, Bar(IsEven())); -// -// or, -// -// // Verifies that the value of some_expression is even. -// EXPECT_THAT(some_expression, IsEven()); -// -// If the above assertion fails, it will print something like: -// -// Value of: some_expression -// Expected: is even -// Actual: 7 -// -// where the description "is even" is automatically calculated from the -// matcher name IsEven. -// -// Argument Type -// ============= -// -// Note that the type of the value being matched (arg_type) is -// determined by the context in which you use the matcher and is -// supplied to you by the compiler, so you don't need to worry about -// declaring it (nor can you). This allows the matcher to be -// polymorphic. For example, IsEven() can be used to match any type -// where the value of "(arg % 2) == 0" can be implicitly converted to -// a bool. In the "Bar(IsEven())" example above, if method Bar() -// takes an int, 'arg_type' will be int; if it takes an unsigned long, -// 'arg_type' will be unsigned long; and so on. -// -// Parameterizing Matchers -// ======================= -// -// Sometimes you'll want to parameterize the matcher. For that you -// can use another macro: -// -// MATCHER_P(name, param_name, description_string) { statements; } -// -// For example: -// -// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } -// -// will allow you to write: -// -// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); -// -// which may lead to this message (assuming n is 10): -// -// Value of: Blah("a") -// Expected: has absolute value 10 -// Actual: -9 -// -// Note that both the matcher description and its parameter are -// printed, making the message human-friendly. -// -// In the matcher definition body, you can write 'foo_type' to -// reference the type of a parameter named 'foo'. For example, in the -// body of MATCHER_P(HasAbsoluteValue, value) above, you can write -// 'value_type' to refer to the type of 'value'. -// -// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P10 to -// support multi-parameter matchers. -// -// Describing Parameterized Matchers -// ================================= -// -// The last argument to MATCHER*() is a string-typed expression. The -// expression can reference all of the matcher's parameters and a -// special bool-typed variable named 'negation'. When 'negation' is -// false, the expression should evaluate to the matcher's description; -// otherwise it should evaluate to the description of the negation of -// the matcher. For example, -// -// using testing::PrintToString; -// -// MATCHER_P2(InClosedRange, low, hi, -// std::string(negation ? "is not" : "is") + " in range [" + -// PrintToString(low) + ", " + PrintToString(hi) + "]") { -// return low <= arg && arg <= hi; -// } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: is in range [4, 6] -// ... -// Expected: is not in range [2, 4] -// -// If you specify "" as the description, the failure message will -// contain the sequence of words in the matcher name followed by the -// parameter values printed as a tuple. For example, -// -// MATCHER_P2(InClosedRange, low, hi, "") { ... } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: in closed range (4, 6) -// ... -// Expected: not (in closed range (2, 4)) -// -// Types of Matcher Parameters -// =========================== -// -// For the purpose of typing, you can view -// -// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } -// -// as shorthand for -// -// template -// FooMatcherPk -// Foo(p1_type p1, ..., pk_type pk) { ... } -// -// When you write Foo(v1, ..., vk), the compiler infers the types of -// the parameters v1, ..., and vk for you. If you are not happy with -// the result of the type inference, you can specify the types by -// explicitly instantiating the template, as in Foo(5, -// false). As said earlier, you don't get to (or need to) specify -// 'arg_type' as that's determined by the context in which the matcher -// is used. You can assign the result of expression Foo(p1, ..., pk) -// to a variable of type FooMatcherPk. This -// can be useful when composing matchers. -// -// While you can instantiate a matcher template with reference types, -// passing the parameters by pointer usually makes your code more -// readable. If, however, you still want to pass a parameter by -// reference, be aware that in the failure message generated by the -// matcher you will see the value of the referenced object but not its -// address. -// -// Explaining Match Results -// ======================== -// -// Sometimes the matcher description alone isn't enough to explain why -// the match has failed or succeeded. For example, when expecting a -// long string, it can be very helpful to also print the diff between -// the expected string and the actual one. To achieve that, you can -// optionally stream additional information to a special variable -// named result_listener, whose type is a pointer to class -// MatchResultListener: -// -// MATCHER_P(EqualsLongString, str, "") { -// if (arg == str) return true; -// -// *result_listener << "the difference: " -/// << DiffStrings(str, arg); -// return false; -// } -// -// Overloading Matchers -// ==================== -// -// You can overload matchers with different numbers of parameters: -// -// MATCHER_P(Blah, a, description_string1) { ... } -// MATCHER_P2(Blah, a, b, description_string2) { ... } -// -// Caveats -// ======= -// -// When defining a new matcher, you should also consider implementing -// MatcherInterface or using MakePolymorphicMatcher(). These -// approaches require more work than the MATCHER* macros, but also -// give you more control on the types of the value being matched and -// the matcher parameters, which may leads to better compiler error -// messages when the matcher is used wrong. They also allow -// overloading matchers based on parameter types (as opposed to just -// based on the number of parameters). -// -// MATCHER*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// -// More Information -// ================ -// -// To learn more about using these macros, please search for 'MATCHER' -// on -// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md - -#define MATCHER(name, description)\ - class name##Matcher {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl()\ - {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple<>()));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl());\ - }\ - name##Matcher() {\ - }\ - private:\ - };\ - inline name##Matcher name() {\ - return name##Matcher();\ - }\ - template \ - bool name##Matcher::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P(name, p0, description)\ - template \ - class name##MatcherP {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - explicit gmock_Impl(p0##_type gmock_p0)\ - : p0(::std::move(gmock_p0)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0));\ - }\ - explicit name##MatcherP(p0##_type gmock_p0) : p0(::std::move(gmock_p0)) {\ - }\ - p0##_type const p0;\ - private:\ - };\ - template \ - inline name##MatcherP name(p0##_type p0) {\ - return name##MatcherP(p0);\ - }\ - template \ - template \ - bool name##MatcherP::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P2(name, p0, p1, description)\ - template \ - class name##MatcherP2 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1));\ - }\ - name##MatcherP2(p0##_type gmock_p0, \ - p1##_type gmock_p1) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - private:\ - };\ - template \ - inline name##MatcherP2 name(p0##_type p0, \ - p1##_type p1) {\ - return name##MatcherP2(p0, p1);\ - }\ - template \ - template \ - bool name##MatcherP2::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P3(name, p0, p1, p2, description)\ - template \ - class name##MatcherP3 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2));\ - }\ - name##MatcherP3(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - private:\ - };\ - template \ - inline name##MatcherP3 name(p0##_type p0, \ - p1##_type p1, p2##_type p2) {\ - return name##MatcherP3(p0, p1, p2);\ - }\ - template \ - template \ - bool name##MatcherP3::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P4(name, p0, p1, p2, p3, description)\ - template \ - class name##MatcherP4 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, \ - p1, p2, p3)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3));\ - }\ - name##MatcherP4(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - private:\ - };\ - template \ - inline name##MatcherP4 name(p0##_type p0, p1##_type p1, p2##_type p2, \ - p3##_type p3) {\ - return name##MatcherP4(p0, \ - p1, p2, p3);\ - }\ - template \ - template \ - bool name##MatcherP4::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P5(name, p0, p1, p2, p3, p4, description)\ - template \ - class name##MatcherP5 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2, p3, p4)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3, p4));\ - }\ - name##MatcherP5(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, \ - p4##_type gmock_p4) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - private:\ - };\ - template \ - inline name##MatcherP5 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4) {\ - return name##MatcherP5(p0, p1, p2, p3, p4);\ - }\ - template \ - template \ - bool name##MatcherP5::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P6(name, p0, p1, p2, p3, p4, p5, description)\ - template \ - class name##MatcherP6 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2, p3, p4, p5)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3, p4, p5));\ - }\ - name##MatcherP6(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - private:\ - };\ - template \ - inline name##MatcherP6 name(p0##_type p0, p1##_type p1, p2##_type p2, \ - p3##_type p3, p4##_type p4, p5##_type p5) {\ - return name##MatcherP6(p0, p1, p2, p3, p4, p5);\ - }\ - template \ - template \ - bool name##MatcherP6::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P7(name, p0, p1, p2, p3, p4, p5, p6, description)\ - template \ - class name##MatcherP7 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2, p3, p4, p5, \ - p6)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3, p4, p5, p6));\ - }\ - name##MatcherP7(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - private:\ - };\ - template \ - inline name##MatcherP7 name(p0##_type p0, p1##_type p1, \ - p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ - p6##_type p6) {\ - return name##MatcherP7(p0, p1, p2, p3, p4, p5, p6);\ - }\ - template \ - template \ - bool name##MatcherP7::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P8(name, p0, p1, p2, p3, p4, p5, p6, p7, description)\ - template \ - class name##MatcherP8 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - p7##_type const p7;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2, \ - p3, p4, p5, p6, p7)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3, p4, p5, p6, p7));\ - }\ - name##MatcherP8(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6, \ - p7##_type gmock_p7) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - p7##_type const p7;\ - private:\ - };\ - template \ - inline name##MatcherP8 name(p0##_type p0, \ - p1##_type p1, p2##_type p2, p3##_type p3, p4##_type p4, p5##_type p5, \ - p6##_type p6, p7##_type p7) {\ - return name##MatcherP8(p0, p1, p2, p3, p4, p5, \ - p6, p7);\ - }\ - template \ - template \ - bool name##MatcherP8::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P9(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, description)\ - template \ - class name##MatcherP9 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \ - p8(::std::move(gmock_p8)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - p7##_type const p7;\ - p8##_type const p8;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2, p3, p4, p5, p6, p7, p8)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3, p4, p5, p6, p7, p8));\ - }\ - name##MatcherP9(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - p7##_type const p7;\ - p8##_type const p8;\ - private:\ - };\ - template \ - inline name##MatcherP9 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, \ - p8##_type p8) {\ - return name##MatcherP9(p0, p1, p2, \ - p3, p4, p5, p6, p7, p8);\ - }\ - template \ - template \ - bool name##MatcherP9::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#define MATCHER_P10(name, p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, description)\ - template \ - class name##MatcherP10 {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - gmock_Impl(p0##_type gmock_p0, p1##_type gmock_p1, p2##_type gmock_p2, \ - p3##_type gmock_p3, p4##_type gmock_p4, p5##_type gmock_p5, \ - p6##_type gmock_p6, p7##_type gmock_p7, p8##_type gmock_p8, \ - p9##_type gmock_p9)\ - : p0(::std::move(gmock_p0)), p1(::std::move(gmock_p1)), \ - p2(::std::move(gmock_p2)), p3(::std::move(gmock_p3)), \ - p4(::std::move(gmock_p4)), p5(::std::move(gmock_p5)), \ - p6(::std::move(gmock_p6)), p7(::std::move(gmock_p7)), \ - p8(::std::move(gmock_p8)), p9(::std::move(gmock_p9)) {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - p7##_type const p7;\ - p8##_type const p8;\ - p9##_type const p9;\ - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9)));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl(p0, p1, p2, p3, p4, p5, p6, p7, p8, p9));\ - }\ - name##MatcherP10(p0##_type gmock_p0, p1##_type gmock_p1, \ - p2##_type gmock_p2, p3##_type gmock_p3, p4##_type gmock_p4, \ - p5##_type gmock_p5, p6##_type gmock_p6, p7##_type gmock_p7, \ - p8##_type gmock_p8, p9##_type gmock_p9) : p0(::std::move(gmock_p0)), \ - p1(::std::move(gmock_p1)), p2(::std::move(gmock_p2)), \ - p3(::std::move(gmock_p3)), p4(::std::move(gmock_p4)), \ - p5(::std::move(gmock_p5)), p6(::std::move(gmock_p6)), \ - p7(::std::move(gmock_p7)), p8(::std::move(gmock_p8)), \ - p9(::std::move(gmock_p9)) {\ - }\ - p0##_type const p0;\ - p1##_type const p1;\ - p2##_type const p2;\ - p3##_type const p3;\ - p4##_type const p4;\ - p5##_type const p5;\ - p6##_type const p6;\ - p7##_type const p7;\ - p8##_type const p8;\ - p9##_type const p9;\ - private:\ - };\ - template \ - inline name##MatcherP10 name(p0##_type p0, p1##_type p1, p2##_type p2, p3##_type p3, \ - p4##_type p4, p5##_type p5, p6##_type p6, p7##_type p7, p8##_type p8, \ - p9##_type p9) {\ - return name##MatcherP10(p0, \ - p1, p2, p3, p4, p5, p6, p7, p8, p9);\ - }\ - template \ - template \ - bool name##MatcherP10::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump b/ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump deleted file mode 100644 index ae90917cc3..0000000000 --- a/ext/googletest/googlemock/include/gmock/gmock-generated-matchers.h.pump +++ /dev/null @@ -1,346 +0,0 @@ -$$ -*- mode: c++; -*- -$$ This is a Pump source file. Please use Pump to convert -$$ it to gmock-generated-matchers.h. -$$ -$var n = 10 $$ The maximum arity we support. -$$ }} This line fixes auto-indentation of the following code in Emacs. -// Copyright 2008, Google Inc. -// All rights reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -// Google Mock - a framework for writing C++ mock classes. -// -// This file implements some commonly used variadic matchers. - -// GOOGLETEST_CM0002 DO NOT DELETE - -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ - -#include -#include -#include -#include -#include -#include "gmock/gmock-matchers.h" - -// The MATCHER* family of macros can be used in a namespace scope to -// define custom matchers easily. -// -// Basic Usage -// =========== -// -// The syntax -// -// MATCHER(name, description_string) { statements; } -// -// defines a matcher with the given name that executes the statements, -// which must return a bool to indicate if the match succeeds. Inside -// the statements, you can refer to the value being matched by 'arg', -// and refer to its type by 'arg_type'. -// -// The description string documents what the matcher does, and is used -// to generate the failure message when the match fails. Since a -// MATCHER() is usually defined in a header file shared by multiple -// C++ source files, we require the description to be a C-string -// literal to avoid possible side effects. It can be empty, in which -// case we'll use the sequence of words in the matcher name as the -// description. -// -// For example: -// -// MATCHER(IsEven, "") { return (arg % 2) == 0; } -// -// allows you to write -// -// // Expects mock_foo.Bar(n) to be called where n is even. -// EXPECT_CALL(mock_foo, Bar(IsEven())); -// -// or, -// -// // Verifies that the value of some_expression is even. -// EXPECT_THAT(some_expression, IsEven()); -// -// If the above assertion fails, it will print something like: -// -// Value of: some_expression -// Expected: is even -// Actual: 7 -// -// where the description "is even" is automatically calculated from the -// matcher name IsEven. -// -// Argument Type -// ============= -// -// Note that the type of the value being matched (arg_type) is -// determined by the context in which you use the matcher and is -// supplied to you by the compiler, so you don't need to worry about -// declaring it (nor can you). This allows the matcher to be -// polymorphic. For example, IsEven() can be used to match any type -// where the value of "(arg % 2) == 0" can be implicitly converted to -// a bool. In the "Bar(IsEven())" example above, if method Bar() -// takes an int, 'arg_type' will be int; if it takes an unsigned long, -// 'arg_type' will be unsigned long; and so on. -// -// Parameterizing Matchers -// ======================= -// -// Sometimes you'll want to parameterize the matcher. For that you -// can use another macro: -// -// MATCHER_P(name, param_name, description_string) { statements; } -// -// For example: -// -// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } -// -// will allow you to write: -// -// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); -// -// which may lead to this message (assuming n is 10): -// -// Value of: Blah("a") -// Expected: has absolute value 10 -// Actual: -9 -// -// Note that both the matcher description and its parameter are -// printed, making the message human-friendly. -// -// In the matcher definition body, you can write 'foo_type' to -// reference the type of a parameter named 'foo'. For example, in the -// body of MATCHER_P(HasAbsoluteValue, value) above, you can write -// 'value_type' to refer to the type of 'value'. -// -// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to -// support multi-parameter matchers. -// -// Describing Parameterized Matchers -// ================================= -// -// The last argument to MATCHER*() is a string-typed expression. The -// expression can reference all of the matcher's parameters and a -// special bool-typed variable named 'negation'. When 'negation' is -// false, the expression should evaluate to the matcher's description; -// otherwise it should evaluate to the description of the negation of -// the matcher. For example, -// -// using testing::PrintToString; -// -// MATCHER_P2(InClosedRange, low, hi, -// std::string(negation ? "is not" : "is") + " in range [" + -// PrintToString(low) + ", " + PrintToString(hi) + "]") { -// return low <= arg && arg <= hi; -// } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: is in range [4, 6] -// ... -// Expected: is not in range [2, 4] -// -// If you specify "" as the description, the failure message will -// contain the sequence of words in the matcher name followed by the -// parameter values printed as a tuple. For example, -// -// MATCHER_P2(InClosedRange, low, hi, "") { ... } -// ... -// EXPECT_THAT(3, InClosedRange(4, 6)); -// EXPECT_THAT(3, Not(InClosedRange(2, 4))); -// -// would generate two failures that contain the text: -// -// Expected: in closed range (4, 6) -// ... -// Expected: not (in closed range (2, 4)) -// -// Types of Matcher Parameters -// =========================== -// -// For the purpose of typing, you can view -// -// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } -// -// as shorthand for -// -// template -// FooMatcherPk -// Foo(p1_type p1, ..., pk_type pk) { ... } -// -// When you write Foo(v1, ..., vk), the compiler infers the types of -// the parameters v1, ..., and vk for you. If you are not happy with -// the result of the type inference, you can specify the types by -// explicitly instantiating the template, as in Foo(5, -// false). As said earlier, you don't get to (or need to) specify -// 'arg_type' as that's determined by the context in which the matcher -// is used. You can assign the result of expression Foo(p1, ..., pk) -// to a variable of type FooMatcherPk. This -// can be useful when composing matchers. -// -// While you can instantiate a matcher template with reference types, -// passing the parameters by pointer usually makes your code more -// readable. If, however, you still want to pass a parameter by -// reference, be aware that in the failure message generated by the -// matcher you will see the value of the referenced object but not its -// address. -// -// Explaining Match Results -// ======================== -// -// Sometimes the matcher description alone isn't enough to explain why -// the match has failed or succeeded. For example, when expecting a -// long string, it can be very helpful to also print the diff between -// the expected string and the actual one. To achieve that, you can -// optionally stream additional information to a special variable -// named result_listener, whose type is a pointer to class -// MatchResultListener: -// -// MATCHER_P(EqualsLongString, str, "") { -// if (arg == str) return true; -// -// *result_listener << "the difference: " -/// << DiffStrings(str, arg); -// return false; -// } -// -// Overloading Matchers -// ==================== -// -// You can overload matchers with different numbers of parameters: -// -// MATCHER_P(Blah, a, description_string1) { ... } -// MATCHER_P2(Blah, a, b, description_string2) { ... } -// -// Caveats -// ======= -// -// When defining a new matcher, you should also consider implementing -// MatcherInterface or using MakePolymorphicMatcher(). These -// approaches require more work than the MATCHER* macros, but also -// give you more control on the types of the value being matched and -// the matcher parameters, which may leads to better compiler error -// messages when the matcher is used wrong. They also allow -// overloading matchers based on parameter types (as opposed to just -// based on the number of parameters). -// -// MATCHER*() can only be used in a namespace scope as templates cannot be -// declared inside of a local class. -// -// More Information -// ================ -// -// To learn more about using these macros, please search for 'MATCHER' -// on -// https://github.com/google/googletest/blob/master/googlemock/docs/cook_book.md - -$range i 0..n -$for i - -[[ -$var macro_name = [[$if i==0 [[MATCHER]] $elif i==1 [[MATCHER_P]] - $else [[MATCHER_P$i]]]] -$var class_name = [[name##Matcher[[$if i==0 [[]] $elif i==1 [[P]] - $else [[P$i]]]]]] -$range j 0..i-1 -$var template = [[$if i==0 [[]] $else [[ - - template <$for j, [[typename p$j##_type]]>\ -]]]] -$var ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] -$var impl_ctor_param_list = [[$for j, [[p$j##_type gmock_p$j]]]] -$var impl_inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::move(gmock_p$j))]]]]]] -$var inits = [[$if i==0 [[]] $else [[ : $for j, [[p$j(::std::move(gmock_p$j))]]]]]] -$var params = [[$for j, [[p$j]]]] -$var param_types = [[$if i==0 [[]] $else [[<$for j, [[p$j##_type]]>]]]] -$var param_types_and_names = [[$for j, [[p$j##_type p$j]]]] -$var param_field_decls = [[$for j -[[ - - p$j##_type const p$j;\ -]]]] -$var param_field_decls2 = [[$for j -[[ - - p$j##_type const p$j;\ -]]]] - -#define $macro_name(name$for j [[, p$j]], description)\$template - class $class_name {\ - public:\ - template \ - class gmock_Impl : public ::testing::MatcherInterface<\ - GTEST_REFERENCE_TO_CONST_(arg_type)> {\ - public:\ - [[$if i==1 [[explicit ]]]]gmock_Impl($impl_ctor_param_list)\ - $impl_inits {}\ - virtual bool MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener) const;\ - virtual void DescribeTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(false);\ - }\ - virtual void DescribeNegationTo(::std::ostream* gmock_os) const {\ - *gmock_os << FormatDescription(true);\ - }\$param_field_decls - private:\ - ::std::string FormatDescription(bool negation) const {\ - ::std::string gmock_description = (description);\ - if (!gmock_description.empty()) {\ - return gmock_description;\ - }\ - return ::testing::internal::FormatMatcherDescription(\ - negation, #name, \ - ::testing::internal::UniversalTersePrintTupleFieldsToStrings(\ - ::std::tuple<$for j, [[p$j##_type]]>($for j, [[p$j]])));\ - }\ - };\ - template \ - operator ::testing::Matcher() const {\ - return ::testing::Matcher(\ - new gmock_Impl($params));\ - }\ - [[$if i==1 [[explicit ]]]]$class_name($ctor_param_list)$inits {\ - }\$param_field_decls2 - private:\ - };\$template - inline $class_name$param_types name($param_types_and_names) {\ - return $class_name$param_types($params);\ - }\$template - template \ - bool $class_name$param_types::gmock_Impl::MatchAndExplain(\ - GTEST_REFERENCE_TO_CONST_(arg_type) arg,\ - ::testing::MatchResultListener* result_listener GTEST_ATTRIBUTE_UNUSED_)\ - const -]] - - -#endif // GMOCK_INCLUDE_GMOCK_GMOCK_GENERATED_MATCHERS_H_ diff --git a/ext/googletest/googlemock/include/gmock/gmock-matchers.h b/ext/googletest/googlemock/include/gmock/gmock-matchers.h index 28e188bb81..f1bb22caa9 100644 --- a/ext/googletest/googlemock/include/gmock/gmock-matchers.h +++ b/ext/googletest/googlemock/include/gmock/gmock-matchers.h @@ -30,7 +30,220 @@ // Google Mock - a framework for writing C++ mock classes. // -// This file implements some commonly used argument matchers. More +// The MATCHER* family of macros can be used in a namespace scope to +// define custom matchers easily. +// +// Basic Usage +// =========== +// +// The syntax +// +// MATCHER(name, description_string) { statements; } +// +// defines a matcher with the given name that executes the statements, +// which must return a bool to indicate if the match succeeds. Inside +// the statements, you can refer to the value being matched by 'arg', +// and refer to its type by 'arg_type'. +// +// The description string documents what the matcher does, and is used +// to generate the failure message when the match fails. Since a +// MATCHER() is usually defined in a header file shared by multiple +// C++ source files, we require the description to be a C-string +// literal to avoid possible side effects. It can be empty, in which +// case we'll use the sequence of words in the matcher name as the +// description. +// +// For example: +// +// MATCHER(IsEven, "") { return (arg % 2) == 0; } +// +// allows you to write +// +// // Expects mock_foo.Bar(n) to be called where n is even. +// EXPECT_CALL(mock_foo, Bar(IsEven())); +// +// or, +// +// // Verifies that the value of some_expression is even. +// EXPECT_THAT(some_expression, IsEven()); +// +// If the above assertion fails, it will print something like: +// +// Value of: some_expression +// Expected: is even +// Actual: 7 +// +// where the description "is even" is automatically calculated from the +// matcher name IsEven. +// +// Argument Type +// ============= +// +// Note that the type of the value being matched (arg_type) is +// determined by the context in which you use the matcher and is +// supplied to you by the compiler, so you don't need to worry about +// declaring it (nor can you). This allows the matcher to be +// polymorphic. For example, IsEven() can be used to match any type +// where the value of "(arg % 2) == 0" can be implicitly converted to +// a bool. In the "Bar(IsEven())" example above, if method Bar() +// takes an int, 'arg_type' will be int; if it takes an unsigned long, +// 'arg_type' will be unsigned long; and so on. +// +// Parameterizing Matchers +// ======================= +// +// Sometimes you'll want to parameterize the matcher. For that you +// can use another macro: +// +// MATCHER_P(name, param_name, description_string) { statements; } +// +// For example: +// +// MATCHER_P(HasAbsoluteValue, value, "") { return abs(arg) == value; } +// +// will allow you to write: +// +// EXPECT_THAT(Blah("a"), HasAbsoluteValue(n)); +// +// which may lead to this message (assuming n is 10): +// +// Value of: Blah("a") +// Expected: has absolute value 10 +// Actual: -9 +// +// Note that both the matcher description and its parameter are +// printed, making the message human-friendly. +// +// In the matcher definition body, you can write 'foo_type' to +// reference the type of a parameter named 'foo'. For example, in the +// body of MATCHER_P(HasAbsoluteValue, value) above, you can write +// 'value_type' to refer to the type of 'value'. +// +// We also provide MATCHER_P2, MATCHER_P3, ..., up to MATCHER_P$n to +// support multi-parameter matchers. +// +// Describing Parameterized Matchers +// ================================= +// +// The last argument to MATCHER*() is a string-typed expression. The +// expression can reference all of the matcher's parameters and a +// special bool-typed variable named 'negation'. When 'negation' is +// false, the expression should evaluate to the matcher's description; +// otherwise it should evaluate to the description of the negation of +// the matcher. For example, +// +// using testing::PrintToString; +// +// MATCHER_P2(InClosedRange, low, hi, +// std::string(negation ? "is not" : "is") + " in range [" + +// PrintToString(low) + ", " + PrintToString(hi) + "]") { +// return low <= arg && arg <= hi; +// } +// ... +// EXPECT_THAT(3, InClosedRange(4, 6)); +// EXPECT_THAT(3, Not(InClosedRange(2, 4))); +// +// would generate two failures that contain the text: +// +// Expected: is in range [4, 6] +// ... +// Expected: is not in range [2, 4] +// +// If you specify "" as the description, the failure message will +// contain the sequence of words in the matcher name followed by the +// parameter values printed as a tuple. For example, +// +// MATCHER_P2(InClosedRange, low, hi, "") { ... } +// ... +// EXPECT_THAT(3, InClosedRange(4, 6)); +// EXPECT_THAT(3, Not(InClosedRange(2, 4))); +// +// would generate two failures that contain the text: +// +// Expected: in closed range (4, 6) +// ... +// Expected: not (in closed range (2, 4)) +// +// Types of Matcher Parameters +// =========================== +// +// For the purpose of typing, you can view +// +// MATCHER_Pk(Foo, p1, ..., pk, description_string) { ... } +// +// as shorthand for +// +// template +// FooMatcherPk +// Foo(p1_type p1, ..., pk_type pk) { ... } +// +// When you write Foo(v1, ..., vk), the compiler infers the types of +// the parameters v1, ..., and vk for you. If you are not happy with +// the result of the type inference, you can specify the types by +// explicitly instantiating the template, as in Foo(5, +// false). As said earlier, you don't get to (or need to) specify +// 'arg_type' as that's determined by the context in which the matcher +// is used. You can assign the result of expression Foo(p1, ..., pk) +// to a variable of type FooMatcherPk. This +// can be useful when composing matchers. +// +// While you can instantiate a matcher template with reference types, +// passing the parameters by pointer usually makes your code more +// readable. If, however, you still want to pass a parameter by +// reference, be aware that in the failure message generated by the +// matcher you will see the value of the referenced object but not its +// address. +// +// Explaining Match Results +// ======================== +// +// Sometimes the matcher description alone isn't enough to explain why +// the match has failed or succeeded. For example, when expecting a +// long string, it can be very helpful to also print the diff between +// the expected string and the actual one. To achieve that, you can +// optionally stream additional information to a special variable +// named result_listener, whose type is a pointer to class +// MatchResultListener: +// +// MATCHER_P(EqualsLongString, str, "") { +// if (arg == str) return true; +// +// *result_listener << "the difference: " +/// << DiffStrings(str, arg); +// return false; +// } +// +// Overloading Matchers +// ==================== +// +// You can overload matchers with different numbers of parameters: +// +// MATCHER_P(Blah, a, description_string1) { ... } +// MATCHER_P2(Blah, a, b, description_string2) { ... } +// +// Caveats +// ======= +// +// When defining a new matcher, you should also consider implementing +// MatcherInterface or using MakePolymorphicMatcher(). These +// approaches require more work than the MATCHER* macros, but also +// give you more control on the types of the value being matched and +// the matcher parameters, which may leads to better compiler error +// messages when the matcher is used wrong. They also allow +// overloading matchers based on parameter types (as opposed to just +// based on the number of parameters). +// +// MATCHER*() can only be used in a namespace scope as templates cannot be +// declared inside of a local class. +// +// More Information +// ================ +// +// To learn more about using these macros, please search for 'MATCHER' +// on +// https://github.com/google/googletest/blob/master/docs/gmock_cook_book.md +// +// This file also implements some commonly used argument matchers. More // matchers can be defined by the user implementing the // MatcherInterface interface if necessary. // @@ -39,11 +252,11 @@ // GOOGLETEST_CM0002 DO NOT DELETE -#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ -#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ +#ifndef GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ +#define GOOGLEMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_ -#include #include +#include #include #include #include @@ -54,8 +267,10 @@ #include #include #include + #include "gmock/internal/gmock-internal-utils.h" #include "gmock/internal/gmock-port.h" +#include "gmock/internal/gmock-pp.h" #include "gtest/gtest.h" // MSVC warning C5046 is new as of VS2017 version 15.8. @@ -128,7 +343,7 @@ class MatcherCastImpl { // constructor from M (this usually happens when T has an implicit // constructor from any type). // - // It won't work to unconditionally implict_cast + // It won't work to unconditionally implicit_cast // polymorphic_matcher_or_value to Matcher because it won't trigger // a user-defined conversion from M to T if one exists (assuming M is // a value). @@ -141,7 +356,7 @@ class MatcherCastImpl { template static Matcher CastImpl(const M& polymorphic_matcher_or_value, std::true_type /* convertible_to_matcher */, - bool_constant) { + std::integral_constant) { // M is implicitly convertible to Matcher, which means that either // M is a polymorphic matcher or Matcher has an implicit constructor // from M. In both cases using the implicit conversion will produce a @@ -209,7 +424,14 @@ class MatcherCastImpl > { !std::is_base_of::value, "Can't implicitly convert from to "); - return source_matcher_.MatchAndExplain(static_cast(x), listener); + // Do the cast to `U` explicitly if necessary. + // Otherwise, let implicit conversions do the trick. + using CastType = + typename std::conditional::value, + T&, U>::type; + + return source_matcher_.MatchAndExplain(static_cast(x), + listener); } void DescribeTo(::std::ostream* os) const override { @@ -222,8 +444,6 @@ class MatcherCastImpl > { private: const Matcher source_matcher_; - - GTEST_DISALLOW_ASSIGN_(Impl); }; }; @@ -235,6 +455,50 @@ class MatcherCastImpl > { static Matcher Cast(const Matcher& matcher) { return matcher; } }; +// Template specialization for parameterless Matcher. +template +class MatcherBaseImpl { + public: + MatcherBaseImpl() = default; + + template + operator ::testing::Matcher() const { // NOLINT(runtime/explicit) + return ::testing::Matcher(new + typename Derived::template gmock_Impl()); + } +}; + +// Template specialization for Matcher with parameters. +template