< prev index next >

src/hotspot/share/opto/idealKit.hpp

Print this page

  1 /*
  2  * Copyright (c) 2005, 2024, 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  *

207   Node* XorX(Node* l, Node* r) { return transform(new XorLNode(l, r)); }
208 #else // _LP64
209   Node* XorX(Node* l, Node* r) { return transform(new XorINode(l, r)); }
210 #endif // _LP64
211   Node* URShiftX(Node* l, Node* r) { return transform(new URShiftXNode(l, r)); }
212   Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
213   Node* CastPX(Node* ctl, Node* p) { return transform(new CastP2XNode(ctl, p)); }
214 
215   // Memory operations
216 
217   // This is the base version which is given an alias index.
218   Node* load(Node* ctl,
219              Node* adr,
220              const Type* t,
221              BasicType bt,
222              int adr_idx,
223              bool require_atomic_access = false,
224              MemNode::MemOrd mo = MemNode::unordered,
225              LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest);
226 



227   // Return the new StoreXNode
228   Node* store(Node* ctl,
229               Node* adr,
230               Node* val,
231               BasicType bt,
232               int adr_idx,
233               MemNode::MemOrd mo,
234               bool require_atomic_access = false,
235               bool mismatched = false);
236 
237   // Trivial call
238   Node* make_leaf_call(const TypeFunc *slow_call_type,
239                        address slow_call,
240                        const char *leaf_name,
241                        Node* parm0,
242                        Node* parm1 = nullptr,
243                        Node* parm2 = nullptr,
244                        Node* parm3 = nullptr);
245 
246   void make_leaf_call_no_fp(const TypeFunc *slow_call_type,

  1 /*
  2  * Copyright (c) 2005, 2025, 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  *

207   Node* XorX(Node* l, Node* r) { return transform(new XorLNode(l, r)); }
208 #else // _LP64
209   Node* XorX(Node* l, Node* r) { return transform(new XorINode(l, r)); }
210 #endif // _LP64
211   Node* URShiftX(Node* l, Node* r) { return transform(new URShiftXNode(l, r)); }
212   Node* ConX(jint k) { return (Node*)gvn().MakeConX(k); }
213   Node* CastPX(Node* ctl, Node* p) { return transform(new CastP2XNode(ctl, p)); }
214 
215   // Memory operations
216 
217   // This is the base version which is given an alias index.
218   Node* load(Node* ctl,
219              Node* adr,
220              const Type* t,
221              BasicType bt,
222              int adr_idx,
223              bool require_atomic_access = false,
224              MemNode::MemOrd mo = MemNode::unordered,
225              LoadNode::ControlDependency control_dependency = LoadNode::DependsOnlyOnTest);
226 
227   // Load AOT runtime constant
228   Node* load_aot_const(Node* adr, const Type* t);
229 
230   // Return the new StoreXNode
231   Node* store(Node* ctl,
232               Node* adr,
233               Node* val,
234               BasicType bt,
235               int adr_idx,
236               MemNode::MemOrd mo,
237               bool require_atomic_access = false,
238               bool mismatched = false);
239 
240   // Trivial call
241   Node* make_leaf_call(const TypeFunc *slow_call_type,
242                        address slow_call,
243                        const char *leaf_name,
244                        Node* parm0,
245                        Node* parm1 = nullptr,
246                        Node* parm2 = nullptr,
247                        Node* parm3 = nullptr);
248 
249   void make_leaf_call_no_fp(const TypeFunc *slow_call_type,
< prev index next >