mirror of
https://github.com/RPCS3/llvm.git
synced 2026-01-31 01:25:19 +01:00
6b547686c5
to reflect the new license. We understand that people may be surprised that we're moving the header entirely to discuss the new license. We checked this carefully with the Foundation's lawyer and we believe this is the correct approach. Essentially, all code in the project is now made available by the LLVM project under our new license, so you will see that the license headers include that license only. Some of our contributors have contributed code under our old license, and accordingly, we have retained a copy of our old license notice in the top-level files in each project and repository. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@351636 91177308-0d34-0410-b5e6-96231b3b80d8
96 lines
3.7 KiB
C++
96 lines
3.7 KiB
C++
//===- llvm/Support/PrettyStackTrace.h - Pretty Crash Handling --*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the PrettyStackTraceEntry class, which is used to make
|
|
// crashes give more contextual information about what the program was doing
|
|
// when it crashed.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_SUPPORT_PRETTYSTACKTRACE_H
|
|
#define LLVM_SUPPORT_PRETTYSTACKTRACE_H
|
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/Compiler.h"
|
|
|
|
namespace llvm {
|
|
class raw_ostream;
|
|
|
|
void EnablePrettyStackTrace();
|
|
|
|
/// PrettyStackTraceEntry - This class is used to represent a frame of the
|
|
/// "pretty" stack trace that is dumped when a program crashes. You can define
|
|
/// subclasses of this and declare them on the program stack: when they are
|
|
/// constructed and destructed, they will add their symbolic frames to a
|
|
/// virtual stack trace. This gets dumped out if the program crashes.
|
|
class PrettyStackTraceEntry {
|
|
friend PrettyStackTraceEntry *ReverseStackTrace(PrettyStackTraceEntry *);
|
|
|
|
PrettyStackTraceEntry *NextEntry;
|
|
PrettyStackTraceEntry(const PrettyStackTraceEntry &) = delete;
|
|
void operator=(const PrettyStackTraceEntry &) = delete;
|
|
public:
|
|
PrettyStackTraceEntry();
|
|
virtual ~PrettyStackTraceEntry();
|
|
|
|
/// print - Emit information about this stack frame to OS.
|
|
virtual void print(raw_ostream &OS) const = 0;
|
|
|
|
/// getNextEntry - Return the next entry in the list of frames.
|
|
const PrettyStackTraceEntry *getNextEntry() const { return NextEntry; }
|
|
};
|
|
|
|
/// PrettyStackTraceString - This object prints a specified string (which
|
|
/// should not contain newlines) to the stream as the stack trace when a crash
|
|
/// occurs.
|
|
class PrettyStackTraceString : public PrettyStackTraceEntry {
|
|
const char *Str;
|
|
public:
|
|
PrettyStackTraceString(const char *str) : Str(str) {}
|
|
void print(raw_ostream &OS) const override;
|
|
};
|
|
|
|
/// PrettyStackTraceFormat - This object prints a string (which may use
|
|
/// printf-style formatting but should not contain newlines) to the stream
|
|
/// as the stack trace when a crash occurs.
|
|
class PrettyStackTraceFormat : public PrettyStackTraceEntry {
|
|
llvm::SmallVector<char, 32> Str;
|
|
public:
|
|
PrettyStackTraceFormat(const char *Format, ...);
|
|
void print(raw_ostream &OS) const override;
|
|
};
|
|
|
|
/// PrettyStackTraceProgram - This object prints a specified program arguments
|
|
/// to the stream as the stack trace when a crash occurs.
|
|
class PrettyStackTraceProgram : public PrettyStackTraceEntry {
|
|
int ArgC;
|
|
const char *const *ArgV;
|
|
public:
|
|
PrettyStackTraceProgram(int argc, const char * const*argv)
|
|
: ArgC(argc), ArgV(argv) {
|
|
EnablePrettyStackTrace();
|
|
}
|
|
void print(raw_ostream &OS) const override;
|
|
};
|
|
|
|
/// Returns the topmost element of the "pretty" stack state.
|
|
const void *SavePrettyStackState();
|
|
|
|
/// Restores the topmost element of the "pretty" stack state to State, which
|
|
/// should come from a previous call to SavePrettyStackState(). This is
|
|
/// useful when using a CrashRecoveryContext in code that also uses
|
|
/// PrettyStackTraceEntries, to make sure the stack that's printed if a crash
|
|
/// happens after a crash that's been recovered by CrashRecoveryContext
|
|
/// doesn't have frames on it that were added in code unwound by the
|
|
/// CrashRecoveryContext.
|
|
void RestorePrettyStackState(const void *State);
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|