basic.isa (12236:126ac9da6050) basic.isa (12275:4b4dd932c710)
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

--- 16 unchanged lines hidden (view full) ---

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 {{
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

--- 16 unchanged lines hidden (view full) ---

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 };
33/**
34 * Static instruction class for "%(mnemonic)s".
35 */
36class %(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 {{
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 };
47/**
48 * Static instruction class for "%(mnemonic)s".
49 */
50class %(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 *, Trace::InstRecord *) const M5_NO_INLINE;
57};
59}};
60
61// Basic instruction class declaration template.
62def template BasicDeclareWithMnemonic {{
58}};
59
60// Basic instruction class declaration template.
61def 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 };
62/**
63 * Static instruction class for "%(mnemonic)s".
64 */
65class %(class_name)s : public %(base_class)s
66{
67 public:
68 // Constructor.
69 %(class_name)s(const char *mnemonic, ExtMachInst machInst);
70 Fault execute(ExecContext *, Trace::InstRecord *) const;
71};
73}};
74
75// Basic instruction class constructor template.
76def template BasicConstructor {{
72}};
73
74// Basic instruction class constructor template.
75def 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 }
76%(class_name)s::%(class_name)s(ExtMachInst machInst) :
77 %(base_class)s("%(mnemonic)s", machInst, %(op_class)s)
78{
79 %(constructor)s;
80}
82}};
83
84// Basic instruction class constructor template.
85def template BasicConstructorWithMnemonic {{
81}};
82
83// Basic instruction class constructor template.
84def 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 }
85%(class_name)s::%(class_name)s(const char *mnemonic, ExtMachInst machInst) :
86 %(base_class)s(mnemonic, machInst, %(op_class)s)
87{
88 %(constructor)s;
89}
92}};
93
94// Basic instruction class execute method template.
95def template BasicExecute {{
90}};
91
92// Basic instruction class execute method template.
93def template BasicExecute {{
96 Fault
97 %(class_name)s::execute(ExecContext *xc,
98 Trace::InstRecord *traceData) const
99 {
100 Fault fault = NoFault;
94Fault
95%(class_name)s::execute(ExecContext *xc,
96 Trace::InstRecord *traceData) const
97{
98 Fault fault = NoFault;
101
99
102 %(fp_enable_check)s;
103 %(op_decl)s;
104 %(op_rd)s;
105 %(code)s;
100 %(fp_enable_check)s;
101 %(op_decl)s;
102 %(op_rd)s;
103 %(code)s;
106
104
107 if (fault == NoFault) {
108 %(op_wb)s;
109 }
110 return fault;
111 }
105 if (fault == NoFault) {
106 %(op_wb)s;
107 }
108 return fault;
109}
112}};
113
114def template DoFpOpExecute {{
110}};
111
112def 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 }
113Fault
114%(class_name)s::doFpOp(ExecContext *xc, Trace::InstRecord *traceData) const
115{
116 Fault fault = NoFault;
117 %(op_decl)s;
118 %(op_rd)s;
119 %(fp_code)s;
120 if (fault == NoFault) {
121 %(op_wb)s;
122 }
123 return fault;
124}
128}};
129
130// Basic decode template.
131def template BasicDecode {{
125}};
126
127// Basic decode template.
128def template BasicDecode {{
132 return new %(class_name)s(machInst);
129return new %(class_name)s(machInst);
133}};
134
135// Basic decode template, passing mnemonic in as string arg to constructor.
136def template BasicDecodeWithMnemonic {{
130}};
131
132// Basic decode template, passing mnemonic in as string arg to constructor.
133def template BasicDecodeWithMnemonic {{
137 return new %(class_name)s("%(mnemonic)s", machInst);
134return 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) {{
135}};
136
137// The most basic instruction format... used only for a few misc. insts
138def 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)
139 code = filterDoubles(code)
140 iop = InstObjParams(name, Name, 'SparcStaticInst', code, flags)
141 header_output = BasicDeclare.subst(iop)
142 decoder_output = BasicConstructor.subst(iop)
143 decode_block = BasicDecode.subst(iop)
144 exec_output = BasicExecute.subst(iop)
145
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>) {

--- 7 unchanged lines hidden (view full) ---

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',
146}};
147
148def format FpBasic(code, *flags) {{
149 exec_code = """
150 Fsr |= bits(Fsr, 4, 0) << 5;
151 Fsr = insertBits(Fsr, 4, 0, 0);
152 int newrnd = M5_FE_TONEAREST;
153 switch (Fsr<31:30>) {

--- 7 unchanged lines hidden (view full) ---

161 __asm__ __volatile__("" ::: "memory");
162 fault = doFpOp(xc, traceData);
163 __asm__ __volatile__("" ::: "memory");
164 m5_fesetround(oldrnd);
165 return fault;
166"""
167 fp_code = filterDoubles(code)
168 iop = InstObjParams(name, Name, 'SparcStaticInst',
171 { "code" : exec_code, "fp_code" : fp_code }, flags)
169 { "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}};
170 header_output = FpBasicDeclare.subst(iop)
171 decoder_output = BasicConstructor.subst(iop)
172 decode_block = BasicDecode.subst(iop)
173 exec_output = BasicExecute.subst(iop)
174 exec_output += DoFpOpExecute.subst(iop)
175}};