MCWin64EH.cpp revision c4cbf9b6aa95cf861a5a80bfccf615ff5c53e4ef 
1//===- lib/MC/MCWin64EH.cpp - MCWin64EH implementation --------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "llvm/MC/MCWin64EH.h"
11#include "llvm/MC/MCStreamer.h"
12#include "llvm/MC/MCContext.h"
13#include "llvm/MC/MCExpr.h"
14#include "llvm/Target/TargetAsmInfo.h"
15
16namespace llvm {
17
18// NOTE: All relocations generated here are 4-byte image-relative.
19
20static uint8_t CountOfUnwindCodes(std::vector<MCWin64EHInstruction> &instArray){
21  uint8_t count = 0;
22  for (std::vector<MCWin64EHInstruction>::const_iterator I = instArray.begin(),
23       E = instArray.end(); I != E; ++I) {
24    switch (I->getOperation()) {
25    case Win64EH::UOP_PushNonVol:
26    case Win64EH::UOP_AllocSmall:
27    case Win64EH::UOP_SetFPReg:
28    case Win64EH::UOP_PushMachFrame:
29      count += 1;
30      break;
31    case Win64EH::UOP_SaveNonVol:
32    case Win64EH::UOP_SaveXMM128:
33      count += 2;
34      break;
35    case Win64EH::UOP_SaveNonVolBig:
36    case Win64EH::UOP_SaveXMM128Big:
37      count += 3;
38      break;
39    case Win64EH::UOP_AllocLarge:
40      if (I->getSize() > 512*1024-8)
41        count += 3;
42      else
43        count += 2;
44      break;
45    }
46  }
47  return count;
48}
49
50static void EmitAbsDifference(MCStreamer &streamer, MCSymbol *lhs,
51                              MCSymbol *rhs) {
52  MCContext &context = streamer.getContext();
53  const MCExpr *diff = MCBinaryExpr::CreateSub(MCSymbolRefExpr::Create(
54                                                                  lhs, context),
55                                               MCSymbolRefExpr::Create(
56                                                                  rhs, context),
57                                               context);
58  streamer.EmitAbsValue(diff, 1);
59
60}
61
62static void EmitUnwindCode(MCStreamer &streamer, MCSymbol *begin,
63                           MCWin64EHInstruction &inst) {
64  uint8_t b1, b2;
65  uint16_t w;
66  b2 = (inst.getOperation() & 0x0F) << 4;
67  switch (inst.getOperation()) {
68  case Win64EH::UOP_PushNonVol:
69    EmitAbsDifference(streamer, inst.getLabel(), begin);
70    b2 |= inst.getRegister() & 0x0F;
71    streamer.EmitIntValue(b2, 1);
72    break;
73  case Win64EH::UOP_AllocLarge:
74    EmitAbsDifference(streamer, inst.getLabel(), begin);
75    if (inst.getSize() > 512*1024-8) {
76      b2 |= 1;
77      streamer.EmitIntValue(b2, 1);
78      w = inst.getSize() & 0xFFF8;
79      streamer.EmitIntValue(w, 2);
80      w = inst.getSize() >> 16;
81    } else {
82      streamer.EmitIntValue(b2, 1);
83      w = inst.getSize() >> 3;
84    }
85    streamer.EmitIntValue(w, 2);
86    break;
87  case Win64EH::UOP_AllocSmall:
88    b2 |= ((inst.getSize()-8) >> 3) & 0x0F;
89    EmitAbsDifference(streamer, inst.getLabel(), begin);
90    streamer.EmitIntValue(b2, 1);
91    break;
92  case Win64EH::UOP_SetFPReg:
93    b1 = inst.getOffset() & 0xF0;
94    streamer.EmitIntValue(b1, 1);
95    streamer.EmitIntValue(b2, 1);
96    break;
97  case Win64EH::UOP_SaveNonVol:
98  case Win64EH::UOP_SaveXMM128:
99    b2 |= inst.getRegister() & 0x0F;
100    EmitAbsDifference(streamer, inst.getLabel(), begin);
101    streamer.EmitIntValue(b2, 1);
102    w = inst.getOffset() >> 3;
103    if (inst.getOperation() == Win64EH::UOP_SaveXMM128)
104      w >>= 1;
105    streamer.EmitIntValue(w, 2);
106    break;
107  case Win64EH::UOP_SaveNonVolBig:
108  case Win64EH::UOP_SaveXMM128Big:
109    b2 |= inst.getRegister() & 0x0F;
110    EmitAbsDifference(streamer, inst.getLabel(), begin);
111    streamer.EmitIntValue(b2, 1);
112    if (inst.getOperation() == Win64EH::UOP_SaveXMM128Big)
113      w = inst.getOffset() & 0xFFF0;
114    else
115      w = inst.getOffset() & 0xFFF8;
116    streamer.EmitIntValue(w, 2);
117    w = inst.getOffset() >> 16;
118    streamer.EmitIntValue(w, 2);
119    break;
120  case Win64EH::UOP_PushMachFrame:
121    if (inst.isPushCodeFrame())
122      b2 |= 1;
123    EmitAbsDifference(streamer, inst.getLabel(), begin);
124    streamer.EmitIntValue(b2, 1);
125    break;
126  }
127}
128
129static void EmitRuntimeFunction(MCStreamer &streamer,
130                                const MCWin64EHUnwindInfo *info) {
131  MCContext &context = streamer.getContext();
132
133  streamer.EmitValueToAlignment(4);
134  streamer.EmitValue(MCSymbolRefExpr::Create(info->Begin, context), 4);
135  streamer.EmitValue(MCSymbolRefExpr::Create(info->End, context), 4);
136  streamer.EmitValue(MCSymbolRefExpr::Create(info->Symbol, context), 4);
137}
138
139static void EmitUnwindInfo(MCStreamer &streamer, MCWin64EHUnwindInfo *info) {
140  // If this UNWIND_INFO already has a symbol, it's already been emitted.
141  if (info->Symbol) return;
142
143  MCContext &context = streamer.getContext();
144  streamer.EmitValueToAlignment(4);
145  // Upper 3 bits are the version number (currently 1).
146  uint8_t flags = 0x20;
147  info->Symbol = context.CreateTempSymbol();
148  streamer.EmitLabel(info->Symbol);
149
150  if (info->ChainedParent)
151    flags |= Win64EH::UNW_ChainInfo;
152  else {
153    if (info->HandlesUnwind)
154      flags |= Win64EH::UNW_TerminateHandler;
155    if (info->HandlesExceptions)
156      flags |= Win64EH::UNW_ExceptionHandler;
157  }
158  streamer.EmitIntValue(flags, 1);
159
160  EmitAbsDifference(streamer, info->PrologEnd, info->Begin);
161
162  uint8_t numCodes = CountOfUnwindCodes(info->Instructions);
163  streamer.EmitIntValue(numCodes, 1);
164
165  uint8_t frame = 0;
166  if (info->LastFrameInst >= 0) {
167    MCWin64EHInstruction &frameInst = info->Instructions[info->LastFrameInst];
168    assert(frameInst.getOperation() == Win64EH::UOP_SetFPReg);
169    frame = ((frameInst.getRegister() & 0x0F) << 4) |
170            ((frameInst.getOffset() >> 4) & 0x0F);
171  }
172  streamer.EmitIntValue(frame, 1);
173
174  // Emit unwind instructions (in reverse order).
175  uint8_t numInst = info->Instructions.size();
176  for (uint8_t c = 0; c < numInst; ++c) {
177    MCWin64EHInstruction inst = info->Instructions.back();
178    info->Instructions.pop_back();
179    EmitUnwindCode(streamer, info->Begin, inst);
180  }
181
182  if (flags & Win64EH::UNW_ChainInfo)
183    EmitRuntimeFunction(streamer, info->ChainedParent);
184  else if (flags &(Win64EH::UNW_TerminateHandler|Win64EH::UNW_ExceptionHandler))
185    streamer.EmitValue(MCSymbolRefExpr::Create(info->ExceptionHandler, context),
186                       4);
187}
188
189void MCWin64EHUnwindEmitter::EmitUnwindInfo(MCStreamer &streamer,
190                                            MCWin64EHUnwindInfo *info) {
191  // Switch sections (the static function above is meant to be called from
192  // here and from Emit().
193  MCContext &context = streamer.getContext();
194  const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
195  const MCSection *xdataSect = asmInfo.getWin64EHTableSection();
196  streamer.SwitchSection(xdataSect);
197
198  llvm::EmitUnwindInfo(streamer, info);
199}
200
201void MCWin64EHUnwindEmitter::Emit(MCStreamer &streamer) {
202  MCContext &context = streamer.getContext();
203  // Emit the unwind info structs first.
204  const TargetAsmInfo &asmInfo = context.getTargetAsmInfo();
205  const MCSection *xdataSect = asmInfo.getWin64EHTableSection();
206  streamer.SwitchSection(xdataSect);
207  for (unsigned i = 0; i < streamer.getNumW64UnwindInfos(); ++i)
208    llvm::EmitUnwindInfo(streamer, &streamer.getW64UnwindInfo(i));
209  // Now emit RUNTIME_FUNCTION entries.
210  const MCSection *pdataSect = asmInfo.getWin64EHFuncTableSection();
211  streamer.SwitchSection(pdataSect);
212  for (unsigned i = 0; i < streamer.getNumW64UnwindInfos(); ++i)
213    EmitRuntimeFunction(streamer, &streamer.getW64UnwindInfo(i));
214}
215
216} // End of namespace llvm
217
218