1/*
2 * Copyright (c) 1997, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25#ifndef SHARE_VM_OPTO_CONNODE_HPP
26#define SHARE_VM_OPTO_CONNODE_HPP
27
28#include "opto/node.hpp"
29#include "opto/opcodes.hpp"
30#include "opto/type.hpp"
31
32class PhaseTransform;
33class MachNode;
34
35//------------------------------ConNode----------------------------------------
36// Simple constants
37class ConNode : public TypeNode {
38public:
39  ConNode( const Type *t ) : TypeNode(t->remove_speculative(),1) {
40    init_req(0, (Node*)Compile::current()->root());
41    init_flags(Flag_is_Con);
42  }
43  virtual int  Opcode() const;
44  virtual uint hash() const;
45  virtual const RegMask &out_RegMask() const { return RegMask::Empty; }
46  virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; }
47
48  // Polymorphic factory method:
49  static ConNode* make(const Type *t);
50};
51
52//------------------------------ConINode---------------------------------------
53// Simple integer constants
54class ConINode : public ConNode {
55public:
56  ConINode( const TypeInt *t ) : ConNode(t) {}
57  virtual int Opcode() const;
58
59  // Factory method:
60  static ConINode* make(int con) {
61    return new ConINode( TypeInt::make(con) );
62  }
63
64};
65
66//------------------------------ConPNode---------------------------------------
67// Simple pointer constants
68class ConPNode : public ConNode {
69public:
70  ConPNode( const TypePtr *t ) : ConNode(t) {}
71  virtual int Opcode() const;
72
73  // Factory methods:
74  static ConPNode* make(address con) {
75    if (con == NULL)
76      return new ConPNode( TypePtr::NULL_PTR ) ;
77    else
78      return new ConPNode( TypeRawPtr::make(con) );
79  }
80};
81
82
83//------------------------------ConNNode--------------------------------------
84// Simple narrow oop constants
85class ConNNode : public ConNode {
86public:
87  ConNNode( const TypeNarrowOop *t ) : ConNode(t) {}
88  virtual int Opcode() const;
89};
90
91//------------------------------ConNKlassNode---------------------------------
92// Simple narrow klass constants
93class ConNKlassNode : public ConNode {
94public:
95  ConNKlassNode( const TypeNarrowKlass *t ) : ConNode(t) {}
96  virtual int Opcode() const;
97};
98
99
100//------------------------------ConLNode---------------------------------------
101// Simple long constants
102class ConLNode : public ConNode {
103public:
104  ConLNode( const TypeLong *t ) : ConNode(t) {}
105  virtual int Opcode() const;
106
107  // Factory method:
108  static ConLNode* make(jlong con) {
109    return new ConLNode( TypeLong::make(con) );
110  }
111
112};
113
114//------------------------------ConFNode---------------------------------------
115// Simple float constants
116class ConFNode : public ConNode {
117public:
118  ConFNode( const TypeF *t ) : ConNode(t) {}
119  virtual int Opcode() const;
120
121  // Factory method:
122  static ConFNode* make(float con) {
123    return new ConFNode( TypeF::make(con) );
124  }
125
126};
127
128//------------------------------ConDNode---------------------------------------
129// Simple double constants
130class ConDNode : public ConNode {
131public:
132  ConDNode( const TypeD *t ) : ConNode(t) {}
133  virtual int Opcode() const;
134
135  // Factory method:
136  static ConDNode* make(double con) {
137    return new ConDNode( TypeD::make(con) );
138  }
139
140};
141
142//------------------------------ThreadLocalNode--------------------------------
143// Ideal Node which returns the base of ThreadLocalStorage.
144class ThreadLocalNode : public Node {
145public:
146    ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {}
147    virtual int Opcode() const;
148    virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;}
149    virtual uint ideal_reg() const { return Op_RegP; }
150};
151
152
153
154#endif // SHARE_VM_OPTO_CONNODE_HPP
155