Lines Matching full:verifier
26 namespace verifier {
28 bool RegisterLine::CheckConstructorReturn(MethodVerifier* verifier) const {
32 const RegType& type = GetRegisterType(verifier, i);
36 << PrettyMethod(verifier->GetMethodReference().dex_method_index,
37 *verifier->GetMethodReference().dex_file);
41 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD)
47 const RegType& RegisterLine::GetInvocationThis(MethodVerifier* verifier, const Instruction* inst,
52 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invoke lacks 'this'";
54 return verifier->GetRegTypeCache()->Conflict();
58 const RegType& this_type = GetRegisterType(verifier, this_reg);
61 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD)
65 return verifier->GetRegTypeCache()->Conflict();
70 bool RegisterLine::VerifyRegisterTypeWide(MethodVerifier* verifier, uint32_t vsrc,
75 const RegType& src_type = GetRegisterType(verifier, vsrc);
77 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "register v" << vsrc << " has type " << src_type
81 const RegType& src_type_h = GetRegisterType(verifier, vsrc + 1);
83 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "wide register v" << vsrc << " has type "
94 void RegisterLine::MarkRefsAsInitialized(MethodVerifier* verifier, const RegType& uninit_type,
98 const RegType& init_type = verifier->GetRegTypeCache()->FromUninitialized(uninit_type);
101 if (GetRegisterType(verifier, i).Equals(uninit_type)) {
105 auto it = verifier->GetStringInitPcRegMap().find(dex_pc);
106 if (it != verifier->GetStringInitPcRegMap().end()) {
110 verifier->GetStringInitPcRegMap().Put(dex_pc, reg_set);
123 void RegisterLine::MarkAllRegistersAsConflicts(MethodVerifier* verifier) {
124 uint16_t conflict_type_id = verifier->GetRegTypeCache()->Conflict().GetId();
130 void RegisterLine::MarkAllRegistersAsConflictsExcept(MethodVerifier* verifier, uint32_t vsrc) {
131 uint16_t conflict_type_id = verifier->GetRegTypeCache()->Conflict().GetId();
139 void RegisterLine::MarkAllRegistersAsConflictsExceptWide(MethodVerifier* verifier, uint32_t vsrc) {
140 uint16_t conflict_type_id = verifier->GetRegTypeCache()->Conflict().GetId();
148 std::string RegisterLine::Dump(MethodVerifier* verifier) const {
152 result += GetRegisterType(verifier, i).Dump();
161 void RegisterLine::MarkUninitRefsAsInvalid(MethodVerifier* verifier, const RegType& uninit_type) {
163 if (GetRegisterType(verifier, i).Equals(uninit_type)) {
164 line_[i] = verifier->GetRegTypeCache()->Conflict().GetId();
170 void RegisterLine::CopyResultRegister1(MethodVerifier* verifier, uint32_t vdst, bool is_reference) {
171 const RegType& type = verifier->GetRegTypeCache()->GetFromId(result_[0]);
174 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD)
177 DCHECK(verifier->GetRegTypeCache()->GetFromId(result_[1]).IsUndefined());
178 SetRegisterType(verifier, vdst, type);
179 result_[0] = verifier->GetRegTypeCache()->Undefined().GetId();
187 void RegisterLine::CopyResultRegister2(MethodVerifier* verifier, uint32_t vdst) {
188 const RegType& type_l = verifier->GetRegTypeCache()->GetFromId(result_[0]);
189 const RegType& type_h = verifier->GetRegTypeCache()->GetFromId(result_[1]);
191 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD)
195 SetRegisterTypeWide(verifier, vdst, type_l, type_h); // also sets the high
196 result_[0] = verifier->GetRegTypeCache()->Undefined().GetId();
197 result_[1] = verifier->GetRegTypeCache()->Undefined().GetId();
201 void RegisterLine::CheckUnaryOp(MethodVerifier* verifier, const Instruction* inst,
203 if (VerifyRegisterType(verifier, inst->VRegB_12x(), src_type)) {
204 SetRegisterType(verifier, inst->VRegA_12x(), dst_type);
208 void RegisterLine::CheckUnaryOpWide(MethodVerifier* verifier, const Instruction* inst,
211 if (VerifyRegisterTypeWide(verifier, inst->VRegB_12x(), src_type1, src_type2)) {
212 SetRegisterTypeWide(verifier, inst->VRegA_12x(), dst_type1, dst_type2);
216 void RegisterLine::CheckUnaryOpToWide(MethodVerifier* verifier, const Instruction* inst,
219 if (VerifyRegisterType(verifier, inst->VRegB_12x(), src_type)) {
220 SetRegisterTypeWide(verifier, inst->VRegA_12x(), dst_type1, dst_type2);
224 void RegisterLine::CheckUnaryOpFromWide(MethodVerifier* verifier, const Instruction* inst,
227 if (VerifyRegisterTypeWide(verifier, inst->VRegB_12x(), src_type1, src_type2)) {
228 SetRegisterType(verifier, inst->VRegA_12x(), dst_type);
232 void RegisterLine::CheckBinaryOp(MethodVerifier* verifier, const Instruction* inst,
238 if (VerifyRegisterType(verifier, vregB, src_type1) &&
239 VerifyRegisterType(verifier, vregC, src_type2)) {
242 if (GetRegisterType(verifier, vregB).IsBooleanTypes() &&
243 GetRegisterType(verifier, vregC).IsBooleanTypes()) {
244 SetRegisterType(verifier, inst->VRegA_23x(), verifier->GetRegTypeCache()->Boolean());
248 SetRegisterType(verifier, inst->VRegA_23x(), dst_type);
252 void RegisterLine::CheckBinaryOpWide(MethodVerifier* verifier, const Instruction* inst,
256 if (VerifyRegisterTypeWide(verifier, inst->VRegB_23x(), src_type1_1, src_type1_2) &&
257 VerifyRegisterTypeWide(verifier, inst->VRegC_23x(), src_type2_1, src_type2_2)) {
258 SetRegisterTypeWide(verifier, inst->VRegA_23x(), dst_type1, dst_type2);
262 void RegisterLine::CheckBinaryOpWideShift(MethodVerifier* verifier, const Instruction* inst,
265 if (VerifyRegisterTypeWide(verifier, inst->VRegB_23x(), long_lo_type, long_hi_type) &&
266 VerifyRegisterType(verifier, inst->VRegC_23x(), int_type)) {
267 SetRegisterTypeWide(verifier, inst->VRegA_23x(), long_lo_type, long_hi_type);
271 void RegisterLine::CheckBinaryOp2addr(MethodVerifier* verifier, const Instruction* inst,
276 if (VerifyRegisterType(verifier, vregA, src_type1) &&
277 VerifyRegisterType(verifier, vregB, src_type2)) {
280 if (GetRegisterType(verifier, vregA).IsBooleanTypes() &&
281 GetRegisterType(verifier, vregB).IsBooleanTypes()) {
282 SetRegisterType(verifier, vregA, verifier->GetRegTypeCache()->Boolean());
286 SetRegisterType(verifier, vregA, dst_type);
290 void RegisterLine::CheckBinaryOp2addrWide(MethodVerifier* verifier, const Instruction* inst,
296 if (VerifyRegisterTypeWide(verifier, vregA, src_type1_1, src_type1_2) &&
297 VerifyRegisterTypeWide(verifier, vregB, src_type2_1, src_type2_2)) {
298 SetRegisterTypeWide(verifier, vregA, dst_type1, dst_type2);
302 void RegisterLine::CheckBinaryOp2addrWideShift(MethodVerifier* verifier, const Instruction* inst,
307 if (VerifyRegisterTypeWide(verifier, vregA, long_lo_type, long_hi_type) &&
308 VerifyRegisterType(verifier, vregB, int_type)) {
309 SetRegisterTypeWide(verifier, vregA, long_lo_type, long_hi_type);
313 void RegisterLine::CheckLiteralOp(MethodVerifier* verifier, const Instruction* inst,
318 if (VerifyRegisterType(verifier, vregB, src_type)) {
323 if (GetRegisterType(verifier, vregB).IsBooleanTypes() && (val == 0 || val == 1)) {
324 SetRegisterType(verifier, vregA, verifier->GetRegTypeCache()->Boolean());
328 SetRegisterType(verifier, vregA, dst_type);
332 void RegisterLine::PushMonitor(MethodVerifier* verifier, uint32_t reg_idx, int32_t insn_idx) {
333 const RegType& reg_type = GetRegisterType(verifier, reg_idx);
335 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "monitor-enter on non-object ("
338 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "monitor-enter stack overflow: "
344 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unexpected monitor-enter on register v" <<
350 void RegisterLine::PopMonitor(MethodVerifier* verifier, uint32_t reg_idx) {
351 const RegType& reg_type = GetRegisterType(verifier, reg_idx);
353 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "monitor-exit on non-object (" << reg_type << ")";
355 verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "monitor-exit stack underflow";
362 ((verifier->DexFileVersion() >= 36) ? verifier->Fail(VERIFY_ERROR_BAD_CLASS_SOFT)
363 : verifier->LogVerifyInfo())
372 bool RegisterLine::MergeRegisters(MethodVerifier* verifier, const RegisterLine* incoming_line) {
377 const RegType& incoming_reg_type = incoming_line->GetRegisterType(verifier, idx);
378 const RegType& cur_type = GetRegisterType(verifier, idx);
379 const RegType& new_type = cur_type.Merge(incoming_reg_type, verifier->GetRegTypeCache());
412 void RegisterLine::WriteReferenceBitMap(MethodVerifier* verifier,
418 if (GetRegisterType(verifier, i + j).IsNonZeroReferenceTypes()) {
431 } // namespace verifier
