1//===----- JITDwarfEmitter.cpp - Write dwarf tables into memory -----------===//
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// This file defines a JITDwarfEmitter object that is used by the JIT to
11// write dwarf tables to memory.
12//
13//===----------------------------------------------------------------------===//
14
15#include "JIT.h"
16#include "JITDwarfEmitter.h"
17#include "llvm/Function.h"
18#include "llvm/ADT/DenseMap.h"
19#include "llvm/CodeGen/JITCodeEmitter.h"
20#include "llvm/CodeGen/MachineFunction.h"
21#include "llvm/CodeGen/MachineModuleInfo.h"
22#include "llvm/ExecutionEngine/JITMemoryManager.h"
23#include "llvm/MC/MachineLocation.h"
24#include "llvm/MC/MCAsmInfo.h"
25#include "llvm/MC/MCSymbol.h"
26#include "llvm/Support/ErrorHandling.h"
27#include "llvm/Target/TargetData.h"
28#include "llvm/Target/TargetInstrInfo.h"
29#include "llvm/Target/TargetFrameLowering.h"
30#include "llvm/Target/TargetMachine.h"
31#include "llvm/Target/TargetRegisterInfo.h"
32using namespace llvm;
33
34JITDwarfEmitter::JITDwarfEmitter(JIT& theJit) : MMI(0), Jit(theJit) {}
35
36
37unsigned char* JITDwarfEmitter::EmitDwarfTable(MachineFunction& F,
38                                               JITCodeEmitter& jce,
39                                               unsigned char* StartFunction,
40                                               unsigned char* EndFunction,
41                                               unsigned char* &EHFramePtr) {
42  assert(MMI && "MachineModuleInfo not registered!");
43
44  const TargetMachine& TM = F.getTarget();
45  TD = TM.getTargetData();
46  stackGrowthDirection = TM.getFrameLowering()->getStackGrowthDirection();
47  RI = TM.getRegisterInfo();
48  MAI = TM.getMCAsmInfo();
49  JCE = &jce;
50
51  unsigned char* ExceptionTable = EmitExceptionTable(&F, StartFunction,
52                                                     EndFunction);
53
54  unsigned char* Result = 0;
55
56  const std::vector<const Function *> Personalities = MMI->getPersonalities();
57  EHFramePtr = EmitCommonEHFrame(Personalities[MMI->getPersonalityIndex()]);
58
59  Result = EmitEHFrame(Personalities[MMI->getPersonalityIndex()], EHFramePtr,
60                       StartFunction, EndFunction, ExceptionTable);
61
62  return Result;
63}
64
65
66void
67JITDwarfEmitter::EmitFrameMoves(intptr_t BaseLabelPtr,
68                                const std::vector<MachineMove> &Moves) const {
69  unsigned PointerSize = TD->getPointerSize();
70  int stackGrowth = stackGrowthDirection == TargetFrameLowering::StackGrowsUp ?
71          PointerSize : -PointerSize;
72  MCSymbol *BaseLabel = 0;
73
74  for (unsigned i = 0, N = Moves.size(); i < N; ++i) {
75    const MachineMove &Move = Moves[i];
76    MCSymbol *Label = Move.getLabel();
77
78    // Throw out move if the label is invalid.
79    if (Label && (*JCE->getLabelLocations())[Label] == 0)
80      continue;
81
82    intptr_t LabelPtr = 0;
83    if (Label) LabelPtr = JCE->getLabelAddress(Label);
84
85    const MachineLocation &Dst = Move.getDestination();
86    const MachineLocation &Src = Move.getSource();
87
88    // Advance row if new location.
89    if (BaseLabelPtr && Label && BaseLabel != Label) {
90      JCE->emitByte(dwarf::DW_CFA_advance_loc4);
91      JCE->emitInt32(LabelPtr - BaseLabelPtr);
92
93      BaseLabel = Label;
94      BaseLabelPtr = LabelPtr;
95    }
96
97    // If advancing cfa.
98    if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) {
99      if (!Src.isReg()) {
100        if (Src.getReg() == MachineLocation::VirtualFP) {
101          JCE->emitByte(dwarf::DW_CFA_def_cfa_offset);
102        } else {
103          JCE->emitByte(dwarf::DW_CFA_def_cfa);
104          JCE->emitULEB128Bytes(RI->getDwarfRegNum(Src.getReg(), true));
105        }
106
107        JCE->emitULEB128Bytes(-Src.getOffset());
108      } else {
109        llvm_unreachable("Machine move not supported yet.");
110      }
111    } else if (Src.isReg() &&
112      Src.getReg() == MachineLocation::VirtualFP) {
113      if (Dst.isReg()) {
114        JCE->emitByte(dwarf::DW_CFA_def_cfa_register);
115        JCE->emitULEB128Bytes(RI->getDwarfRegNum(Dst.getReg(), true));
116      } else {
117        llvm_unreachable("Machine move not supported yet.");
118      }
119    } else {
120      unsigned Reg = RI->getDwarfRegNum(Src.getReg(), true);
121      int Offset = Dst.getOffset() / stackGrowth;
122
123      if (Offset < 0) {
124        JCE->emitByte(dwarf::DW_CFA_offset_extended_sf);
125        JCE->emitULEB128Bytes(Reg);
126        JCE->emitSLEB128Bytes(Offset);
127      } else if (Reg < 64) {
128        JCE->emitByte(dwarf::DW_CFA_offset + Reg);
129        JCE->emitULEB128Bytes(Offset);
130      } else {
131        JCE->emitByte(dwarf::DW_CFA_offset_extended);
132        JCE->emitULEB128Bytes(Reg);
133        JCE->emitULEB128Bytes(Offset);
134      }
135    }
136  }
137}
138
139/// SharedTypeIds - How many leading type ids two landing pads have in common.
140static unsigned SharedTypeIds(const LandingPadInfo *L,
141                              const LandingPadInfo *R) {
142  const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
143  unsigned LSize = LIds.size(), RSize = RIds.size();
144  unsigned MinSize = LSize < RSize ? LSize : RSize;
145  unsigned Count = 0;
146
147  for (; Count != MinSize; ++Count)
148    if (LIds[Count] != RIds[Count])
149      return Count;
150
151  return Count;
152}
153
154
155/// PadLT - Order landing pads lexicographically by type id.
156static bool PadLT(const LandingPadInfo *L, const LandingPadInfo *R) {
157  const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds;
158  unsigned LSize = LIds.size(), RSize = RIds.size();
159  unsigned MinSize = LSize < RSize ? LSize : RSize;
160
161  for (unsigned i = 0; i != MinSize; ++i)
162    if (LIds[i] != RIds[i])
163      return LIds[i] < RIds[i];
164
165  return LSize < RSize;
166}
167
168namespace {
169
170/// ActionEntry - Structure describing an entry in the actions table.
171struct ActionEntry {
172  int ValueForTypeID; // The value to write - may not be equal to the type id.
173  int NextAction;
174  struct ActionEntry *Previous;
175};
176
177/// PadRange - Structure holding a try-range and the associated landing pad.
178struct PadRange {
179  // The index of the landing pad.
180  unsigned PadIndex;
181  // The index of the begin and end labels in the landing pad's label lists.
182  unsigned RangeIndex;
183};
184
185typedef DenseMap<MCSymbol*, PadRange> RangeMapType;
186
187/// CallSiteEntry - Structure describing an entry in the call-site table.
188struct CallSiteEntry {
189  MCSymbol *BeginLabel; // zero indicates the start of the function.
190  MCSymbol *EndLabel;   // zero indicates the end of the function.
191  MCSymbol *PadLabel;   // zero indicates that there is no landing pad.
192  unsigned Action;
193};
194
195}
196
197unsigned char* JITDwarfEmitter::EmitExceptionTable(MachineFunction* MF,
198                                         unsigned char* StartFunction,
199                                         unsigned char* EndFunction) const {
200  assert(MMI && "MachineModuleInfo not registered!");
201
202  // Map all labels and get rid of any dead landing pads.
203  MMI->TidyLandingPads(JCE->getLabelLocations());
204
205  const std::vector<const GlobalVariable *> &TypeInfos = MMI->getTypeInfos();
206  const std::vector<unsigned> &FilterIds = MMI->getFilterIds();
207  const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads();
208  if (PadInfos.empty()) return 0;
209
210  // Sort the landing pads in order of their type ids.  This is used to fold
211  // duplicate actions.
212  SmallVector<const LandingPadInfo *, 64> LandingPads;
213  LandingPads.reserve(PadInfos.size());
214  for (unsigned i = 0, N = PadInfos.size(); i != N; ++i)
215    LandingPads.push_back(&PadInfos[i]);
216  std::sort(LandingPads.begin(), LandingPads.end(), PadLT);
217
218  // Negative type ids index into FilterIds, positive type ids index into
219  // TypeInfos.  The value written for a positive type id is just the type
220  // id itself.  For a negative type id, however, the value written is the
221  // (negative) byte offset of the corresponding FilterIds entry.  The byte
222  // offset is usually equal to the type id, because the FilterIds entries
223  // are written using a variable width encoding which outputs one byte per
224  // entry as long as the value written is not too large, but can differ.
225  // This kind of complication does not occur for positive type ids because
226  // type infos are output using a fixed width encoding.
227  // FilterOffsets[i] holds the byte offset corresponding to FilterIds[i].
228  SmallVector<int, 16> FilterOffsets;
229  FilterOffsets.reserve(FilterIds.size());
230  int Offset = -1;
231  for(std::vector<unsigned>::const_iterator I = FilterIds.begin(),
232    E = FilterIds.end(); I != E; ++I) {
233    FilterOffsets.push_back(Offset);
234    Offset -= MCAsmInfo::getULEB128Size(*I);
235  }
236
237  // Compute the actions table and gather the first action index for each
238  // landing pad site.
239  SmallVector<ActionEntry, 32> Actions;
240  SmallVector<unsigned, 64> FirstActions;
241  FirstActions.reserve(LandingPads.size());
242
243  int FirstAction = 0;
244  unsigned SizeActions = 0;
245  for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
246    const LandingPadInfo *LP = LandingPads[i];
247    const std::vector<int> &TypeIds = LP->TypeIds;
248    const unsigned NumShared = i ? SharedTypeIds(LP, LandingPads[i-1]) : 0;
249    unsigned SizeSiteActions = 0;
250
251    if (NumShared < TypeIds.size()) {
252      unsigned SizeAction = 0;
253      ActionEntry *PrevAction = 0;
254
255      if (NumShared) {
256        const unsigned SizePrevIds = LandingPads[i-1]->TypeIds.size();
257        assert(Actions.size());
258        PrevAction = &Actions.back();
259        SizeAction = MCAsmInfo::getSLEB128Size(PrevAction->NextAction) +
260          MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
261        for (unsigned j = NumShared; j != SizePrevIds; ++j) {
262          SizeAction -= MCAsmInfo::getSLEB128Size(PrevAction->ValueForTypeID);
263          SizeAction += -PrevAction->NextAction;
264          PrevAction = PrevAction->Previous;
265        }
266      }
267
268      // Compute the actions.
269      for (unsigned I = NumShared, M = TypeIds.size(); I != M; ++I) {
270        int TypeID = TypeIds[I];
271        assert(-1-TypeID < (int)FilterOffsets.size() && "Unknown filter id!");
272        int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID;
273        unsigned SizeTypeID = MCAsmInfo::getSLEB128Size(ValueForTypeID);
274
275        int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0;
276        SizeAction = SizeTypeID + MCAsmInfo::getSLEB128Size(NextAction);
277        SizeSiteActions += SizeAction;
278
279        ActionEntry Action = {ValueForTypeID, NextAction, PrevAction};
280        Actions.push_back(Action);
281
282        PrevAction = &Actions.back();
283      }
284
285      // Record the first action of the landing pad site.
286      FirstAction = SizeActions + SizeSiteActions - SizeAction + 1;
287    } // else identical - re-use previous FirstAction
288
289    FirstActions.push_back(FirstAction);
290
291    // Compute this sites contribution to size.
292    SizeActions += SizeSiteActions;
293  }
294
295  // Compute the call-site table.  Entries must be ordered by address.
296  SmallVector<CallSiteEntry, 64> CallSites;
297
298  RangeMapType PadMap;
299  for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) {
300    const LandingPadInfo *LandingPad = LandingPads[i];
301    for (unsigned j=0, E = LandingPad->BeginLabels.size(); j != E; ++j) {
302      MCSymbol *BeginLabel = LandingPad->BeginLabels[j];
303      assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!");
304      PadRange P = { i, j };
305      PadMap[BeginLabel] = P;
306    }
307  }
308
309  bool MayThrow = false;
310  MCSymbol *LastLabel = 0;
311  for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
312        I != E; ++I) {
313    for (MachineBasicBlock::const_iterator MI = I->begin(), E = I->end();
314          MI != E; ++MI) {
315      if (!MI->isLabel()) {
316        MayThrow |= MI->isCall();
317        continue;
318      }
319
320      MCSymbol *BeginLabel = MI->getOperand(0).getMCSymbol();
321      assert(BeginLabel && "Invalid label!");
322
323      if (BeginLabel == LastLabel)
324        MayThrow = false;
325
326      RangeMapType::iterator L = PadMap.find(BeginLabel);
327
328      if (L == PadMap.end())
329        continue;
330
331      PadRange P = L->second;
332      const LandingPadInfo *LandingPad = LandingPads[P.PadIndex];
333
334      assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] &&
335              "Inconsistent landing pad map!");
336
337      // If some instruction between the previous try-range and this one may
338      // throw, create a call-site entry with no landing pad for the region
339      // between the try-ranges.
340      if (MayThrow) {
341        CallSiteEntry Site = {LastLabel, BeginLabel, 0, 0};
342        CallSites.push_back(Site);
343      }
344
345      LastLabel = LandingPad->EndLabels[P.RangeIndex];
346      CallSiteEntry Site = {BeginLabel, LastLabel,
347        LandingPad->LandingPadLabel, FirstActions[P.PadIndex]};
348
349      assert(Site.BeginLabel && Site.EndLabel && Site.PadLabel &&
350              "Invalid landing pad!");
351
352      // Try to merge with the previous call-site.
353      if (CallSites.size()) {
354        CallSiteEntry &Prev = CallSites.back();
355        if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) {
356          // Extend the range of the previous entry.
357          Prev.EndLabel = Site.EndLabel;
358          continue;
359        }
360      }
361
362      // Otherwise, create a new call-site.
363      CallSites.push_back(Site);
364    }
365  }
366  // If some instruction between the previous try-range and the end of the
367  // function may throw, create a call-site entry with no landing pad for the
368  // region following the try-range.
369  if (MayThrow) {
370    CallSiteEntry Site = {LastLabel, 0, 0, 0};
371    CallSites.push_back(Site);
372  }
373
374  // Final tallies.
375  unsigned SizeSites = CallSites.size() * (sizeof(int32_t) + // Site start.
376                                            sizeof(int32_t) + // Site length.
377                                            sizeof(int32_t)); // Landing pad.
378  for (unsigned i = 0, e = CallSites.size(); i < e; ++i)
379    SizeSites += MCAsmInfo::getULEB128Size(CallSites[i].Action);
380
381  unsigned SizeTypes = TypeInfos.size() * TD->getPointerSize();
382
383  unsigned TypeOffset = sizeof(int8_t) + // Call site format
384                        // Call-site table length
385                        MCAsmInfo::getULEB128Size(SizeSites) +
386                        SizeSites + SizeActions + SizeTypes;
387
388  // Begin the exception table.
389  JCE->emitAlignmentWithFill(4, 0);
390  // Asm->EOL("Padding");
391
392  unsigned char* DwarfExceptionTable = (unsigned char*)JCE->getCurrentPCValue();
393
394  // Emit the header.
395  JCE->emitByte(dwarf::DW_EH_PE_omit);
396  // Asm->EOL("LPStart format (DW_EH_PE_omit)");
397  JCE->emitByte(dwarf::DW_EH_PE_absptr);
398  // Asm->EOL("TType format (DW_EH_PE_absptr)");
399  JCE->emitULEB128Bytes(TypeOffset);
400  // Asm->EOL("TType base offset");
401  JCE->emitByte(dwarf::DW_EH_PE_udata4);
402  // Asm->EOL("Call site format (DW_EH_PE_udata4)");
403  JCE->emitULEB128Bytes(SizeSites);
404  // Asm->EOL("Call-site table length");
405
406  // Emit the landing pad site information.
407  for (unsigned i = 0; i < CallSites.size(); ++i) {
408    CallSiteEntry &S = CallSites[i];
409    intptr_t BeginLabelPtr = 0;
410    intptr_t EndLabelPtr = 0;
411
412    if (!S.BeginLabel) {
413      BeginLabelPtr = (intptr_t)StartFunction;
414      JCE->emitInt32(0);
415    } else {
416      BeginLabelPtr = JCE->getLabelAddress(S.BeginLabel);
417      JCE->emitInt32(BeginLabelPtr - (intptr_t)StartFunction);
418    }
419
420    // Asm->EOL("Region start");
421
422    if (!S.EndLabel)
423      EndLabelPtr = (intptr_t)EndFunction;
424    else
425      EndLabelPtr = JCE->getLabelAddress(S.EndLabel);
426
427    JCE->emitInt32(EndLabelPtr - BeginLabelPtr);
428    //Asm->EOL("Region length");
429
430    if (!S.PadLabel) {
431      JCE->emitInt32(0);
432    } else {
433      unsigned PadLabelPtr = JCE->getLabelAddress(S.PadLabel);
434      JCE->emitInt32(PadLabelPtr - (intptr_t)StartFunction);
435    }
436    // Asm->EOL("Landing pad");
437
438    JCE->emitULEB128Bytes(S.Action);
439    // Asm->EOL("Action");
440  }
441
442  // Emit the actions.
443  for (unsigned I = 0, N = Actions.size(); I != N; ++I) {
444    ActionEntry &Action = Actions[I];
445
446    JCE->emitSLEB128Bytes(Action.ValueForTypeID);
447    //Asm->EOL("TypeInfo index");
448    JCE->emitSLEB128Bytes(Action.NextAction);
449    //Asm->EOL("Next action");
450  }
451
452  // Emit the type ids.
453  for (unsigned M = TypeInfos.size(); M; --M) {
454    const GlobalVariable *GV = TypeInfos[M - 1];
455
456    if (GV) {
457      if (TD->getPointerSize() == sizeof(int32_t))
458        JCE->emitInt32((intptr_t)Jit.getOrEmitGlobalVariable(GV));
459      else
460        JCE->emitInt64((intptr_t)Jit.getOrEmitGlobalVariable(GV));
461    } else {
462      if (TD->getPointerSize() == sizeof(int32_t))
463        JCE->emitInt32(0);
464      else
465        JCE->emitInt64(0);
466    }
467    // Asm->EOL("TypeInfo");
468  }
469
470  // Emit the filter typeids.
471  for (unsigned j = 0, M = FilterIds.size(); j < M; ++j) {
472    unsigned TypeID = FilterIds[j];
473    JCE->emitULEB128Bytes(TypeID);
474    //Asm->EOL("Filter TypeInfo index");
475  }
476
477  JCE->emitAlignmentWithFill(4, 0);
478
479  return DwarfExceptionTable;
480}
481
482unsigned char*
483JITDwarfEmitter::EmitCommonEHFrame(const Function* Personality) const {
484  unsigned PointerSize = TD->getPointerSize();
485  int stackGrowth = stackGrowthDirection == TargetFrameLowering::StackGrowsUp ?
486          PointerSize : -PointerSize;
487
488  unsigned char* StartCommonPtr = (unsigned char*)JCE->getCurrentPCValue();
489  // EH Common Frame header
490  JCE->allocateSpace(4, 0);
491  unsigned char* FrameCommonBeginPtr = (unsigned char*)JCE->getCurrentPCValue();
492  JCE->emitInt32((int)0);
493  JCE->emitByte(dwarf::DW_CIE_VERSION);
494  JCE->emitString(Personality ? "zPLR" : "zR");
495  JCE->emitULEB128Bytes(1);
496  JCE->emitSLEB128Bytes(stackGrowth);
497  JCE->emitByte(RI->getDwarfRegNum(RI->getRARegister(), true));
498
499  if (Personality) {
500    // Augmentation Size: 3 small ULEBs of one byte each, and the personality
501    // function which size is PointerSize.
502    JCE->emitULEB128Bytes(3 + PointerSize);
503
504    // We set the encoding of the personality as direct encoding because we use
505    // the function pointer. The encoding is not relative because the current
506    // PC value may be bigger than the personality function pointer.
507    if (PointerSize == 4) {
508      JCE->emitByte(dwarf::DW_EH_PE_sdata4);
509      JCE->emitInt32(((intptr_t)Jit.getPointerToGlobal(Personality)));
510    } else {
511      JCE->emitByte(dwarf::DW_EH_PE_sdata8);
512      JCE->emitInt64(((intptr_t)Jit.getPointerToGlobal(Personality)));
513    }
514
515    // LSDA encoding: This must match the encoding used in EmitEHFrame ()
516    if (PointerSize == 4)
517      JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
518    else
519      JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8);
520    JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
521  } else {
522    JCE->emitULEB128Bytes(1);
523    JCE->emitULEB128Bytes(dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4);
524  }
525
526  EmitFrameMoves(0, MAI->getInitialFrameState());
527
528  JCE->emitAlignmentWithFill(PointerSize, dwarf::DW_CFA_nop);
529
530  JCE->emitInt32At((uintptr_t*)StartCommonPtr,
531                   (uintptr_t)((unsigned char*)JCE->getCurrentPCValue() -
532                               FrameCommonBeginPtr));
533
534  return StartCommonPtr;
535}
536
537
538unsigned char*
539JITDwarfEmitter::EmitEHFrame(const Function* Personality,
540                             unsigned char* StartCommonPtr,
541                             unsigned char* StartFunction,
542                             unsigned char* EndFunction,
543                             unsigned char* ExceptionTable) const {
544  unsigned PointerSize = TD->getPointerSize();
545
546  // EH frame header.
547  unsigned char* StartEHPtr = (unsigned char*)JCE->getCurrentPCValue();
548  JCE->allocateSpace(4, 0);
549  unsigned char* FrameBeginPtr = (unsigned char*)JCE->getCurrentPCValue();
550  // FDE CIE Offset
551  JCE->emitInt32(FrameBeginPtr - StartCommonPtr);
552  JCE->emitInt32(StartFunction - (unsigned char*)JCE->getCurrentPCValue());
553  JCE->emitInt32(EndFunction - StartFunction);
554
555  // If there is a personality and landing pads then point to the language
556  // specific data area in the exception table.
557  if (Personality) {
558    JCE->emitULEB128Bytes(PointerSize == 4 ? 4 : 8);
559
560    if (PointerSize == 4) {
561      if (!MMI->getLandingPads().empty())
562        JCE->emitInt32(ExceptionTable-(unsigned char*)JCE->getCurrentPCValue());
563      else
564        JCE->emitInt32((int)0);
565    } else {
566      if (!MMI->getLandingPads().empty())
567        JCE->emitInt64(ExceptionTable-(unsigned char*)JCE->getCurrentPCValue());
568      else
569        JCE->emitInt64((int)0);
570    }
571  } else {
572    JCE->emitULEB128Bytes(0);
573  }
574
575  // Indicate locations of function specific  callee saved registers in
576  // frame.
577  EmitFrameMoves((intptr_t)StartFunction, MMI->getFrameMoves());
578
579  JCE->emitAlignmentWithFill(PointerSize, dwarf::DW_CFA_nop);
580
581  // Indicate the size of the table
582  JCE->emitInt32At((uintptr_t*)StartEHPtr,
583                   (uintptr_t)((unsigned char*)JCE->getCurrentPCValue() -
584                               StartEHPtr));
585
586  // Double zeroes for the unwind runtime
587  if (PointerSize == 8) {
588    JCE->emitInt64(0);
589    JCE->emitInt64(0);
590  } else {
591    JCE->emitInt32(0);
592    JCE->emitInt32(0);
593  }
594
595  return StartEHPtr;
596}
597