basic.isa revision 10196:be0e1724eb39 
1// Copyright (c) 2006-2007 The Regents of The University of Michigan
2// All rights reserved.
3//
4// Redistribution and use in source and binary forms, with or without
5// modification, are permitted provided that the following conditions are
6// met: redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer;
8// redistributions in binary form must reproduce the above copyright
9// notice, this list of conditions and the following disclaimer in the
10// documentation and/or other materials provided with the distribution;
11// neither the name of the copyright holders nor the names of its
12// contributors may be used to endorse or promote products derived from
13// this software without specific prior written permission.
14//
15// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26//
27// Authors: Ali Saidi
28//          Gabe Black
29//          Steve Reinhardt
30
31// Declarations for execute() methods.
32def template BasicExecDeclare {{
33        Fault execute(%(CPU_exec_context)s *, Trace::InstRecord *) const;
34}};
35
36def template DoFpOpDeclare {{
37        Fault doFpOp(%(CPU_exec_context)s *, Trace::InstRecord *)
38            const M5_NO_INLINE;
39}};
40
41// Definitions of execute methods that panic.
42def template BasicExecPanic {{
43        Fault
44        execute(%(CPU_exec_context)s *, Trace::InstRecord *) const
45        {
46            panic("Execute method called when it shouldn't!");
47            M5_DUMMY_RETURN
48        }
49}};
50
51// Basic instruction class declaration template.
52def template BasicDeclare {{
53        /**
54         * Static instruction class for "%(mnemonic)s".
55         */
56        class %(class_name)s : public %(base_class)s
57        {
58          public:
59            // Constructor.
60            %(class_name)s(ExtMachInst machInst);
61            %(BasicExecDeclare)s
62        };
63}};
64
65// Basic instruction class declaration template.
66def template FpBasicDeclare {{
67        /**
68         * Static instruction class for "%(mnemonic)s".
69         */
70        class %(class_name)s : public %(base_class)s
71        {
72          public:
73            // Constructor.
74            %(class_name)s(ExtMachInst machInst);
75            %(BasicExecDeclare)s
76            %(DoFpOpDeclare)s
77        };
78}};
79
80// Basic instruction class declaration template.
81def template BasicDeclareWithMnemonic {{
82        /**
83         * Static instruction class for "%(mnemonic)s".
84         */
85        class %(class_name)s : public %(base_class)s
86        {
87          public:
88            // Constructor.
89            %(class_name)s(const char * mnemonic, ExtMachInst machInst);
90            %(BasicExecDeclare)s
91        };
92}};
93
94// Basic instruction class constructor template.
95def template BasicConstructor {{
96        %(class_name)s::%(class_name)s(ExtMachInst machInst)
97            : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s)
98        {
99                %(constructor)s;
100        }
101}};
102
103// Basic instruction class constructor template.
104def template BasicConstructorWithMnemonic {{
105        %(class_name)s::%(class_name)s(const char * mnemonic,
106                ExtMachInst machInst)
107            : %(base_class)s(mnemonic, machInst, %(op_class)s)
108        {
109                %(constructor)s;
110        }
111}};
112
113// Basic instruction class execute method template.
114def template BasicExecute {{
115        Fault
116        %(class_name)s::execute(CPU_EXEC_CONTEXT *xc,
117                Trace::InstRecord *traceData) const
118        {
119            Fault fault = NoFault;
120
121            %(fp_enable_check)s;
122            %(op_decl)s;
123            %(op_rd)s;
124            %(code)s;
125
126            if (fault == NoFault) {
127                %(op_wb)s;
128            }
129            return fault;
130        }
131}};
132
133def template DoFpOpExecute {{
134        Fault
135        %(class_name)s::doFpOp(CPU_EXEC_CONTEXT *xc,
136                Trace::InstRecord *traceData) const
137        {
138            Fault fault = NoFault;
139            %(op_decl)s;
140            %(op_rd)s;
141            %(fp_code)s;
142            if (fault == NoFault) {
143                %(op_wb)s;
144            }
145            return fault;
146        }
147}};
148
149// Basic decode template.
150def template BasicDecode {{
151        return new %(class_name)s(machInst);
152}};
153
154// Basic decode template, passing mnemonic in as string arg to constructor.
155def template BasicDecodeWithMnemonic {{
156    return new %(class_name)s("%(mnemonic)s", machInst);
157}};
158
159// The most basic instruction format... used only for a few misc. insts
160def format BasicOperate(code, *flags) {{
161        code = filterDoubles(code)
162        iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags)
163        header_output = BasicDeclare.subst(iop)
164        decoder_output = BasicConstructor.subst(iop)
165        decode_block = BasicDecode.subst(iop)
166        exec_output = BasicExecute.subst(iop)
167}};
168
169def format FpBasic(code, *flags) {{
170    exec_code = """
171    Fsr |= bits(Fsr, 4, 0) << 5;
172    Fsr = insertBits(Fsr, 4, 0, 0);
173    int newrnd = M5_FE_TONEAREST;
174    switch (Fsr<31:30>) {
175      case 0: newrnd = M5_FE_TONEAREST; break;
176      case 1: newrnd = M5_FE_TOWARDZERO; break;
177      case 2: newrnd = M5_FE_UPWARD; break;
178      case 3: newrnd = M5_FE_DOWNWARD; break;
179    }
180    int oldrnd = m5_fegetround();
181    m5_fesetround(newrnd);
182    __asm__ __volatile__("" ::: "memory");
183    fault = doFpOp(xc, traceData);
184    __asm__ __volatile__("" ::: "memory");
185    m5_fesetround(oldrnd);
186    return fault;
187"""
188    fp_code = filterDoubles(code)
189    iop = InstObjParams(name, Name, 'SparcStaticInst',
190            { "code" : exec_code, "fp_code" : fp_code }, flags)
191    header_output = FpBasicDeclare.subst(iop)
192    decoder_output = BasicConstructor.subst(iop)
193    decode_block = BasicDecode.subst(iop)
194    exec_output = BasicExecute.subst(iop)
195    exec_output += DoFpOpExecute.subst(iop)
196}};
197