-
Notifications
You must be signed in to change notification settings - Fork 392
/
BinaryCommutativeAnalyser.hpp
134 lines (114 loc) · 6.21 KB
/
BinaryCommutativeAnalyser.hpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*******************************************************************************
* Copyright (c) 2000, 2020 IBM Corp. and others
*
* This program and the accompanying materials are made available under
* the terms of the Eclipse Public License 2.0 which accompanies this
* distribution and is available at http://eclipse.org/legal/epl-2.0
* or the Apache License, Version 2.0 which accompanies this distribution
* and is available at https://www.apache.org/licenses/LICENSE-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License, v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception [1] and GNU General Public
* License, version 2 with the OpenJDK Assembly Exception [2].
*
* [1] https://www.gnu.org/software/classpath/license.html
* [2] http://openjdk.java.net/legal/assembly-exception.html
*
* SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 OR GPL-2.0 WITH Classpath-exception-2.0 OR LicenseRef-GPL-2.0 WITH Assembly-exception
*******************************************************************************/
#ifndef IA32BINARYCOMMUTATIVEANALYSER_INCL
#define IA32BINARYCOMMUTATIVEANALYSER_INCL
#include <stdint.h>
#include "codegen/Analyser.hpp"
#include "codegen/CodeGenerator.hpp"
#include "codegen/InstOpCode.hpp"
namespace TR { class Machine; }
namespace TR { class Node; }
#define EvalChild1 0x01
#define EvalChild2 0x02
#define CopyReg1 0x04
#define CopyReg2 0x08
#define OpReg1Reg2 0x10
#define OpReg2Reg1 0x20
#define OpReg1Mem2 0x40
#define OpReg2Mem1 0x80
class TR_X86BinaryCommutativeAnalyser : public TR_Analyser
{
static const uint8_t _actionMap[NUM_ACTIONS];
TR::CodeGenerator *_cg;
bool _reversedOperands;
TR::Machine *_machine;
public:
TR_X86BinaryCommutativeAnalyser(TR::CodeGenerator *cg)
: _cg(cg),
_machine(cg->machine()),
_reversedOperands(false)
{}
void genericAnalyserWithExplicitOperands(TR::Node *root,
TR::Node *firstChild,
TR::Node *secondChild,
TR_X86OpCodes regRegOpCode,
TR_X86OpCodes regMemOpCode,
TR_X86OpCodes copyOpCode,
bool nonClobberingDestination = false);
void genericAnalyser(TR::Node *root,
TR_X86OpCodes regRegOpCode,
TR_X86OpCodes regMemOpCode,
TR_X86OpCodes copyOpCode,
bool nonClobberingDestination = false);
TR::Register *genericAnalyserImpl(TR::Node *root,
TR::Node *firstChild,
TR::Node *secondChild,
TR_X86OpCodes regRegOpCode,
TR_X86OpCodes regMemOpCode,
TR_X86OpCodes copyOpCode,
bool nonClobberingDestination);
void genericLongAnalyser(TR::Node *root,
TR_X86OpCodes lowRegRegOpCode,
TR_X86OpCodes highRegRegOpCode,
TR_X86OpCodes lowRegMemOpCode,
TR_X86OpCodes lowRegMemOpCode2Byte,
TR_X86OpCodes lowRegMemOpCode1Byte,
TR_X86OpCodes highRegMemOpCode,
TR_X86OpCodes copyOpCode);
void integerAddAnalyser(TR::Node *root,
TR_X86OpCodes regRegOpCode,
TR_X86OpCodes regMemOpCode,
bool needsEflags = false,
TR::Node *carry = 0);// 0 by default
void integerAddAnalyserWithExplicitOperands(TR::Node *root,
TR::Node *firstChild,
TR::Node *secondChild,
TR_X86OpCodes regRegOpCode,
TR_X86OpCodes regMemOpCode,
bool needsEflags = false,
TR::Node *carry = 0);
TR::Register* integerAddAnalyserImpl(TR::Node *root,
TR::Node *firstChild,
TR::Node *secondChild,
TR_X86OpCodes regRegOpCode,
TR_X86OpCodes regMemOpCode,
bool needsEflags,
TR::Node *carry);
void longAddAnalyserWithExplicitOperands(TR::Node *root, TR::Node *firstChild, TR::Node *secondChild);
void longAddAnalyser(TR::Node *root);
TR::Register* longAddAnalyserImpl(TR::Node *root, TR::Node *&firstChild, TR::Node *&secondChild);
void longMultiplyAnalyser(TR::Node *root);
void longDualMultiplyAnalyser(TR::Node *root);
bool getReversedOperands() {return _reversedOperands;}
bool setReversedOperands(bool b) {return (_reversedOperands = b);}
bool notReversedOperands() {return (_reversedOperands = ((_reversedOperands == false) ? true : false));}
bool getEvalChild1() {return (_actionMap[getInputs()] & EvalChild1) ? true : false;}
bool getEvalChild2() {return (_actionMap[getInputs()] & EvalChild2) ? true : false;}
bool getCopyReg1() {return (_actionMap[getInputs()] & CopyReg1) ? true : false;}
bool getCopyReg2() {return (_actionMap[getInputs()] & CopyReg2) ? true : false;}
bool getOpReg1Reg2() {return (_actionMap[getInputs()] & OpReg1Reg2) ? true : false;}
bool getOpReg2Reg1() {return (_actionMap[getInputs()] & OpReg2Reg1) ? true : false;}
bool getOpReg1Mem2() {return (_actionMap[getInputs()] & OpReg1Mem2) ? true : false;}
bool getOpReg2Mem1() {return (_actionMap[getInputs()] & OpReg2Mem1) ? true : false;}
bool getCopyRegs() {return (_actionMap[getInputs()] & (CopyReg1 | CopyReg2)) ? true : false;}
bool isVolatileMemoryOperand(TR::Node *node);
};
#endif