commentRE = re.compile(r'(^)?[^\S\n]*/(?:\*(.*?)\*/[^\S\n]*|/[^\n]*)($)?',
re.DOTALL | re.MULTILINE)
-# Regular expression object to match assignment statements
-# (used in findOperands())
-assignRE = re.compile(r'\s*=(?!=)', re.MULTILINE)
+# Regular expression object to match assignment statements (used in
+# findOperands()). If the code immediately following the first
+# appearance of the operand matches this regex, then the operand
+# appears to be on the LHS of an assignment, and is thus a
+# destination. basically we're looking for an '=' that's not '=='.
+# The heinous tangle before that handles the case where the operand
+# has an array subscript.
+assignRE = re.compile(r'(\[[^\]]+\])?\s*=(?!=)', re.MULTILINE)
def makeFlagConstructor(flag_list):
if len(flag_list) == 0:
/*
* Copyright (c) 2011 Google
+ * Copyright (c) 2015 Advanced Micro Devices, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
#ifndef __ARCH_X86_MEMHELPERS_HH__
#define __ARCH_X86_MEMHELPERS_HH__
+#include <array>
+
#include "base/types.hh"
#include "sim/byteswap.hh"
#include "sim/insttracer.hh"
return xc->initiateMemRead(addr, dataSize, flags);
}
-static inline uint64_t
-getMem(PacketPtr pkt, unsigned dataSize, Trace::InstRecord *traceData)
+static void
+getMem(PacketPtr pkt, uint64_t &mem, unsigned dataSize,
+ Trace::InstRecord *traceData)
{
- uint64_t mem;
switch (dataSize) {
case 1:
mem = pkt->get<uint8_t>();
}
if (traceData)
traceData->setData(mem);
- return mem;
}
+
+template <size_t N>
+void
+getMem(PacketPtr pkt, std::array<uint64_t, N> &mem, unsigned dataSize,
+ Trace::InstRecord *traceData)
+{
+ assert(dataSize >= 8);
+ assert((dataSize % 8) == 0);
+
+ int num_words = dataSize / 8;
+ assert(num_words <= N);
+
+ auto pkt_data = pkt->getConstPtr<const uint64_t>();
+ for (int i = 0; i < num_words; ++i)
+ mem[i] = gtoh(pkt_data[i]);
+
+ // traceData record only has space for 64 bits, so we just record
+ // the first qword
+ if (traceData)
+ traceData->setData(mem[0]);
+}
+
+
template <class XC>
Fault
readMemAtomic(XC *xc, Trace::InstRecord *traceData, Addr addr, uint64_t &mem,
return fault;
}
+template <class XC, size_t N>
+Fault
+readMemAtomic(XC *xc, Trace::InstRecord *traceData, Addr addr,
+ std::array<uint64_t, N> &mem, unsigned dataSize,
+ unsigned flags)
+{
+ assert(dataSize >= 8);
+ assert((dataSize % 8) == 0);
+
+ Fault fault = xc->readMem(addr, (uint8_t *)&mem, dataSize, flags);
+
+ if (fault == NoFault) {
+ int num_words = dataSize / 8;
+ assert(num_words <= N);
+
+ for (int i = 0; i < num_words; ++i)
+ mem[i] = gtoh(mem[i]);
+
+ if (traceData)
+ traceData->setData(mem[0]);
+ }
+ return fault;
+}
+
template <class XC>
Fault
writeMemTiming(XC *xc, Trace::InstRecord *traceData, uint64_t mem,
return xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
}
+template <class XC, size_t N>
+Fault
+writeMemTiming(XC *xc, Trace::InstRecord *traceData,
+ std::array<uint64_t, N> &mem, unsigned dataSize,
+ Addr addr, unsigned flags, uint64_t *res)
+{
+ assert(dataSize >= 8);
+ assert((dataSize % 8) == 0);
+
+ if (traceData) {
+ traceData->setData(mem[0]);
+ }
+
+ int num_words = dataSize / 8;
+ assert(num_words <= N);
+
+ for (int i = 0; i < num_words; ++i)
+ mem[i] = htog(mem[i]);
+
+ return xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
+}
+
template <class XC>
Fault
writeMemAtomic(XC *xc, Trace::InstRecord *traceData, uint64_t mem,
return fault;
}
+template <class XC, size_t N>
+Fault
+writeMemAtomic(XC *xc, Trace::InstRecord *traceData,
+ std::array<uint64_t, N> &mem, unsigned dataSize,
+ Addr addr, unsigned flags, uint64_t *res)
+{
+ if (traceData) {
+ traceData->setData(mem[0]);
+ }
+
+ int num_words = dataSize / 8;
+ assert(num_words <= N);
+
+ for (int i = 0; i < num_words; ++i)
+ mem[i] = htog(mem[i]);
+
+ Fault fault = xc->writeMem((uint8_t *)&mem, dataSize, addr, flags, res);
+
+ if (fault == NoFault && res != NULL) {
+ *res = gtoh(*res);
+ }
+
+ return fault;
+}
+
}
#endif