#
# Please keep the list sorted.
+Abhishek Dasgupta <abhi2743@gmail.com>
Abhishek Parmar <abhishek@orng.net>
Brian Silverman <bsilver16384@gmail.com>
Google Inc.
target_link_libraries (glog PUBLIC ${UNWIND_LIBRARY})
endif (UNWIND_LIBRARY)
+if (HAVE_PTHREAD)
+ target_link_libraries (glog PUBLIC ${CMAKE_THREAD_LIBS_INIT})
+endif (HAVE_PTHREAD)
+
if (WIN32 AND HAVE_SNPRINTF)
set_property (SOURCE src/windows/port.cc APPEND PROPERTY COMPILE_DEFINITIONS
HAVE_SNPRINTF)
target_include_directories (glog BEFORE PUBLIC
"$<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>"
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>"
+ "$<INSTALL_INTERFACE:include>"
PRIVATE ${CMAKE_CURRENT_BINARY_DIR}
PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
LIBRARY DESTINATION lib
ARCHIVE DESTINATION lib)
-# Build tree config
-
-set (glog_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
-set (glog_PACKAGE_DEPS)
-
if (gflags_FOUND)
- set (glog_PACKAGE_DEPS
-"
-include (CMakeFindDependencyMacro)
-
-find_dependency (gflags ${gflags_VERSION})
-")
+ set (gflags_DEPENDENCY "find_dependency (gflags ${gflags_VERSION})")
endif (gflags_FOUND)
configure_package_config_file (glog-config.cmake.in
- ${CMAKE_CURRENT_BINARY_DIR}/glog-config.cmake INSTALL_DESTINATION
- lib/cmake/glog PATH_VARS glog_INCLUDE_DIR
+ ${CMAKE_CURRENT_BINARY_DIR}/glog-config.cmake
+ INSTALL_DESTINATION lib/cmake/glog
NO_CHECK_REQUIRED_COMPONENTS_MACRO)
-# The version file is the same both for build tree and install mode config
write_basic_package_version_file (glog-config-version.cmake VERSION
${GLOG_VERSION} COMPATIBILITY SameMajorVersion)
-# Install config
-
-set (glog_INCLUDE_DIR include)
-
-configure_package_config_file (glog-config.cmake.in
- ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/glog-config.cmake
- INSTALL_DESTINATION lib/cmake/glog PATH_VARS glog_INCLUDE_DIR
- NO_CHECK_REQUIRED_COMPONENTS_MACRO)
-
-export (TARGETS glog FILE glog-targets.cmake)
+export (TARGETS glog NAMESPACE glog:: FILE glog-targets.cmake)
export (PACKAGE glog)
install (FILES
- ${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/glog-config.cmake
+ ${CMAKE_CURRENT_BINARY_DIR}/glog-config.cmake
${CMAKE_CURRENT_BINARY_DIR}/glog-config-version.cmake
DESTINATION lib/cmake/glog)
-install (EXPORT glog-targets DESTINATION lib/cmake/glog)
+install (EXPORT glog-targets NAMESPACE glog:: DESTINATION lib/cmake/glog)
#
# Please keep the list sorted.
+Abhishek Dasgupta <abhi2743@gmail.com>
Abhishek Parmar <abhishek@orng.net>
Brian Silverman <bsilver16384@gmail.com>
Fumitoshi Ukai <ukai@google.com>
Håkan L. S. Younes <hyounes@google.com>
Ivan Penkov <ivanpe@google.com>
Michael Tanner <michael@tannertaxpro.com>
+Peter Collingbourne <pcc@google.com>
romange <romange@users.noreply.github.com>
Sergiu Dotenco <sergiu.dotenco@th-nuernberg.de>
Shinichiro Hamaji <hamaji@google.com>
--- /dev/null
+Building Glog with CMake
+========================
+
+1. Create a build directory and `cd` to it.
+2. Run
+ ```bash
+ cmake path/to/glog
+ ```
+
+3. Afterwards, generated files (GNU make, Visual Studio, etc.) can be used to
+ compile the project.
+
+
+Consuming Glog in a CMake Project
+=================================
+
+To use Glog in your project `myproj`, use:
+
+```cmake
+cmake_minimum_required (VERSION 3.0)
+project (myproj)
+
+find_package (glog 0.3.4 REQUIRED)
+
+add_executable (myapp main.cpp)
+target_link_libraries (myapp glog::glog)
+```
+
+Compile definitions and options will be added automatically to your target as
+needed.
ppc64:Linux:*:*)
echo powerpc64-unknown-linux-gnu
exit ;;
+ ppc64le:Linux:*:*)
+ echo powerpc64le-unknown-linux-gnu
+ exit ;;
alpha:Linux:*:*)
case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in
EV5) UNAME_MACHINE=alphaev5 ;;
@PACKAGE_INIT@
-include ("${CMAKE_CURRENT_LIST_DIR}/glog-targets.cmake")
-set_and_check (glog_INCLUDE_DIR "@PACKAGE_glog_INCLUDE_DIR@")
-
-@glog_PACKAGE_DEPS@
+include (CMakeFindDependencyMacro)
-set (glog_LIBRARY glog)
+@gflags_DEPENDENCY@
-set (glog_LIBRARIES ${glog_LIBRARY})
-set (glog_INCLUDE_DIRS ${glog_INCLUDE_DIR})
+include ("${CMAKE_CURRENT_LIST_DIR}/glog-targets.cmake")
struct CompileAssert {
};
struct CrashReason;
+
+// Returns true if FailureSignalHandler is installed.
+bool IsFailureSignalHandlerInstalled();
} // namespace glog_internal_namespace_
#define GOOGLE_GLOG_COMPILE_ASSERT(expr, msg) \
using std::fdopen;
#endif
+#ifdef _WIN32
+#define fdopen _fdopen
+#endif
+
// There is no thread annotation support.
#define EXCLUSIVE_LOCKS_REQUIRED(mu)
// assume we have the log_mutex or we simply don't care
// about it
for (int i = min_severity; i < NUM_SEVERITIES; i++) {
- LogDestination* log = log_destination(i);
+ LogDestination* log = log_destinations_[i];
if (log != NULL) {
// Flush the base fileobject_ logger directly instead of going
// through any wrappers to reduce chance of deadlock.
LOG(FATAL) << "No directory separator.";
}
const string dirname = pattern.substr(0, index + 1);
- if (FAILED(handle)) {
+ if (handle == INVALID_HANDLE_VALUE) {
// Finding no files is OK.
return;
}
do {
files->push_back(dirname + data.cFileName);
} while (FindNextFileA(handle, &data));
- LOG_SYSRESULT(FindClose(handle));
+ BOOL result = FindClose(handle);
+ LOG_SYSRESULT(result);
#else
# error There is no way to do glob.
#endif
#endif // HAVE_SIGACTION
+namespace glog_internal_namespace_ {
+
+bool IsFailureSignalHandlerInstalled() {
+#ifdef HAVE_SIGACTION
+ struct sigaction sig_action;
+ memset(&sig_action, 0, sizeof(sig_action));
+ sigemptyset(&sig_action.sa_mask);
+ sigaction(SIGABRT, NULL, &sig_action);
+ if (sig_action.sa_sigaction == &FailureSignalHandler)
+ return true;
+#endif // HAVE_SIGACTION
+ return false;
+}
+
+} // namespace glog_internal_namespace_
+
void InstallFailureSignalHandler() {
#ifdef HAVE_SIGACTION
// Build the sigaction struct.
#ifdef HAVE_LIB_GFLAGS
#include <gflags/gflags.h>
-using namespace gflags;
+using namespace GFLAGS_NAMESPACE;
#endif
using namespace GOOGLE_NAMESPACE;
result[n++] = *(sp+2);
#elif defined(_CALL_SYSV)
result[n++] = *(sp+1);
-#elif defined(__APPLE__) || (defined(__linux) && defined(__PPC64__))
+#elif defined(__APPLE__) || ((defined(__linux) || defined(__linux__)) && defined(__PPC64__))
// This check is in case the compiler doesn't define _CALL_AIX/etc.
result[n++] = *(sp+2);
#elif defined(__linux)
// false.
static bool GetSymbolFromObjectFile(const int fd, uint64_t pc,
char *out, int out_size,
- uint64_t map_start_address) {
+ uint64_t map_base_address) {
// Read the ELF header.
ElfW(Ehdr) elf_header;
if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
uint64_t symbol_offset = 0;
if (elf_header.e_type == ET_DYN) { // DSO needs offset adjustment.
- symbol_offset = map_start_address;
+ ElfW(Phdr) phdr;
+ // We need to find the PT_LOAD segment corresponding to the read-execute
+ // file mapping in order to correctly perform the offset adjustment.
+ for (unsigned i = 0; i != elf_header.e_phnum; ++i) {
+ if (!ReadFromOffsetExact(fd, &phdr, sizeof(phdr),
+ elf_header.e_phoff + i * sizeof(phdr)))
+ return false;
+ if (phdr.p_type == PT_LOAD &&
+ (phdr.p_flags & (PF_R | PF_X)) == (PF_R | PF_X)) {
+ // Find the mapped address corresponding to virtual address zero. We do
+ // this by first adding p_offset. This gives us the mapped address of
+ // the start of the segment, or in other words the mapped address
+ // corresponding to the virtual address of the segment. (Note that this
+ // is distinct from the start address, as p_offset is not guaranteed to
+ // be page aligned.) We then subtract p_vaddr, which takes us to virtual
+ // address zero.
+ symbol_offset = map_base_address + phdr.p_offset - phdr.p_vaddr;
+ break;
+ }
+ }
+ if (symbol_offset == 0)
+ return false;
}
ElfW(Shdr) symtab, strtab;
return -1; // Malformed line.
}
- // Check flags. We are only interested in "r-x" maps.
- if (memcmp(flags_start, "r-x", 3) != 0) { // Not a "r-x" map.
+ // Check flags. We are only interested in "r*x" maps.
+ if (flags_start[0] != 'r' || flags_start[2] != 'x') {
continue; // We skip this map.
}
++cursor; // Skip ' '.
}
}
if (!GetSymbolFromObjectFile(wrapped_object_fd.get(), pc0,
- out, out_size, start_address)) {
+ out, out_size, base_address)) {
return false;
}
// TOOD(hamaji): Use signal instead of sigaction?
#ifdef HAVE_SIGACTION
- // Set the default signal handler for SIGABRT, to avoid invoking our
- // own signal handler installed by InstallFailedSignalHandler().
- struct sigaction sig_action;
- memset(&sig_action, 0, sizeof(sig_action));
- sigemptyset(&sig_action.sa_mask);
- sig_action.sa_handler = SIG_DFL;
- sigaction(SIGABRT, &sig_action, NULL);
+ if (IsFailureSignalHandlerInstalled()) {
+ // Set the default signal handler for SIGABRT, to avoid invoking our
+ // own signal handler installed by InstallFailureSignalHandler().
+ struct sigaction sig_action;
+ memset(&sig_action, 0, sizeof(sig_action));
+ sigemptyset(&sig_action.sa_mask);
+ sig_action.sa_handler = SIG_DFL;
+ sigaction(SIGABRT, &sig_action, NULL);
+ }
#endif // HAVE_SIGACTION
abort();
#endif
#include <vector>
-// Annoying stuff for windows -- makes sure clients can import these functions
-#ifndef GOOGLE_GLOG_DLL_DECL
-# if defined(_WIN32) && !defined(__CYGWIN__)
-# define GOOGLE_GLOG_DLL_DECL __declspec(dllimport)
-# else
-# define GOOGLE_GLOG_DLL_DECL
-# endif
-#endif
#if defined(_MSC_VER)
#define GLOG_MSVC_PUSH_DISABLE_WARNING(n) __pragma(warning(push)) \
__pragma(warning(disable:n))
#define GLOG_MSVC_POP_WARNING()
#endif
+// Annoying stuff for windows -- makes sure clients can import these functions
+#ifndef GOOGLE_GLOG_DLL_DECL
+# if defined(_WIN32) && !defined(__CYGWIN__)
+# define GOOGLE_GLOG_DLL_DECL __declspec(dllimport)
+# else
+# define GOOGLE_GLOG_DLL_DECL
+# endif
+#endif
+
// We care a lot about number of bits things take up. Unfortunately,
// systems define their bit-specific ints in a lot of different ways.
// We use our own way, and have a typedef to get there.
#ifndef GOOGLE_PREDICT_BRANCH_NOT_TAKEN
#if 0
#define GOOGLE_PREDICT_BRANCH_NOT_TAKEN(x) (__builtin_expect(x, 0))
-#define GOOGLE_PREDICT_FALSE(x) (__builtin_expect(x, 0))
-#define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
#else
#define GOOGLE_PREDICT_BRANCH_NOT_TAKEN(x) x
+#endif
+#endif
+
+#ifndef GOOGLE_PREDICT_FALSE
+#if 0
+#define GOOGLE_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#else
#define GOOGLE_PREDICT_FALSE(x) x
+#endif
+#endif
+
+#ifndef GOOGLE_PREDICT_TRUE
+#if 0
+#define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
#define GOOGLE_PREDICT_TRUE(x) x
#endif
#endif
+
// Make a bunch of macros for logging. The way to log things is to stream
// things to LOG(<a particular severity level>). E.g.,
//
// default logging directory.
DECLARE_string(log_dir);
+// Set the log file mode.
+DECLARE_int32(logfile_mode);
+
// Sets the path of the directory into which to put additional links
// to the log files.
DECLARE_string(log_link);
// vector<string> *outvec;
// The cast is to disambiguate NULL arguments.
#define LOG_STRING(severity, outvec) \
- LOG_TO_STRING_##severity(static_cast<vector<string>*>(outvec)).stream()
+ LOG_TO_STRING_##severity(static_cast<std::vector<std::string>*>(outvec)).stream()
#define LOG_IF(severity, condition) \
!(condition) ? (void) 0 : google::LogMessageVoidify() & LOG(severity)
// to reduce the overhead of CHECK statments by 2x.
// Real DCHECK-heavy tests have seen 1.5x speedups.
-// The meaning of "string" might be different between now and
+// The meaning of "string" might be different between now and
// when this macro gets invoked (e.g., if someone is experimenting
// with other string implementations that get defined after this
-// file is included). Save the current meaning now and use it
+// file is included). Save the current meaning now and use it
// in the macro.
typedef std::string _Check_string;
#define CHECK_OP_LOG(name, op, val1, val2, log) \
struct CompileAssert {
};
struct CrashReason;
+
+// Returns true if FailureSignalHandler is installed.
+bool IsFailureSignalHandlerInstalled();
} // namespace glog_internal_namespace_
#define GOOGLE_GLOG_COMPILE_ASSERT(expr, msg) \
char* str() const { return pbase(); }
private:
+ LogStream(const LogStream&);
+ LogStream& operator=(const LogStream&);
base_logging::LogStreamBuf streambuf_;
int ctr_; // Counter hack (for the LOG_EVERY_X() macro)
LogStream *self_; // Consistency check hack
void SendToSyslogAndLog(); // Actually dispatch to syslog and the logs
// Call abort() or similar to perform LOG(FATAL) crash.
- static void Fail() ;
+ static void Fail();
std::ostream& stream();
public:
LogMessageFatal(const char* file, int line);
LogMessageFatal(const char* file, int line, const CheckOpString& result);
- ~LogMessageFatal() ;
+ ~LogMessageFatal();
};
// A non-macro interface to the log facility; (useful
NullStreamFatal() { }
NullStreamFatal(const char* file, int line, const CheckOpString& result) :
NullStream(file, line, result) { }
- ~NullStreamFatal() { _exit(1); }
+ ~NullStreamFatal() throw () { _exit(1); }
};
// Install a signal handler that will dump signal information and a stack
projects / platform / upstream / glog.git / commitdiff