1 /* 2 * Copyright (C) 2013 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_RUNTIME_VERIFIER_REGISTER_LINE_INL_H_ 18 #define ART_RUNTIME_VERIFIER_REGISTER_LINE_INL_H_ 19 20 #include "register_line.h" 21 22 #include "method_verifier.h" 23 #include "reg_type_cache-inl.h" 24 25 namespace art { 26 namespace verifier { 27 28 // Should we dump a warning on failures to verify balanced locking? That would be an indication to 29 // developers that their code will be slow. 30 static constexpr bool kDumpLockFailures = true; 31 32 inline const RegType& RegisterLine::GetRegisterType(MethodVerifier* verifier, uint32_t vsrc) const { 33 // The register index was validated during the static pass, so we don't need to check it here. 34 DCHECK_LT(vsrc, num_regs_); 35 return verifier->GetRegTypeCache()->GetFromId(line_[vsrc]); 36 } 37 38 template <LockOp kLockOp> 39 inline bool RegisterLine::SetRegisterType(MethodVerifier* verifier, uint32_t vdst, 40 const RegType& new_type) { 41 DCHECK_LT(vdst, num_regs_); 42 if (new_type.IsLowHalf() || new_type.IsHighHalf()) { 43 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "Expected category1 register type not '" 44 << new_type << "'"; 45 return false; 46 } else { 47 // Note: previously we failed when asked to set a conflict. However, conflicts are OK as long 48 // as they are not accessed, and our backends can handle this nowadays. 49 line_[vdst] = new_type.GetId(); 50 } 51 switch (kLockOp) { 52 case LockOp::kClear: 53 // Clear the monitor entry bits for this register. 54 ClearAllRegToLockDepths(vdst); 55 break; 56 case LockOp::kKeep: 57 // Should only be doing this with reference types. 58 DCHECK(new_type.IsReferenceTypes()); 59 break; 60 } 61 return true; 62 } 63 64 inline bool RegisterLine::SetRegisterTypeWide(MethodVerifier* verifier, uint32_t vdst, 65 const RegType& new_type1, 66 const RegType& new_type2) { 67 DCHECK_LT(vdst + 1, num_regs_); 68 if (!new_type1.CheckWidePair(new_type2)) { 69 verifier->Fail(VERIFY_ERROR_BAD_CLASS_SOFT) << "Invalid wide pair '" 70 << new_type1 << "' '" << new_type2 << "'"; 71 return false; 72 } else { 73 line_[vdst] = new_type1.GetId(); 74 line_[vdst + 1] = new_type2.GetId(); 75 } 76 // Clear the monitor entry bits for this register. 77 ClearAllRegToLockDepths(vdst); 78 ClearAllRegToLockDepths(vdst + 1); 79 return true; 80 } 81 82 inline void RegisterLine::SetResultTypeToUnknown(MethodVerifier* verifier) { 83 result_[0] = verifier->GetRegTypeCache()->Undefined().GetId(); 84 result_[1] = result_[0]; 85 } 86 87 inline void RegisterLine::SetResultRegisterType(MethodVerifier* verifier, const RegType& new_type) { 88 DCHECK(!new_type.IsLowHalf()); 89 DCHECK(!new_type.IsHighHalf()); 90 result_[0] = new_type.GetId(); 91 result_[1] = verifier->GetRegTypeCache()->Undefined().GetId(); 92 } 93 94 inline void RegisterLine::SetResultRegisterTypeWide(const RegType& new_type1, 95 const RegType& new_type2) { 96 DCHECK(new_type1.CheckWidePair(new_type2)); 97 result_[0] = new_type1.GetId(); 98 result_[1] = new_type2.GetId(); 99 } 100 101 inline void RegisterLine::CopyRegister1(MethodVerifier* verifier, uint32_t vdst, uint32_t vsrc, 102 TypeCategory cat) { 103 DCHECK(cat == kTypeCategory1nr || cat == kTypeCategoryRef); 104 const RegType& type = GetRegisterType(verifier, vsrc); 105 if (!SetRegisterType<LockOp::kClear>(verifier, vdst, type)) { 106 return; 107 } 108 if (!type.IsConflict() && // Allow conflicts to be copied around. 109 ((cat == kTypeCategory1nr && !type.IsCategory1Types()) || 110 (cat == kTypeCategoryRef && !type.IsReferenceTypes()))) { 111 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "copy1 v" << vdst << "<-v" << vsrc << " type=" << type 112 << " cat=" << static_cast<int>(cat); 113 } else if (cat == kTypeCategoryRef) { 114 CopyRegToLockDepth(vdst, vsrc); 115 } 116 } 117 118 inline void RegisterLine::CopyRegister2(MethodVerifier* verifier, uint32_t vdst, uint32_t vsrc) { 119 const RegType& type_l = GetRegisterType(verifier, vsrc); 120 const RegType& type_h = GetRegisterType(verifier, vsrc + 1); 121 122 if (!type_l.CheckWidePair(type_h)) { 123 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "copy2 v" << vdst << "<-v" << vsrc 124 << " type=" << type_l << "/" << type_h; 125 } else { 126 SetRegisterTypeWide(verifier, vdst, type_l, type_h); 127 } 128 } 129 130 inline bool RegisterLine::VerifyRegisterType(MethodVerifier* verifier, uint32_t vsrc, 131 const RegType& check_type) { 132 // Verify the src register type against the check type refining the type of the register 133 const RegType& src_type = GetRegisterType(verifier, vsrc); 134 if (UNLIKELY(!check_type.IsAssignableFrom(src_type, verifier))) { 135 enum VerifyError fail_type; 136 if (!check_type.IsNonZeroReferenceTypes() || !src_type.IsNonZeroReferenceTypes()) { 137 // Hard fail if one of the types is primitive, since they are concretely known. 138 fail_type = VERIFY_ERROR_BAD_CLASS_HARD; 139 } else if (check_type.IsUninitializedTypes() || src_type.IsUninitializedTypes()) { 140 // Hard fail for uninitialized types, which don't match anything but themselves. 141 fail_type = VERIFY_ERROR_BAD_CLASS_HARD; 142 } else if (check_type.IsUnresolvedTypes() || src_type.IsUnresolvedTypes()) { 143 fail_type = VERIFY_ERROR_NO_CLASS; 144 } else { 145 fail_type = VERIFY_ERROR_BAD_CLASS_SOFT; 146 } 147 verifier->Fail(fail_type) << "register v" << vsrc << " has type " 148 << src_type << " but expected " << check_type; 149 return false; 150 } 151 if (check_type.IsLowHalf()) { 152 const RegType& src_type_h = GetRegisterType(verifier, vsrc + 1); 153 if (UNLIKELY(!src_type.CheckWidePair(src_type_h))) { 154 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "wide register v" << vsrc << " has type " 155 << src_type << "/" << src_type_h; 156 return false; 157 } 158 } 159 // The register at vsrc has a defined type, we know the lower-upper-bound, but this is less 160 // precise than the subtype in vsrc so leave it for reference types. For primitive types 161 // if they are a defined type then they are as precise as we can get, however, for constant 162 // types we may wish to refine them. Unfortunately constant propagation has rendered this useless. 163 return true; 164 } 165 166 inline void RegisterLine::VerifyMonitorStackEmpty(MethodVerifier* verifier) const { 167 if (MonitorStackDepth() != 0) { 168 verifier->Fail(VERIFY_ERROR_LOCKING); 169 if (kDumpLockFailures) { 170 VLOG(verifier) << "expected empty monitor stack in " 171 << verifier->GetMethodReference().PrettyMethod(); 172 } 173 } 174 } 175 176 inline size_t RegisterLine::ComputeSize(size_t num_regs) { 177 return OFFSETOF_MEMBER(RegisterLine, line_) + num_regs * sizeof(uint16_t); 178 } 179 180 inline RegisterLine* RegisterLine::Create(size_t num_regs, MethodVerifier* verifier) { 181 void* memory = verifier->GetArena().Alloc(ComputeSize(num_regs)); 182 return new (memory) RegisterLine(num_regs, verifier); 183 } 184 185 inline RegisterLine::RegisterLine(size_t num_regs, MethodVerifier* verifier) 186 : num_regs_(num_regs), 187 monitors_(verifier->GetArena().Adapter(kArenaAllocVerifier)), 188 reg_to_lock_depths_(std::less<uint32_t>(), verifier->GetArena().Adapter(kArenaAllocVerifier)), 189 this_initialized_(false) { 190 std::uninitialized_fill_n(line_, num_regs_, 0u); 191 SetResultTypeToUnknown(verifier); 192 } 193 194 inline void RegisterLineArenaDelete::operator()(RegisterLine* ptr) const { 195 if (ptr != nullptr) { 196 ptr->~RegisterLine(); 197 ProtectMemory(ptr, RegisterLine::ComputeSize(ptr->NumRegs())); 198 } 199 } 200 201 } // namespace verifier 202 } // namespace art 203 204 #endif // ART_RUNTIME_VERIFIER_REGISTER_LINE_INL_H_ 205
