1/*
2 * Copyright (C) 2014 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ART_COMPILER_DEX_QUICK_RESOURCE_MASK_H_
18#define ART_COMPILER_DEX_QUICK_RESOURCE_MASK_H_
19
20#include <stdint.h>
21
22#include "base/logging.h"
23#include "dex/reg_storage.h"
24
25namespace art {
26
27class ArenaAllocator;
28
29/**
30 * @brief Resource mask for LIR insn uses or defs.
31 * @detail Def/Use mask used for checking dependencies between LIR insns in local
32 * optimizations such as load hoisting.
33 */
34class ResourceMask {
35 private:
36  constexpr ResourceMask(uint64_t mask1, uint64_t mask2)
37      : masks_{ mask1, mask2 } {  // NOLINT
38  }
39
40 public:
41  /*
42   * Def/Use encoding in 128-bit use_mask/def_mask.  Low positions used for target-specific
43   * registers (and typically use the register number as the position).  High positions
44   * reserved for common and abstract resources.
45   */
46  enum ResourceBit {
47    kMustNotAlias = 127,
48    kHeapRef = 126,         // Default memory reference type.
49    kLiteral = 125,         // Literal pool memory reference.
50    kDalvikReg = 124,       // Dalvik v_reg memory reference.
51    kFPStatus = 123,
52    kCCode = 122,
53    kLowestCommonResource = kCCode,
54    kHighestCommonResource = kMustNotAlias
55  };
56
57  // Default-constructible.
58  constexpr ResourceMask()
59    : masks_ { 0u, 0u } {
60  }
61
62  // Copy-constructible and copyable.
63  ResourceMask(const ResourceMask& other) = default;
64  ResourceMask& operator=(const ResourceMask& other) = default;
65
66  // Comparable by content.
67  bool operator==(const ResourceMask& other) {
68    return masks_[0] == other.masks_[0] && masks_[1] == other.masks_[1];
69  }
70
71  static constexpr ResourceMask RawMask(uint64_t mask1, uint64_t mask2) {
72    return ResourceMask(mask1, mask2);
73  }
74
75  static constexpr ResourceMask Bit(size_t bit) {
76    return ResourceMask(bit >= 64u ? 0u : UINT64_C(1) << bit,
77                        bit >= 64u ? UINT64_C(1) << (bit - 64u) : 0u);
78  }
79
80  // Two consecutive bits. The start_bit must be even.
81  static constexpr ResourceMask TwoBits(size_t start_bit) {
82    return
83        DCHECK_CONSTEXPR((start_bit & 1u) == 0u, << start_bit << " isn't even", Bit(0))
84        ResourceMask(start_bit >= 64u ? 0u : UINT64_C(3) << start_bit,
85                     start_bit >= 64u ? UINT64_C(3) << (start_bit - 64u) : 0u);
86  }
87
88  static constexpr ResourceMask NoBits() {
89    return ResourceMask(UINT64_C(0), UINT64_C(0));
90  }
91
92  static constexpr ResourceMask AllBits() {
93    return ResourceMask(~UINT64_C(0), ~UINT64_C(0));
94  }
95
96  constexpr ResourceMask Union(const ResourceMask& other) const {
97    return ResourceMask(masks_[0] | other.masks_[0], masks_[1] | other.masks_[1]);
98  }
99
100  constexpr ResourceMask Intersection(const ResourceMask& other) const {
101    return ResourceMask(masks_[0] & other.masks_[0], masks_[1] & other.masks_[1]);
102  }
103
104  constexpr ResourceMask Without(const ResourceMask& other) const {
105    return ResourceMask(masks_[0] & ~other.masks_[0], masks_[1] & ~other.masks_[1]);
106  }
107
108  constexpr bool Equals(const ResourceMask& other) const {
109    return masks_[0] == other.masks_[0] && masks_[1] == other.masks_[1];
110  }
111
112  constexpr bool Intersects(const ResourceMask& other) const {
113    return (masks_[0] & other.masks_[0]) != 0u || (masks_[1] & other.masks_[1]) != 0u;
114  }
115
116  void SetBit(size_t bit) {
117    DCHECK_LE(bit, kHighestCommonResource);
118    masks_[bit / 64u] |= UINT64_C(1) << (bit & 63u);
119  }
120
121  constexpr bool HasBit(size_t bit) const {
122    return (masks_[bit / 64u] & (UINT64_C(1) << (bit & 63u))) != 0u;
123  }
124
125  ResourceMask& SetBits(const ResourceMask& other) {
126    masks_[0] |= other.masks_[0];
127    masks_[1] |= other.masks_[1];
128    return *this;
129  }
130
131  ResourceMask& ClearBits(const ResourceMask& other) {
132    masks_[0] &= ~other.masks_[0];
133    masks_[1] &= ~other.masks_[1];
134    return *this;
135  }
136
137 private:
138  uint64_t masks_[2];
139
140  friend class ResourceMaskCache;
141};
142
143constexpr ResourceMask kEncodeNone = ResourceMask::NoBits();
144constexpr ResourceMask kEncodeAll = ResourceMask::AllBits();
145constexpr ResourceMask kEncodeHeapRef = ResourceMask::Bit(ResourceMask::kHeapRef);
146constexpr ResourceMask kEncodeLiteral = ResourceMask::Bit(ResourceMask::kLiteral);
147constexpr ResourceMask kEncodeDalvikReg = ResourceMask::Bit(ResourceMask::kDalvikReg);
148constexpr ResourceMask kEncodeMem = kEncodeLiteral.Union(kEncodeDalvikReg).Union(
149    kEncodeHeapRef).Union(ResourceMask::Bit(ResourceMask::kMustNotAlias));
150
151class ResourceMaskCache {
152 public:
153  explicit ResourceMaskCache(ArenaAllocator* allocator)
154      : allocator_(allocator) {
155  }
156
157  const ResourceMask* GetMask(const ResourceMask& mask);
158
159 private:
160  ArenaAllocator* allocator_;
161};
162
163}  // namespace art
164
165#endif  // ART_COMPILER_DEX_QUICK_RESOURCE_MASK_H_
166