1 /* 2 * Copyright (C) 2011 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_BASE_LOGGING_H_ 18 #define ART_RUNTIME_BASE_LOGGING_H_ 19 20 #include <ostream> 21 22 #include "base/macros.h" 23 24 namespace art { 25 26 enum LogSeverity { 27 NONE, // Fake level, don't log at all. 28 VERBOSE, 29 DEBUG, 30 INFO, 31 WARNING, 32 ERROR, 33 FATAL, 34 INTERNAL_FATAL, // For Runtime::Abort. 35 }; 36 37 // The members of this struct are the valid arguments to VLOG and VLOG_IS_ON in code, 38 // and the "-verbose:" command line argument. 39 struct LogVerbosity { 40 bool class_linker; // Enabled with "-verbose:class". 41 bool collector; 42 bool compiler; 43 bool deopt; 44 bool gc; 45 bool heap; 46 bool jdwp; 47 bool jit; 48 bool jni; 49 bool monitor; 50 bool oat; 51 bool profiler; 52 bool signals; 53 bool simulator; 54 bool startup; 55 bool third_party_jni; // Enabled with "-verbose:third-party-jni". 56 bool threads; 57 bool verifier; 58 bool image; 59 bool systrace_lock_logging; // Enabled with "-verbose:sys-locks". 60 }; 61 62 // Global log verbosity setting, initialized by InitLogging. 63 extern LogVerbosity gLogVerbosity; 64 65 // 0 if not abort, non-zero if an abort is in progress. Used on fatal exit to prevents recursive 66 // aborts. Global declaration allows us to disable some error checking to ensure fatal shutdown 67 // makes forward progress. 68 extern unsigned int gAborting; 69 70 // Configure logging based on ANDROID_LOG_TAGS environment variable. 71 // We need to parse a string that looks like 72 // 73 // *:v jdwp:d dalvikvm:d dalvikvm-gc:i dalvikvmi:i 74 // 75 // The tag (or '*' for the global level) comes first, followed by a colon 76 // and a letter indicating the minimum priority level we're expected to log. 77 // This can be used to reveal or conceal logs with specific tags. 78 extern void InitLogging(char* argv[]); 79 80 // Returns the command line used to invoke the current tool or null if InitLogging hasn't been 81 // performed. 82 extern const char* GetCmdLine(); 83 84 // The command used to start the ART runtime, such as "/system/bin/dalvikvm". If InitLogging hasn't 85 // been performed then just returns "art" 86 extern const char* ProgramInvocationName(); 87 88 // A short version of the command used to start the ART runtime, such as "dalvikvm". If InitLogging 89 // hasn't been performed then just returns "art" 90 extern const char* ProgramInvocationShortName(); 91 92 // Logs a message to logcat on Android otherwise to stderr. If the severity is FATAL it also causes 93 // an abort. For example: LOG(FATAL) << "We didn't expect to reach here"; 94 #define LOG(severity) ::art::LogMessage(__FILE__, __LINE__, severity, -1).stream() 95 96 // A variant of LOG that also logs the current errno value. To be used when library calls fail. 97 #define PLOG(severity) ::art::LogMessage(__FILE__, __LINE__, severity, errno).stream() 98 99 // Marker that code is yet to be implemented. 100 #define UNIMPLEMENTED(level) LOG(level) << __PRETTY_FUNCTION__ << " unimplemented " 101 102 // Is verbose logging enabled for the given module? Where the module is defined in LogVerbosity. 103 #define VLOG_IS_ON(module) UNLIKELY(::art::gLogVerbosity.module) 104 105 // Variant of LOG that logs when verbose logging is enabled for a module. For example, 106 // VLOG(jni) << "A JNI operation was performed"; 107 #define VLOG(module) \ 108 if (VLOG_IS_ON(module)) \ 109 ::art::LogMessage(__FILE__, __LINE__, INFO, -1).stream() 110 111 // Return the stream associated with logging for the given module. 112 #define VLOG_STREAM(module) ::art::LogMessage(__FILE__, __LINE__, INFO, -1).stream() 113 114 // Check whether condition x holds and LOG(FATAL) if not. The value of the expression x is only 115 // evaluated once. Extra logging can be appended using << after. For example, 116 // CHECK(false == true) results in a log message of "Check failed: false == true". 117 #define CHECK(x) \ 118 if (UNLIKELY(!(x))) \ 119 ::art::LogMessage(__FILE__, __LINE__, ::art::FATAL, -1).stream() \ 120 << "Check failed: " #x << " " 121 122 // Helper for CHECK_xx(x,y) macros. 123 #define CHECK_OP(LHS, RHS, OP) \ 124 for (auto _values = ::art::MakeEagerEvaluator(LHS, RHS); \ 125 UNLIKELY(!(_values.lhs OP _values.rhs)); /* empty */) \ 126 ::art::LogMessage(__FILE__, __LINE__, ::art::FATAL, -1).stream() \ 127 << "Check failed: " << #LHS << " " << #OP << " " << #RHS \ 128 << " (" #LHS "=" << _values.lhs << ", " #RHS "=" << _values.rhs << ") " 129 130 131 // Check whether a condition holds between x and y, LOG(FATAL) if not. The value of the expressions 132 // x and y is evaluated once. Extra logging can be appended using << after. For example, 133 // CHECK_NE(0 == 1, false) results in "Check failed: false != false (0==1=false, false=false) ". 134 #define CHECK_EQ(x, y) CHECK_OP(x, y, ==) 135 #define CHECK_NE(x, y) CHECK_OP(x, y, !=) 136 #define CHECK_LE(x, y) CHECK_OP(x, y, <=) 137 #define CHECK_LT(x, y) CHECK_OP(x, y, <) 138 #define CHECK_GE(x, y) CHECK_OP(x, y, >=) 139 #define CHECK_GT(x, y) CHECK_OP(x, y, >) 140 141 // Helper for CHECK_STRxx(s1,s2) macros. 142 #define CHECK_STROP(s1, s2, sense) \ 143 if (UNLIKELY((strcmp(s1, s2) == 0) != sense)) \ 144 LOG(::art::FATAL) << "Check failed: " \ 145 << "\"" << s1 << "\"" \ 146 << (sense ? " == " : " != ") \ 147 << "\"" << s2 << "\"" 148 149 // Check for string (const char*) equality between s1 and s2, LOG(FATAL) if not. 150 #define CHECK_STREQ(s1, s2) CHECK_STROP(s1, s2, true) 151 #define CHECK_STRNE(s1, s2) CHECK_STROP(s1, s2, false) 152 153 // Perform the pthread function call(args), LOG(FATAL) on error. 154 #define CHECK_PTHREAD_CALL(call, args, what) \ 155 do { \ 156 int rc = call args; \ 157 if (rc != 0) { \ 158 errno = rc; \ 159 PLOG(::art::FATAL) << # call << " failed for " << what; \ 160 } \ 161 } while (false) 162 163 // CHECK that can be used in a constexpr function. For example, 164 // constexpr int half(int n) { 165 // return 166 // DCHECK_CONSTEXPR(n >= 0, , 0) 167 // CHECK_CONSTEXPR((n & 1) == 0), << "Extra debugging output: n = " << n, 0) 168 // n / 2; 169 // } 170 #define CHECK_CONSTEXPR(x, out, dummy) \ 171 (UNLIKELY(!(x))) ? (LOG(::art::FATAL) << "Check failed: " << #x out, dummy) : 172 173 174 // DCHECKs are debug variants of CHECKs only enabled in debug builds. Generally CHECK should be 175 // used unless profiling identifies a CHECK as being in performance critical code. 176 #if defined(NDEBUG) 177 static constexpr bool kEnableDChecks = false; 178 #else 179 static constexpr bool kEnableDChecks = true; 180 #endif 181 182 #define DCHECK(x) if (::art::kEnableDChecks) CHECK(x) 183 #define DCHECK_EQ(x, y) if (::art::kEnableDChecks) CHECK_EQ(x, y) 184 #define DCHECK_NE(x, y) if (::art::kEnableDChecks) CHECK_NE(x, y) 185 #define DCHECK_LE(x, y) if (::art::kEnableDChecks) CHECK_LE(x, y) 186 #define DCHECK_LT(x, y) if (::art::kEnableDChecks) CHECK_LT(x, y) 187 #define DCHECK_GE(x, y) if (::art::kEnableDChecks) CHECK_GE(x, y) 188 #define DCHECK_GT(x, y) if (::art::kEnableDChecks) CHECK_GT(x, y) 189 #define DCHECK_STREQ(s1, s2) if (::art::kEnableDChecks) CHECK_STREQ(s1, s2) 190 #define DCHECK_STRNE(s1, s2) if (::art::kEnableDChecks) CHECK_STRNE(s1, s2) 191 #if defined(NDEBUG) 192 #define DCHECK_CONSTEXPR(x, out, dummy) 193 #else 194 #define DCHECK_CONSTEXPR(x, out, dummy) CHECK_CONSTEXPR(x, out, dummy) 195 #endif 196 197 // Temporary class created to evaluate the LHS and RHS, used with MakeEagerEvaluator to infer the 198 // types of LHS and RHS. 199 template <typename LHS, typename RHS> 200 struct EagerEvaluator { 201 EagerEvaluator(LHS l, RHS r) : lhs(l), rhs(r) { } 202 LHS lhs; 203 RHS rhs; 204 }; 205 206 // Helper function for CHECK_xx. 207 template <typename LHS, typename RHS> 208 static inline EagerEvaluator<LHS, RHS> MakeEagerEvaluator(LHS lhs, RHS rhs) { 209 return EagerEvaluator<LHS, RHS>(lhs, rhs); 210 } 211 212 // Explicitly instantiate EagerEvalue for pointers so that char*s aren't treated as strings. To 213 // compare strings use CHECK_STREQ and CHECK_STRNE. We rely on signed/unsigned warnings to 214 // protect you against combinations not explicitly listed below. 215 #define EAGER_PTR_EVALUATOR(T1, T2) \ 216 template <> struct EagerEvaluator<T1, T2> { \ 217 EagerEvaluator(T1 l, T2 r) \ 218 : lhs(reinterpret_cast<const void*>(l)), \ 219 rhs(reinterpret_cast<const void*>(r)) { } \ 220 const void* lhs; \ 221 const void* rhs; \ 222 } 223 EAGER_PTR_EVALUATOR(const char*, const char*); 224 EAGER_PTR_EVALUATOR(const char*, char*); 225 EAGER_PTR_EVALUATOR(char*, const char*); 226 EAGER_PTR_EVALUATOR(char*, char*); 227 EAGER_PTR_EVALUATOR(const unsigned char*, const unsigned char*); 228 EAGER_PTR_EVALUATOR(const unsigned char*, unsigned char*); 229 EAGER_PTR_EVALUATOR(unsigned char*, const unsigned char*); 230 EAGER_PTR_EVALUATOR(unsigned char*, unsigned char*); 231 EAGER_PTR_EVALUATOR(const signed char*, const signed char*); 232 EAGER_PTR_EVALUATOR(const signed char*, signed char*); 233 EAGER_PTR_EVALUATOR(signed char*, const signed char*); 234 EAGER_PTR_EVALUATOR(signed char*, signed char*); 235 236 // Data for the log message, not stored in LogMessage to avoid increasing the stack size. 237 class LogMessageData; 238 239 // A LogMessage is a temporarily scoped object used by LOG and the unlikely part of a CHECK. The 240 // destructor will abort if the severity is FATAL. 241 class LogMessage { 242 public: 243 LogMessage(const char* file, unsigned int line, LogSeverity severity, int error); 244 245 ~LogMessage(); // TODO: enable REQUIRES(!Locks::logging_lock_). 246 247 // Returns the stream associated with the message, the LogMessage performs output when it goes 248 // out of scope. 249 std::ostream& stream(); 250 251 // The routine that performs the actual logging. 252 static void LogLine(const char* file, unsigned int line, LogSeverity severity, const char* msg); 253 254 // A variant of the above for use with little stack. 255 static void LogLineLowStack(const char* file, unsigned int line, LogSeverity severity, 256 const char* msg); 257 258 private: 259 const std::unique_ptr<LogMessageData> data_; 260 261 DISALLOW_COPY_AND_ASSIGN(LogMessage); 262 }; 263 264 // Allows to temporarily change the minimum severity level for logging. 265 class ScopedLogSeverity { 266 public: 267 explicit ScopedLogSeverity(LogSeverity level); 268 ~ScopedLogSeverity(); 269 270 private: 271 LogSeverity old_; 272 }; 273 274 } // namespace art 275 276 #endif // ART_RUNTIME_BASE_LOGGING_H_ 277
