basic.isa revision 12236:126ac9da6050 
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// Basic instruction class declaration template.
32def template BasicDeclare {{
33        /**
34         * Static instruction class for "%(mnemonic)s".
35         */
36        class %(class_name)s : public %(base_class)s
37        {
38          public:
39            // Constructor.
40            %(class_name)s(ExtMachInst machInst);
41            Fault execute(ExecContext *, Trace::InstRecord *) const;
42        };
43}};
44
45// Basic instruction class declaration template.
46def template FpBasicDeclare {{
47        /**
48         * Static instruction class for "%(mnemonic)s".
49         */
50        class %(class_name)s : public %(base_class)s
51        {
52          public:
53            // Constructor.
54            %(class_name)s(ExtMachInst machInst);
55            Fault execute(ExecContext *, Trace::InstRecord *) const;
56            Fault doFpOp(ExecContext *,
57                         Trace::InstRecord *) const M5_NO_INLINE;
58        };
59}};
60
61// Basic instruction class declaration template.
62def template BasicDeclareWithMnemonic {{
63        /**
64         * Static instruction class for "%(mnemonic)s".
65         */
66        class %(class_name)s : public %(base_class)s
67        {
68          public:
69            // Constructor.
70            %(class_name)s(const char * mnemonic, ExtMachInst machInst);
71            Fault execute(ExecContext *, Trace::InstRecord *) const;
72        };
73}};
74
75// Basic instruction class constructor template.
76def template BasicConstructor {{
77        %(class_name)s::%(class_name)s(ExtMachInst machInst)
78            : %(base_class)s("%(mnemonic)s", machInst, %(op_class)s)
79        {
80                %(constructor)s;
81        }
82}};
83
84// Basic instruction class constructor template.
85def template BasicConstructorWithMnemonic {{
86        %(class_name)s::%(class_name)s(const char * mnemonic,
87                ExtMachInst machInst)
88            : %(base_class)s(mnemonic, machInst, %(op_class)s)
89        {
90                %(constructor)s;
91        }
92}};
93
94// Basic instruction class execute method template.
95def template BasicExecute {{
96        Fault
97        %(class_name)s::execute(ExecContext *xc,
98                Trace::InstRecord *traceData) const
99        {
100            Fault fault = NoFault;
101
102            %(fp_enable_check)s;
103            %(op_decl)s;
104            %(op_rd)s;
105            %(code)s;
106
107            if (fault == NoFault) {
108                %(op_wb)s;
109            }
110            return fault;
111        }
112}};
113
114def template DoFpOpExecute {{
115        Fault
116        %(class_name)s::doFpOp(ExecContext *xc,
117                Trace::InstRecord *traceData) const
118        {
119            Fault fault = NoFault;
120            %(op_decl)s;
121            %(op_rd)s;
122            %(fp_code)s;
123            if (fault == NoFault) {
124                %(op_wb)s;
125            }
126            return fault;
127        }
128}};
129
130// Basic decode template.
131def template BasicDecode {{
132        return new %(class_name)s(machInst);
133}};
134
135// Basic decode template, passing mnemonic in as string arg to constructor.
136def template BasicDecodeWithMnemonic {{
137    return new %(class_name)s("%(mnemonic)s", machInst);
138}};
139
140// The most basic instruction format... used only for a few misc. insts
141def format BasicOperate(code, *flags) {{
142        code = filterDoubles(code)
143        iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags)
144        header_output = BasicDeclare.subst(iop)
145        decoder_output = BasicConstructor.subst(iop)
146        decode_block = BasicDecode.subst(iop)
147        exec_output = BasicExecute.subst(iop)
148}};
149
150def format FpBasic(code, *flags) {{
151    exec_code = """
152    Fsr |= bits(Fsr, 4, 0) << 5;
153    Fsr = insertBits(Fsr, 4, 0, 0);
154    int newrnd = M5_FE_TONEAREST;
155    switch (Fsr<31:30>) {
156      case 0: newrnd = M5_FE_TONEAREST; break;
157      case 1: newrnd = M5_FE_TOWARDZERO; break;
158      case 2: newrnd = M5_FE_UPWARD; break;
159      case 3: newrnd = M5_FE_DOWNWARD; break;
160    }
161    int oldrnd = m5_fegetround();
162    m5_fesetround(newrnd);
163    __asm__ __volatile__("" ::: "memory");
164    fault = doFpOp(xc, traceData);
165    __asm__ __volatile__("" ::: "memory");
166    m5_fesetround(oldrnd);
167    return fault;
168"""
169    fp_code = filterDoubles(code)
170    iop = InstObjParams(name, Name, 'SparcStaticInst',
171            { "code" : exec_code, "fp_code" : fp_code }, flags)
172    header_output = FpBasicDeclare.subst(iop)
173    decoder_output = BasicConstructor.subst(iop)
174    decode_block = BasicDecode.subst(iop)
175    exec_output = BasicExecute.subst(iop)
176    exec_output += DoFpOpExecute.subst(iop)
177}};
178