1 /*
2 * Copyright (c) 2018, 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_GC_SHARED_C1_BARRIERSETC1_HPP
26 #define SHARE_GC_SHARED_C1_BARRIERSETC1_HPP
27
28 #include "c1/c1_Decorators.hpp"
29 #include "c1/c1_LIRGenerator.hpp"
30 #include "c1/c1_Instruction.hpp"
31 #include "c1/c1_LIR.hpp"
32 #include "memory/allocation.hpp"
33
34 class LIRGenerator;
35 class LIRItem;
36
37 // The LIRAddressOpr comprises either a LIRItem or a LIR_Opr to describe elements
38 // of an access in the C1 Access API. Both of them allow asking for the opr() which
39 // will correspond to either _item.result() or _opr if there is no _item.
40 class LIRAddressOpr: public StackObj {
41 LIRItem* _item;
42 LIR_Opr _opr;
43 public:
44 LIRAddressOpr(LIRItem& item) : _item(&item), _opr(NULL) {}
45 LIRAddressOpr(LIR_Opr opr) : _item(NULL), _opr(opr) {}
46 LIRAddressOpr(const LIRAddressOpr& other) : _item(other._item), _opr(other._opr) {}
47
48 LIRItem& item() const {
49 assert(_item != NULL, "sanity");
50 return *_item;
51 }
52
53 LIR_Opr opr() const {
54 if (_item == NULL) {
55 return _opr;
56 } else {
57 return _item->result();
58 }
59 }
60 };
61
62 // The LIRAccess class wraps shared context parameters required for performing
63 // the right access in C1. This includes the address of the offset and the decorators.
64 class LIRAccess: public StackObj {
65 LIRGenerator* _gen;
66 DecoratorSet _decorators;
67 LIRAddressOpr _base;
68 LIRAddressOpr _offset;
69 BasicType _type;
70 LIR_Opr _resolved_addr;
71 CodeEmitInfo* _patch_info;
72 CodeEmitInfo* _access_emit_info;
73
74 public:
75 LIRAccess(LIRGenerator* gen, DecoratorSet decorators,
76 LIRAddressOpr base, LIRAddressOpr offset, BasicType type,
77 CodeEmitInfo* patch_info = NULL, CodeEmitInfo* access_emit_info = NULL) :
78 _gen(gen),
79 _decorators(AccessInternal::decorator_fixup(decorators)),
80 _base(base),
81 _offset(offset),
82 _type(type),
83 _resolved_addr(NULL),
84 _patch_info(patch_info),
85 _access_emit_info(access_emit_info) {}
86
87 void load_base() { _base.item().load_item(); }
88 void load_offset() { _offset.item().load_nonconstant(); }
89
90 void load_address() {
91 load_base();
92 load_offset();
93 }
94
95 LIRGenerator* gen() const { return _gen; }
96 CodeEmitInfo*& patch_info() { return _patch_info; }
97 CodeEmitInfo*& access_emit_info() { return _access_emit_info; }
98 LIRAddressOpr& base() { return _base; }
99 LIRAddressOpr& offset() { return _offset; }
100 BasicType type() const { return _type; }
101 LIR_Opr resolved_addr() const { return _resolved_addr; }
102 void set_resolved_addr(LIR_Opr addr) { _resolved_addr = addr; }
103 bool is_oop() const { return _type == T_ARRAY || _type == T_OBJECT; }
104 DecoratorSet decorators() const { return _decorators; }
105 bool is_raw() const { return (_decorators & AS_RAW) != 0; }
106 };
107
108 // The BarrierSetC1 class is the main entry point for the GC backend of the Access API in C1.
109 // It is called by the LIRGenerator::access_* functions, which is the main entry poing for
110 // access calls in C1.
111
112 class BarrierSetC1: public CHeapObj<mtGC> {
113 protected:
114 virtual LIR_Opr resolve_address(LIRAccess& access, bool resolve_in_register);
115
116 virtual void generate_referent_check(LIRAccess& access, LabelObj* cont);
117
118 // Accesses with resolved address
119 virtual void store_at_resolved(LIRAccess& access, LIR_Opr value);
120 virtual void load_at_resolved(LIRAccess& access, LIR_Opr result);
121
122 virtual LIR_Opr atomic_cmpxchg_resolved(LIRAccess& access, LIRItem& cmp_value, LIRItem& new_value);
123
124 virtual LIR_Opr atomic_xchg_resolved(LIRAccess& access, LIRItem& value);
125 virtual LIR_Opr atomic_add_at_resolved(LIRAccess& access, LIRItem& value);
126
127 public:
128 virtual void store_at(LIRAccess& access, LIR_Opr value);
129 virtual void load_at(LIRAccess& access, LIR_Opr result);
130
131 virtual LIR_Opr atomic_cmpxchg_at(LIRAccess& access, LIRItem& cmp_value, LIRItem& new_value);
132
133 virtual LIR_Opr atomic_xchg(LIRAccess& access, LIRItem& value);
134 virtual LIR_Opr atomic_add_at(LIRAccess& access, LIRItem& value);
135
136 virtual void generate_c1_runtime_stubs(BufferBlob* buffer_blob) {}
137 };
138
139 #endif // SHARE_GC_SHARED_C1_BARRIERSETC1_HPP