Gabe Black has uploaded this change for review. (
https://gem5-review.googlesource.com/c/public/gem5/+/44146 )
Change subject: arch-x86: Rework the ACPI object interfaces.
......................................................................
arch-x86: Rework the ACPI object interfaces.
Change-Id: I1ee08854d1c81925e4da145bf4c9bd3cefc7458a
---
M src/arch/x86/bios/acpi.cc
M src/arch/x86/bios/acpi.hh
2 files changed, 204 insertions(+), 249 deletions(-)
diff --git a/src/arch/x86/bios/acpi.cc b/src/arch/x86/bios/acpi.cc
index 2946392..035ae97 100644
--- a/src/arch/x86/bios/acpi.cc
+++ b/src/arch/x86/bios/acpi.cc
@@ -43,17 +43,6 @@
#include "base/trace.hh"
#include "mem/port.hh"
#include "mem/port_proxy.hh"
-#include "params/X86ACPIMadt.hh"
-#include "params/X86ACPIMadtIOAPIC.hh"
-#include "params/X86ACPIMadtIntSourceOverride.hh"
-#include "params/X86ACPIMadtLAPIC.hh"
-#include "params/X86ACPIMadtLAPICOverride.hh"
-#include "params/X86ACPIMadtNMI.hh"
-#include "params/X86ACPIMadtRecord.hh"
-#include "params/X86ACPIRSDP.hh"
-#include "params/X86ACPIRSDT.hh"
-#include "params/X86ACPISysDescTable.hh"
-#include "params/X86ACPIXSDT.hh"
#include "sim/byteswap.hh"
#include "sim/sim_object.hh"
@@ -92,38 +81,34 @@
SimObject(p),
rsdt(p.rsdt),
xsdt(p.xsdt)
-{
- static_assert(sizeof(signature) - 1 == sizeof(_data.signature),
- "signature length mismatch");
- std::memcpy(_data.signature, signature, sizeof(_data.signature));
- std::strncpy(_data.oemID, p.oem_id.c_str(), sizeof(_data.oemID));
- _data.revision = p.revision;
- _data.length = sizeof(_data);
-}
+{}
Addr
RSDP::write(PortProxy& phys_proxy, Allocator& alloc) const
{
- std::vector<uint8_t> mem(sizeof(_data));
- Addr addr = alloc.alloc(sizeof(_data), 16);
+ std::vector<uint8_t> mem(sizeof(Mem));
+ Addr addr = alloc.alloc(mem.size(), 16);
- assert(mem.size() >= sizeof(_data));
- std::memcpy(mem.data(), &_data, sizeof(_data));
- Mem* desc = (Mem*)mem.data();
+ Mem* data = (Mem*)mem.data();
+ static_assert(sizeof(signature) - 1 == sizeof(data->signature),
+ "signature length mismatch");
+ std::memcpy(data->signature, signature, sizeof(data->signature));
+ std::strncpy(data->oemID, params().oem_id.c_str(),
sizeof(data->oemID));
+ data->revision = params().revision;
+ data->length = mem.size();
if (rsdt) {
- desc->rsdtAddress = rsdt->write(phys_proxy, alloc);
- DPRINTF(ACPI, "Allocated RSDT @ %llx\n", desc->rsdtAddress);
+ data->rsdtAddress = rsdt->write(phys_proxy, alloc);
+ DPRINTF(ACPI, "Allocated RSDT @ %llx\n", data->rsdtAddress);
}
if (xsdt) {
- desc->xsdtAddress = xsdt->write(phys_proxy, alloc);
- DPRINTF(ACPI, "Allocated XSDT @ %llx\n", desc->xsdtAddress);
+ data->xsdtAddress = xsdt->write(phys_proxy, alloc);
+ DPRINTF(ACPI, "Allocated XSDT @ %llx\n", data->xsdtAddress);
}
// checksum calculation
- assert(_data.length == sizeof(_data));
- desc->checksum = apic_checksum(mem.data(), sizeof(MemR0));
- desc->extendedChecksum = apic_checksum(mem.data(), _data.length);
+ data->checksum = apic_checksum(mem.data(), sizeof(MemR0));
+ data->extendedChecksum = apic_checksum(mem.data(), mem.size());
// write the whole thing
phys_proxy.writeBlob(addr, mem.data(), mem.size());
@@ -131,50 +116,37 @@
return addr;
}
-SysDescTable::Mem::Mem(const char* _signature, uint8_t _revision,
- const Params& p) :
- revision(_revision)
-{
- std::strncpy(signature, _signature, sizeof(signature));
- std::strncpy(oemID, p.oem_id.c_str(), sizeof(oemID));
- std::strncpy(oemTableID, p.oem_table_id.c_str(), sizeof(oemTableID));
- oemRevision = p.oem_revision;
- creatorID = p.creator_id;
- creatorRevision = p.creator_revision;
-}
-
-void
-SysDescTable::prepare_self(std::vector<uint8_t>& mem) const
-{
- Mem const* d;
- std::size_t size;
- std::tie(d, size) = data();
- mem.resize(size);
- std::memcpy(mem.data(), d, size);
-}
-
Addr
-SysDescTable::prepare(std::vector<uint8_t>& mem,
- PortProxy& phys_proxy, Allocator& alloc) const
+SysDescTable::writeBuf(PortProxy& phys_proxy, Allocator& alloc,
+ std::vector<uint8_t> &mem) const
{
- prepare_self(mem);
- return alloc.alloc(mem.size());
-}
+ // An empty SysDescTable doesn't make any sense, so assert that
somebody
+ // else allocated a large enough blob.
+ assert(!mem.empty());
-Addr
-SysDescTable::write(PortProxy& phys_proxy, Allocator& alloc) const
-{
- std::vector<uint8_t> mem;
+ // Allocate a place to write this blob.
+ Addr addr = alloc.alloc(mem.size());
- // prepare data
- Addr addr = prepare(mem, phys_proxy, alloc);
+ DPRINTF(ACPI, "Writing system description table [%llx - %llx]\n", addr,
+ addr + mem.size());
- // checksum calculation
+ // Fill in the header.
+ auto& p = params();
Mem* header = (Mem*)mem.data();
+ std::strncpy(header->signature, signature, sizeof(header->signature));
header->length = mem.size();
+ header->revision = revision;
+ std::strncpy(header->oemID, p.oem_id.c_str(), sizeof(header->oemID));
+ std::strncpy(header->oemTableID, p.oem_table_id.c_str(),
+ sizeof(header->oemTableID));
+ header->oemRevision = p.oem_revision;
+ header->creatorID = p.creator_id;
+ header->creatorRevision = p.creator_revision;
+
+ // Update checksum.
header->checksum = apic_checksum(mem.data(), mem.size());
- // write to physical memory
+ // Write to memory.
phys_proxy.writeBlob(addr, mem.data(), mem.size());
return addr;
@@ -182,48 +154,43 @@
//// RSDT, XSDT
template<class T>
-RXSDT<T>::RXSDT(const Params& p, const char * _signature, uint8_t
_revision) :
- SysDescTable(p),
- _data(_signature, _revision, p)
+RXSDT<T>::RXSDT(const Params& p, const char *_signature, uint8_t
_revision) :
+ SysDescTable(p, _signature, _revision)
{}
template<class T>
-std::tuple<SysDescTable::Mem const*, std::size_t>
-RXSDT<T>::data() const
-{
- return std::make_tuple(&_data, sizeof(_data));
-}
-
-template<class T>
Addr
-RXSDT<T>::prepare(std::vector<uint8_t>& mem,
- PortProxy& phys_proxy, Allocator& alloc) const
+RXSDT<T>::writeBuf(PortProxy& phys_proxy, Allocator& alloc,
+ std::vector<uint8_t>& mem) const
{
- prepare_self(mem);
+ // Since this table ends with a variably sized array, it can't be
extended
+ // by another table type.
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
+
auto base_size = mem.size();
mem.resize(base_size + sizeof(Ptr) * entries.size());
- Addr addr = alloc.alloc(mem.size());
+
Ptr* ptr_array = reinterpret_cast<Ptr*>(mem.data() + base_size);
- DPRINTF(ACPI, "RXSDT: writing %d entries @ %llx (ptr size: %d)\n",
- entries.size(), addr, sizeof(Ptr));
- for (unsigned i = 0; i < entries.size(); ++i) {
- Addr entry_addr = entries[i]->write(phys_proxy, alloc);
+ DPRINTF(ACPI, "RXSDT: Writing %d entries (ptr size: %d)\n",
entries.size(),
+ sizeof(Ptr));
+ for (const auto *entry : entries) {
+ Addr entry_addr = entry->write(phys_proxy, alloc);
fatal_if((entry_addr & mask(sizeof(Ptr) * 8)) != entry_addr,
"RXSDT: Entry address doesn't fit in pointer type.");
DPRINTF(ACPI, "RXSDT: wrote entry @ %llx\n", entry_addr);
- ptr_array[i] = entry_addr;
+ *ptr_array++ = entry_addr;
}
- return addr;
+
+ return SysDescTable::writeBuf(phys_proxy, alloc, mem);
}
-RSDT::RSDT(const Params& p) :
- RXSDT(p, "RSDT", 1)
+RSDT::RSDT(const Params& p) : RXSDT(p, "RSDT", 1)
{
entries = p.entries;
}
-XSDT::XSDT(const Params& p) :
- RXSDT(p, "XSDT", 1)
+XSDT::XSDT(const Params& p) : RXSDT(p, "XSDT", 1)
{
entries = p.entries;
}
@@ -231,91 +198,114 @@
//// MADT
MADT::MADT::MADT(const Params& p) :
- SysDescTable(p),
- records(p.records),
- _data("APIC", 4, p)
-{
- _data.localAPICAddress = p.local_apic_address;
- _data.flags = p.flags;
-}
+ SysDescTable(p, "APIC", 4),
+ records(p.records)
+{}
-std::tuple<SysDescTable::Mem const*, std::size_t>
-MADT::MADT::data() const
+Addr
+MADT::MADT::writeBuf(PortProxy& phys_proxy, Allocator& alloc,
+ std::vector<uint8_t>& mem) const
{
- return std::make_tuple(&_data, sizeof(_data));
-}
+ // Since this table ends with a variably sized array, it can't be
extended
+ // by another table type.
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
-void
-MADT::MADT::prepare_self(std::vector<uint8_t>& mem) const
-{
- // header
- SysDescTable::prepare_self(mem);
- auto base_size = mem.size();
+ Mem* header = reinterpret_cast<Mem*>(mem.data());
+ header->localAPICAddress = params().local_apic_address;
+ header->flags = params().flags;
- // size of header and records
- std::size_t record_size = 0;
- for (auto const& record : records) {
- assert(record->size() > 0);
- record_size += record->size();
+ for (const auto& record : records) {
+ auto entry = record->prepare();
+ mem.insert(mem.end(), entry.begin(), entry.end());
}
- mem.resize(base_size + record_size);
- // records
- auto p = mem.data() + base_size;
DPRINTF(ACPI, "MADT: writing %d records (size: %d)\n",
records.size(), mem.size());
- for (auto const& record : records) {
- assert(p < mem.data() + mem.size());
- record->write(p);
- p += record->size();
- }
+
+ return SysDescTable::writeBuf(phys_proxy, alloc, mem);
}
void
-MADT::Record::write(uint8_t* mem) const
+MADT::Record::prepareBuf(std::vector<uint8_t>& mem) const
{
+ assert(!mem.empty());
DPRINTF(ACPI, "MADT: writing record type %d (size: %d)\n",
- data().type, data().length);
- std::memcpy(mem, &data(), size());
+ type, mem.size());
+
+ Mem* header = reinterpret_cast<Mem*>(mem.data());
+ header->type = type;
+ header->length = mem.size();
}
-MADT::LAPIC::LAPIC(const Params& p) :
- Record(p)
+void
+MADT::LAPIC::prepareBuf(std::vector<uint8_t>& mem) const
{
- d.acpiProcessorId = p.acpi_processor_id;
- d.apicId = p.apic_id;
- d.flags = p.flags;
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
+
+ Mem* data = reinterpret_cast<Mem*>(mem.data());
+ data->acpiProcessorId = params().acpi_processor_id;
+ data->apicId = params().apic_id;
+ data->flags = params().flags;
+
+ Record::prepareBuf(mem);
}
-MADT::IOAPIC::IOAPIC(const Params& p) :
- Record(p)
+void
+MADT::IOAPIC::prepareBuf(std::vector<uint8_t>& mem) const
{
- d.ioApicId = p.id;
- d.ioApicAddress = p.address;
- d.intBase = p.int_base;
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
+
+ Mem* data = reinterpret_cast<Mem*>(mem.data());
+ data->ioApicId = params().id;
+ data->ioApicAddress = params().address;
+ data->intBase = params().int_base;
+
+ Record::prepareBuf(mem);
}
-MADT::IntSourceOverride::IntSourceOverride(const Params& p) :
- Record(p)
+void
+MADT::IntSourceOverride::prepareBuf(std::vector<uint8_t>& mem) const
{
- d.busSource = p.bus_source;
- d.irqSource = p.irq_source;
- d.globalSystemInterrupt = p.sys_int;
- d.flags = p.flags;
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
+
+ Mem* data = reinterpret_cast<Mem*>(mem.data());
+ data->busSource = params().bus_source;
+ data->irqSource = params().irq_source;
+ data->globalSystemInterrupt = params().sys_int;
+ data->flags = params().flags;
+
+ Record::prepareBuf(mem);
}
-MADT::NMI::NMI(const Params& p) :
- Record(p)
+void
+MADT::NMI::prepareBuf(std::vector<uint8_t>& mem) const
{
- d.acpiProcessorId = p.acpi_processor_id;
- d.flags = p.flags;
- d.lintNo = p.lint_no;
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
+
+ Mem* data = reinterpret_cast<Mem*>(mem.data());
+ data->acpiProcessorId = params().acpi_processor_id;
+ // The "flags" field is not properly aligned.
+ memcpy(&data->flags, ¶ms().flags, sizeof(data->flags));
+ data->lintNo = params().lint_no;
+
+ Record::prepareBuf(mem);
}
-MADT::LAPICOverride::LAPICOverride(const Params& p) :
- Record(p)
+void
+MADT::LAPICOverride::prepareBuf(std::vector<uint8_t>& mem) const
{
- d.localAPICAddress = p.address;
+ assert(mem.empty());
+ mem.resize(sizeof(Mem));
+
+ Mem* data = reinterpret_cast<Mem*>(mem.data());
+ data->localAPICAddress = params().address;
+
+ Record::prepareBuf(mem);
}
} // namespace ACPI
diff --git a/src/arch/x86/bios/acpi.hh b/src/arch/x86/bios/acpi.hh
index bb1d905..cc0c93e 100644
--- a/src/arch/x86/bios/acpi.hh
+++ b/src/arch/x86/bios/acpi.hh
@@ -46,24 +46,21 @@
#include "base/compiler.hh"
#include "base/types.hh"
#include "debug/ACPI.hh"
+#include "params/X86ACPIMadt.hh"
+#include "params/X86ACPIMadtIOAPIC.hh"
+#include "params/X86ACPIMadtIntSourceOverride.hh"
+#include "params/X86ACPIMadtLAPIC.hh"
+#include "params/X86ACPIMadtLAPICOverride.hh"
+#include "params/X86ACPIMadtNMI.hh"
+#include "params/X86ACPIMadtRecord.hh"
+#include "params/X86ACPIRSDP.hh"
+#include "params/X86ACPIRSDT.hh"
+#include "params/X86ACPISysDescTable.hh"
+#include "params/X86ACPIXSDT.hh"
#include "sim/sim_object.hh"
-class Port;
class PortProxy;
-struct X86ACPIRSDPParams;
-
-struct X86ACPISysDescTableParams;
-struct X86ACPIRSDTParams;
-struct X86ACPIXSDTParams;
-struct X86ACPIMadtParams;
-struct X86ACPIMadtRecordParams;
-struct X86ACPIMadtLAPICParams;
-struct X86ACPIMadtIOAPICParams;
-struct X86ACPIMadtIntSourceOverrideParams;
-struct X86ACPIMadtNMIParams;
-struct X86ACPIMadtLAPICOverrideParams;
-
namespace X86ISA
{
@@ -72,7 +69,6 @@
class RSDT;
class XSDT;
-class SysDescTable;
struct Allocator
{
@@ -95,7 +91,7 @@
class RSDP : public SimObject
{
protected:
- typedef X86ACPIRSDPParams Params;
+ PARAMS(X86ACPIRSDP);
static const char signature[];
@@ -122,11 +118,6 @@
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy,");
- Mem _data;
-
- std::string oemID;
- uint8_t revision;
-
RSDT* rsdt;
XSDT* xsdt;
@@ -139,7 +130,7 @@
class SysDescTable : public SimObject
{
protected:
- typedef X86ACPISysDescTableParams Params;
+ PARAMS(X86ACPISysDescTable);
struct M5_ATTR_PACKED Mem
{
@@ -153,22 +144,27 @@
uint32_t oemRevision = 0;
uint32_t creatorID = 0;
uint32_t creatorRevision = 0;
-
- Mem(char const* signature, uint8_t revision, const Params& p);
};
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- virtual void prepare_self(std::vector<uint8_t>& mem) const;
- virtual Addr prepare(std::vector<uint8_t>& mem,
- PortProxy& physProxy, Allocator& alloc) const;
+ virtual Addr writeBuf(PortProxy& phys_proxy, Allocator& alloc,
+ std::vector<uint8_t>& mem) const;
- virtual std::tuple<Mem const*, std::size_t> data() const = 0;
+ const char* signature;
+ uint8_t revision;
+
+ SysDescTable(const Params& p, const char* _signature, uint8_t
_revision) :
+ SimObject(p), signature(_signature), revision(_revision)
+ {}
public:
- using SimObject::SimObject;
-
- Addr write(PortProxy& phys_proxy, Allocator& alloc) const;
+ Addr
+ write(PortProxy& phys_proxy, Allocator& alloc) const
+ {
+ std::vector<uint8_t> mem;
+ return writeBuf(phys_proxy, alloc, mem);
+ }
};
template<class T>
@@ -179,15 +175,8 @@
std::vector<SysDescTable *> entries;
- Addr prepare(std::vector<uint8_t>& mem,
- PortProxy& phys_proxy, Allocator& alloc) const override;
-
- std::tuple<Mem const*, std::size_t> data() const override;
-
- private:
- SysDescTable::Mem _data;
- static_assert(std::is_trivially_copyable<decltype(_data)>::value,
- "Type not suitable for memcpy.");
+ Addr writeBuf(PortProxy& phys_proxy, Allocator& alloc,
+ std::vector<uint8_t>& mem) const override;
protected:
RXSDT(const Params& p, const char* _signature, uint8_t _revision);
@@ -196,7 +185,7 @@
class RSDT : public RXSDT<uint32_t>
{
protected:
- typedef X86ACPIRSDTParams Params;
+ PARAMS(X86ACPIRSDT);
public:
RSDT(const Params &p);
@@ -205,7 +194,7 @@
class XSDT : public RXSDT<uint64_t>
{
protected:
- typedef X86ACPIXSDTParams Params;
+ PARAMS(X86ACPIXSDT);
public:
XSDT(const Params &p);
@@ -216,38 +205,39 @@
class Record : public SimObject
{
protected:
- typedef X86ACPIMadtRecordParams Params;
+ PARAMS(X86ACPIMadtRecord);
struct M5_ATTR_PACKED Mem
{
- uint8_t type;
+ uint8_t type = 0;
uint8_t length = 0;
-
- Mem(uint8_t _type, uint8_t _length) :
- type(_type),
- length(_length)
- {}
};
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- virtual Mem const& data() const = 0;
+ uint8_t type;
+
+ virtual void prepareBuf(std::vector<uint8_t>& mem) const;
public:
- using SimObject::SimObject;
+ Record(const Params& p, uint8_t _type) : SimObject(p), type(_type) {}
- std::size_t size() const { return data().length; }
- void write(uint8_t* mem) const;
+ std::vector<uint8_t>
+ prepare() const
+ {
+ std::vector<uint8_t> mem;
+ prepareBuf(mem);
+ return mem;
+ }
};
class LAPIC : public Record
{
protected:
- typedef X86ACPIMadtLAPICParams Params;
+ PARAMS(X86ACPIMadtLAPIC);
+
struct M5_ATTR_PACKED Mem : public Record::Mem
{
- Mem() : Record::Mem(0, sizeof(Mem)) {}
-
uint8_t acpiProcessorId = 0;
uint8_t apicId = 0;
uint32_t flags = 0;
@@ -255,23 +245,19 @@
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- Record::Mem const& data() const override { return d; }
-
- private:
- Mem d;
+ void prepareBuf(std::vector<uint8_t>& mem) const override;
public:
- LAPIC(const Params& p);
+ LAPIC(const Params& p) : Record(p, 0) {}
};
class IOAPIC : public Record
{
protected:
- typedef X86ACPIMadtIOAPICParams Params;
+ PARAMS(X86ACPIMadtIOAPIC);
+
struct M5_ATTR_PACKED Mem : public Record::Mem
{
- Mem() : Record::Mem(1, sizeof(Mem)) {}
-
uint8_t ioApicId = 0;
uint8_t _reserved = 0;
uint32_t ioApicAddress = 0;
@@ -280,23 +266,19 @@
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- Record::Mem const& data() const override { return d; }
-
- private:
- Mem d;
+ void prepareBuf(std::vector<uint8_t>& mem) const override;
public:
- IOAPIC(const Params& p);
+ IOAPIC(const Params& p) : Record(p, 1) {}
};
class IntSourceOverride : public Record
{
protected:
- typedef X86ACPIMadtIntSourceOverrideParams Params;
+ PARAMS(X86ACPIMadtIntSourceOverride);
+
struct M5_ATTR_PACKED Mem : public Record::Mem
{
- Mem() : Record::Mem(2, sizeof(Mem)) {}
-
uint8_t busSource = 0;
uint8_t irqSource = 0;
uint32_t globalSystemInterrupt = 0;
@@ -305,23 +287,19 @@
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- Record::Mem const& data() const override { return d; }
-
- private:
- Mem d;
+ void prepareBuf(std::vector<uint8_t>& mem) const override;
public:
- IntSourceOverride(const Params& p);
+ IntSourceOverride(const Params& p) : Record(p, 2) {}
};
class NMI : public Record
{
protected:
- typedef X86ACPIMadtNMIParams Params;
+ PARAMS(X86ACPIMadtNMI);
+
struct M5_ATTR_PACKED Mem : public Record::Mem
{
- Mem() : Record::Mem(3, sizeof(Mem)) {}
-
uint8_t acpiProcessorId = 0;
uint16_t flags = 0;
uint8_t lintNo = 0;
@@ -329,61 +307,48 @@
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- Record::Mem const& data() const override { return d; }
-
- private:
- Mem d;
+ void prepareBuf(std::vector<uint8_t>& mem) const override;
public:
- NMI(const Params& p);
+ NMI(const Params& p) : Record(p, 3) {}
};
class LAPICOverride : public Record
{
protected:
- typedef X86ACPIMadtLAPICOverrideParams Params;
+ PARAMS(X86ACPIMadtLAPICOverride);
+
struct M5_ATTR_PACKED Mem : public Record::Mem
{
- Mem() : Record::Mem(5, sizeof(Mem)) {}
-
uint16_t _reserved = 0;
uint64_t localAPICAddress = 0;
};
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
- Record::Mem const& data() const override { return d; }
-
- private:
- Mem d;
+ void prepareBuf(std::vector<uint8_t>& mem) const override;
public:
- LAPICOverride(const Params& p);
+ LAPICOverride(const Params& p) : Record(p, 5) {}
};
class MADT : public SysDescTable
{
protected:
- typedef X86ACPIMadtParams Params;
+ PARAMS(X86ACPIMadt);
struct M5_ATTR_PACKED Mem : public SysDescTable::Mem
{
uint32_t localAPICAddress = 0;
uint32_t flags = 0;
-
- using SysDescTable::Mem::Mem;
};
static_assert(std::is_trivially_copyable<Mem>::value,
"Type not suitable for memcpy.");
std::vector<Record *> records;
- void prepare_self(std::vector<uint8_t>& mem) const override;
-
- std::tuple<SysDescTable::Mem const*, std::size_t> data() const
override;
-
- private:
- Mem _data;
+ Addr writeBuf(PortProxy& phys_proxy, Allocator& alloc,
+ std::vector<uint8_t>& mem) const override;
public:
MADT(const Params &p);
--
To view, visit https://gem5-review.googlesource.com/c/public/gem5/+/44146
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: develop
Gerrit-Change-Id: I1ee08854d1c81925e4da145bf4c9bd3cefc7458a
Gerrit-Change-Number: 44146
Gerrit-PatchSet: 1
Gerrit-Owner: Gabe Black <[email protected]>
Gerrit-MessageType: newchange
_______________________________________________
gem5-dev mailing list -- [email protected]
To unsubscribe send an email to [email protected]
%(web_page_url)slistinfo%(cgiext)s/%(_internal_name)s
