1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- MCWinEH.h - Windows Unwinding Support --------------------*- 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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_MC_MCWINEH_H
#define LLVM_MC_MCWINEH_H
#include "llvm/ADT/MapVector.h"
#include <vector>
namespace llvm {
class MCSection;
class MCStreamer;
class MCSymbol;
namespace WinEH {
struct Instruction {
const MCSymbol *Label;
unsigned Offset;
unsigned Register;
unsigned Operation;
Instruction(unsigned Op, MCSymbol *L, unsigned Reg, unsigned Off)
: Label(L), Offset(Off), Register(Reg), Operation(Op) {}
bool operator==(const Instruction &I) const {
// Check whether two instructions refer to the same operation
// applied at a different spot (i.e. pointing at a different label).
return Offset == I.Offset && Register == I.Register &&
Operation == I.Operation;
}
bool operator!=(const Instruction &I) const { return !(*this == I); }
};
struct FrameInfo {
const MCSymbol *Begin = nullptr;
const MCSymbol *End = nullptr;
const MCSymbol *FuncletOrFuncEnd = nullptr;
const MCSymbol *ExceptionHandler = nullptr;
const MCSymbol *Function = nullptr;
const MCSymbol *PrologEnd = nullptr;
const MCSymbol *Symbol = nullptr;
MCSection *TextSection = nullptr;
uint32_t PackedInfo = 0;
uint32_t PrologCodeBytes = 0;
bool HandlesUnwind = false;
bool HandlesExceptions = false;
bool EmitAttempted = false;
bool Fragment = false;
int LastFrameInst = -1;
const FrameInfo *ChainedParent = nullptr;
std::vector<Instruction> Instructions;
struct Epilog {
std::vector<Instruction> Instructions;
unsigned Condition;
MCSymbol *End;
};
MapVector<MCSymbol *, Epilog> EpilogMap;
// For splitting unwind info of large functions
struct Segment {
int64_t Offset;
int64_t Length;
bool HasProlog;
MCSymbol *Symbol;
// Map an Epilog's symbol to its offset within the function.
MapVector<MCSymbol *, int64_t> Epilogs;
Segment(int64_t Offset, int64_t Length, bool HasProlog = false)
: Offset(Offset), Length(Length), HasProlog(HasProlog) {}
};
std::vector<Segment> Segments;
FrameInfo() = default;
FrameInfo(const MCSymbol *Function, const MCSymbol *BeginFuncEHLabel)
: Begin(BeginFuncEHLabel), Function(Function) {}
FrameInfo(const MCSymbol *Function, const MCSymbol *BeginFuncEHLabel,
const FrameInfo *ChainedParent)
: Begin(BeginFuncEHLabel), Function(Function),
ChainedParent(ChainedParent) {}
bool empty() const {
if (!Instructions.empty())
return false;
for (const auto &E : EpilogMap)
if (!E.second.Instructions.empty())
return false;
return true;
}
};
class UnwindEmitter {
public:
virtual ~UnwindEmitter();
/// This emits the unwind info sections (.pdata and .xdata in PE/COFF).
virtual void Emit(MCStreamer &Streamer) const = 0;
virtual void EmitUnwindInfo(MCStreamer &Streamer, FrameInfo *FI,
bool HandlerData) const = 0;
};
}
}
#endif
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
