mem.isa revision 2239 
1// -*- mode:c++ -*-
2
3// Copyright (c) 2003-2005 The Regents of The University of Michigan
4// All rights reserved.
5//
6// Redistribution and use in source and binary forms, with or without
7// modification, are permitted provided that the following conditions are
8// met: redistributions of source code must retain the above copyright
9// notice, this list of conditions and the following disclaimer;
10// redistributions in binary form must reproduce the above copyright
11// notice, this list of conditions and the following disclaimer in the
12// documentation and/or other materials provided with the distribution;
13// neither the name of the copyright holders nor the names of its
14// contributors may be used to endorse or promote products derived from
15// this software without specific prior written permission.
16//
17// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28
29output header {{
30    /**
31     * Base class for general Mips memory-format instructions.
32     */
33    class Memory : public MipsStaticInst
34    {
35      protected:
36
37        /// Memory request flags.  See mem_req_base.hh.
38        unsigned memAccessFlags;
39        /// Pointer to EAComp object.
40        const StaticInstPtr eaCompPtr;
41        /// Pointer to MemAcc object.
42        const StaticInstPtr memAccPtr;
43
44        /// Displacement for EA calculation (signed).
45        int32_t disp;
46
47        /// Constructor
48        Memory(const char *mnem, MachInst _machInst, OpClass __opClass,
49               StaticInstPtr _eaCompPtr = nullStaticInstPtr,
50               StaticInstPtr _memAccPtr = nullStaticInstPtr)
51            : MipsStaticInst(mnem, _machInst, __opClass),
52              memAccessFlags(0), eaCompPtr(_eaCompPtr), memAccPtr(_memAccPtr),
53              disp(OFFSET)
54        {
55            //If Bit 15 is 1 then Sign Extend
56            int32_t temp = disp & 0x00008000;
57
58            if (temp > 0) {
59                disp |= 0xFFFF0000;
60            }
61        }
62
63        std::string
64        generateDisassembly(Addr pc, const SymbolTable *symtab) const;
65
66      public:
67
68        const StaticInstPtr &eaCompInst() const { return eaCompPtr; }
69        const StaticInstPtr &memAccInst() const { return memAccPtr; }
70    };
71
72}};
73
74
75output decoder {{
76    std::string
77    Memory::generateDisassembly(Addr pc, const SymbolTable *symtab) const
78    {
79        return csprintf("%-10s %c%d,%d(r%d)", mnemonic,
80                        flags[IsFloating] ? 'f' : 'r', RT, disp, RS);
81    }
82
83}};
84
85def format LoadAddress(code) {{
86    iop = InstObjParams(name, Name, 'MemoryDisp32', CodeBlock(code))
87    header_output = BasicDeclare.subst(iop)
88    decoder_output = BasicConstructor.subst(iop)
89    decode_block = BasicDecode.subst(iop)
90    exec_output = BasicExecute.subst(iop)
91}};
92
93
94def template LoadStoreDeclare {{
95    /**
96     * Static instruction class for "%(mnemonic)s".
97     */
98    class %(class_name)s : public %(base_class)s
99    {
100      protected:
101
102        /**
103         * "Fake" effective address computation class for "%(mnemonic)s".
104         */
105        class EAComp : public %(base_class)s
106        {
107          public:
108            /// Constructor
109            EAComp(MachInst machInst);
110
111            %(BasicExecDeclare)s
112        };
113
114        /**
115         * "Fake" memory access instruction class for "%(mnemonic)s".
116         */
117        class MemAcc : public %(base_class)s
118        {
119          public:
120            /// Constructor
121            MemAcc(MachInst machInst);
122
123            %(BasicExecDeclare)s
124        };
125
126      public:
127
128        /// Constructor.
129        %(class_name)s(MachInst machInst);
130
131        %(BasicExecDeclare)s
132
133        %(InitiateAccDeclare)s
134
135        %(CompleteAccDeclare)s
136    };
137}};
138
139
140def template InitiateAccDeclare {{
141    Fault initiateAcc(%(CPU_exec_context)s *, Trace::InstRecord *) const;
142}};
143
144
145def template CompleteAccDeclare {{
146    Fault completeAcc(uint8_t *, %(CPU_exec_context)s *, Trace::InstRecord *) const;
147}};
148
149
150def template LoadStoreConstructor {{
151    /** TODO: change op_class to AddrGenOp or something (requires
152     * creating new member of OpClass enum in op_class.hh, updating
153     * config files, etc.). */
154    inline %(class_name)s::EAComp::EAComp(MachInst machInst)
155        : %(base_class)s("%(mnemonic)s (EAComp)", machInst, IntAluOp)
156    {
157        %(ea_constructor)s;
158    }
159
160    inline %(class_name)s::MemAcc::MemAcc(MachInst machInst)
161        : %(base_class)s("%(mnemonic)s (MemAcc)", machInst, %(op_class)s)
162    {
163        %(memacc_constructor)s;
164    }
165
166    inline %(class_name)s::%(class_name)s(MachInst machInst)
167         : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s,
168                          new EAComp(machInst), new MemAcc(machInst))
169    {
170        %(constructor)s;
171    }
172}};
173
174
175def template EACompExecute {{
176    Fault
177    %(class_name)s::EAComp::execute(%(CPU_exec_context)s *xc,
178                                   Trace::InstRecord *traceData) const
179    {
180        Addr EA;
181        Fault fault = NoFault;
182
183        %(fp_enable_check)s;
184        %(op_decl)s;
185        %(op_rd)s;
186        %(code)s;
187
188        if (fault == NoFault) {
189            %(op_wb)s;
190            xc->setEA(EA);
191        }
192
193        return fault;
194    }
195}};
196
197def template LoadMemAccExecute {{
198    Fault
199    %(class_name)s::MemAcc::execute(%(CPU_exec_context)s *xc,
200                                   Trace::InstRecord *traceData) const
201    {
202        Addr EA;
203        Fault fault = NoFault;
204
205        %(fp_enable_check)s;
206        %(op_decl)s;
207        %(op_rd)s;
208        EA = xc->getEA();
209
210        if (fault == NoFault) {
211            fault = xc->read(EA, (uint%(mem_acc_size)d_t&)Mem, memAccessFlags);
212            %(code)s;
213        }
214
215        if (fault == NoFault) {
216            %(op_wb)s;
217        }
218
219        return fault;
220    }
221}};
222
223
224def template LoadExecute {{
225    Fault %(class_name)s::execute(%(CPU_exec_context)s *xc,
226                                  Trace::InstRecord *traceData) const
227    {
228        Addr EA;
229        Fault fault = NoFault;
230
231        %(fp_enable_check)s;
232        %(op_decl)s;
233        %(op_rd)s;
234        %(ea_code)s;
235
236        if (fault == NoFault) {
237            fault = xc->read(EA, (uint%(mem_acc_size)d_t&)Mem, memAccessFlags);
238            %(memacc_code)s;
239        }
240
241        if (fault == NoFault) {
242            %(op_wb)s;
243        }
244
245        return fault;
246    }
247}};
248
249
250def template LoadInitiateAcc {{
251    Fault %(class_name)s::initiateAcc(%(CPU_exec_context)s *xc,
252                                      Trace::InstRecord *traceData) const
253    {
254        Addr EA;
255        Fault fault = NoFault;
256
257        %(fp_enable_check)s;
258        %(op_src_decl)s;
259        %(op_rd)s;
260        %(ea_code)s;
261
262        if (fault == NoFault) {
263            fault = xc->read(EA, (uint%(mem_acc_size)d_t &)Mem, memAccessFlags);
264        }
265
266        return fault;
267    }
268}};
269
270
271def template LoadCompleteAcc {{
272    Fault %(class_name)s::completeAcc(uint8_t *data,
273                                      %(CPU_exec_context)s *xc,
274                                      Trace::InstRecord *traceData) const
275    {
276        Fault fault = NoFault;
277
278        %(fp_enable_check)s;
279        %(op_src_decl)s;
280        %(op_dest_decl)s;
281
282        memcpy(&Mem, data, sizeof(Mem));
283
284        if (fault == NoFault) {
285            %(memacc_code)s;
286        }
287
288        if (fault == NoFault) {
289            %(op_wb)s;
290        }
291
292        return fault;
293    }
294}};
295
296
297def template StoreMemAccExecute {{
298    Fault
299    %(class_name)s::MemAcc::execute(%(CPU_exec_context)s *xc,
300                                   Trace::InstRecord *traceData) const
301    {
302        Addr EA;
303        Fault fault = NoFault;
304        uint64_t write_result = 0;
305
306        %(fp_enable_check)s;
307        %(op_decl)s;
308        %(op_rd)s;
309        EA = xc->getEA();
310
311        if (fault == NoFault) {
312            %(code)s;
313        }
314
315        if (fault == NoFault) {
316            fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA,
317                              memAccessFlags, &write_result);
318            if (traceData) { traceData->setData(Mem); }
319        }
320
321        if (fault == NoFault) {
322            %(postacc_code)s;
323        }
324
325        if (fault == NoFault) {
326            %(op_wb)s;
327        }
328
329        return fault;
330    }
331}};
332
333
334def template StoreExecute {{
335    Fault %(class_name)s::execute(%(CPU_exec_context)s *xc,
336                                  Trace::InstRecord *traceData) const
337    {
338        Addr EA;
339        Fault fault = NoFault;
340        uint64_t write_result = 0;
341
342        %(fp_enable_check)s;
343        %(op_decl)s;
344        %(op_rd)s;
345        %(ea_code)s;
346
347        if (fault == NoFault) {
348            %(memacc_code)s;
349        }
350
351        if (fault == NoFault) {
352            fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA,
353                              memAccessFlags, &write_result);
354            if (traceData) { traceData->setData(Mem); }
355        }
356
357        if (fault == NoFault) {
358            %(postacc_code)s;
359        }
360
361        if (fault == NoFault) {
362            %(op_wb)s;
363        }
364
365        return fault;
366    }
367}};
368
369def template StoreInitiateAcc {{
370    Fault %(class_name)s::initiateAcc(%(CPU_exec_context)s *xc,
371                                      Trace::InstRecord *traceData) const
372    {
373        Addr EA;
374        Fault fault = NoFault;
375        uint64_t write_result = 0;
376
377        %(fp_enable_check)s;
378        %(op_src_decl)s;
379        %(op_dest_decl)s;
380        %(op_rd)s;
381        %(ea_code)s;
382
383        if (fault == NoFault) {
384            %(memacc_code)s;
385        }
386
387        if (fault == NoFault) {
388            fault = xc->write((uint%(mem_acc_size)d_t&)Mem, EA,
389                              memAccessFlags, &write_result);
390            if (traceData) { traceData->setData(Mem); }
391        }
392
393        return fault;
394    }
395}};
396
397
398def template StoreCompleteAcc {{
399    Fault %(class_name)s::completeAcc(uint8_t *data,
400                                      %(CPU_exec_context)s *xc,
401                                      Trace::InstRecord *traceData) const
402    {
403        Fault fault = NoFault;
404        uint64_t write_result = 0;
405
406        %(fp_enable_check)s;
407        %(op_dest_decl)s;
408
409        memcpy(&write_result, data, sizeof(write_result));
410
411        if (fault == NoFault) {
412            %(postacc_code)s;
413        }
414
415        if (fault == NoFault) {
416            %(op_wb)s;
417        }
418
419        return fault;
420    }
421}};
422
423// load instructions use Rt as dest, so check for
424// Rt == 31 to detect nops
425def template LoadNopCheckDecode {{
426 {
427     MipsStaticInst *i = new %(class_name)s(machInst);
428     if (RT == 0) {
429         i = makeNop(i);
430     }
431     return i;
432 }
433}};
434
435def format LoadMemory(memacc_code, ea_code = {{ EA = Rs + disp; }},
436                     mem_flags = [], inst_flags = []) {{
437    (header_output, decoder_output, decode_block, exec_output) = \
438        LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags,
439                      decode_template = LoadNopCheckDecode,
440                      exec_template_base = 'Load')
441}};
442
443
444def format StoreMemory(memacc_code, ea_code = {{ EA = Rs + disp; }},
445                     mem_flags = [], inst_flags = []) {{
446    (header_output, decoder_output, decode_block, exec_output) = \
447        LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags,
448                      exec_template_base = 'Store')
449}};
450
451//FP loads are offloaded to these formats for now ...
452def format LoadMemory2(ea_code = {{ EA = Rs + disp; }}, memacc_code = {{ }},
453                      mem_flags = [], inst_flags = []) {{
454    (header_output, decoder_output, decode_block, exec_output) = \
455        LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags,
456                      decode_template = LoadNopCheckDecode,
457                      exec_template_base = 'Load')
458}};
459
460
461//FP stores are offloaded to these formats for now ...
462def format StoreMemory2(ea_code = {{ EA = Rs + disp; }},memacc_code = {{ }},
463                      mem_flags = [], inst_flags = []) {{
464    (header_output, decoder_output, decode_block, exec_output) = \
465        LoadStoreBase(name, Name, ea_code, memacc_code, mem_flags, inst_flags,
466                      decode_template = LoadNopCheckDecode,
467                      exec_template_base = 'Store')
468}};
469
470