1 /*
2  * Copyright (C) 2015 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_VERIFIER_ENUMS_H_
18 #define ART_RUNTIME_VERIFIER_VERIFIER_ENUMS_H_
19 
20 #include <stdint.h>
21 
22 namespace art {
23 namespace verifier {
24 
25 // The mode that the verifier should run as.
26 enum class VerifyMode : int8_t {
27   kNone,      // Everything is assumed verified.
28   kEnable,    // Standard verification, try pre-verifying at compile-time.
29   kSoftFail,  // Force a soft fail, punting to the interpreter with access checks.
30 };
31 
32 // The outcome of verification.
33 enum class FailureKind {
34   kNoFailure,
35   kAccessChecksFailure,
36   kSoftFailure,
37   kHardFailure,
38 };
39 std::ostream& operator<<(std::ostream& os, const FailureKind& rhs);
40 
41 // How to log hard failures during verification.
42 enum class HardFailLogMode {
43   kLogNone,                               // Don't log hard failures at all.
44   kLogVerbose,                            // Log with severity VERBOSE.
45   kLogWarning,                            // Log with severity WARNING.
46   kLogInternalFatal,                      // Log with severity FATAL_WITHOUT_ABORT
47 };
48 
49 /*
50  * "Direct" and "virtual" methods are stored independently. The type of call used to invoke the
51  * method determines which list we search, and whether we travel up into superclasses.
52  *
53  * (<clinit>, <init>, and methods declared "private" or "static" are stored in the "direct" list.
54  * All others are stored in the "virtual" list.)
55  */
56 enum MethodType {
57   METHOD_UNKNOWN  = 0,
58   METHOD_DIRECT,      // <init>, private
59   METHOD_STATIC,      // static
60   METHOD_VIRTUAL,     // virtual
61   METHOD_SUPER,       // super
62   METHOD_INTERFACE,   // interface
63   METHOD_POLYMORPHIC  // polymorphic
64 };
65 std::ostream& operator<<(std::ostream& os, const MethodType& rhs);
66 
67 /*
68  * An enumeration of problems that can turn up during verification.
69  * Both VERIFY_ERROR_BAD_CLASS_SOFT and VERIFY_ERROR_BAD_CLASS_HARD denote failures that cause
70  * the entire class to be rejected. However, VERIFY_ERROR_BAD_CLASS_SOFT denotes a soft failure
71  * that can potentially be corrected, and the verifier will try again at runtime.
72  * VERIFY_ERROR_BAD_CLASS_HARD denotes a hard failure that can't be corrected, and will cause
73  * the class to remain uncompiled. Other errors denote verification errors that cause bytecode
74  * to be rewritten to fail at runtime.
75  */
76 enum VerifyError : uint32_t {
77   VERIFY_ERROR_BAD_CLASS_HARD =    1 << 0,   // VerifyError; hard error that skips compilation.
78   VERIFY_ERROR_BAD_CLASS_SOFT =    1 << 1,   // VerifyError; soft error that verifies again at
79                                              // runtime.
80 
81   VERIFY_ERROR_NO_CLASS =          1 << 2,   // NoClassDefFoundError.
82   VERIFY_ERROR_NO_FIELD =          1 << 3,   // NoSuchFieldError.
83   VERIFY_ERROR_NO_METHOD =         1 << 4,   // NoSuchMethodError.
84   VERIFY_ERROR_ACCESS_CLASS =      1 << 5,   // IllegalAccessError.
85   VERIFY_ERROR_ACCESS_FIELD =      1 << 6,   // IllegalAccessError.
86   VERIFY_ERROR_ACCESS_METHOD =     1 << 7,   // IllegalAccessError.
87   VERIFY_ERROR_CLASS_CHANGE =      1 << 8,   // IncompatibleClassChangeError.
88   VERIFY_ERROR_INSTANTIATION =     1 << 9,   // InstantiationError.
89   // For opcodes that don't have complete verifier support,  we need a way to continue
90   // execution at runtime without attempting to re-verify (since we know it will fail no
91   // matter what). Instead, run as the interpreter in a special "do access checks" mode
92   // which will perform verifier-like checking on the fly.
93   VERIFY_ERROR_FORCE_INTERPRETER = 1 << 10,  // Skip the verification phase at runtime;
94                                              // force the interpreter to do access checks.
95                                              // (sets a soft fail at compile time).
96   VERIFY_ERROR_LOCKING =           1 << 11,  // Could not guarantee balanced locking. This should be
97                                              // punted to the interpreter with access checks.
98   VERIFY_ERROR_SKIP_COMPILER =    1u << 31,  // Flag to note that the failure should preclude
99                                              // optimization. Meant as a signal from the verifier
100                                              // to the compiler that there is unreachable unverified
101                                              // code. May be removed once the compiler handles
102                                              // unreachable code correctly.
103 };
104 std::ostream& operator<<(std::ostream& os, const VerifyError& rhs);
105 
106 }  // namespace verifier
107 }  // namespace art
108 
109 #endif  // ART_RUNTIME_VERIFIER_VERIFIER_ENUMS_H_
110