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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
//===-- CSKYMCExpr.cpp - CSKY specific MC expression classes -*- 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
//
//===----------------------------------------------------------------------===//
#include "CSKYMCExpr.h"
#include "CSKYFixupKinds.h"
#include "llvm/BinaryFormat/ELF.h"
#include "llvm/MC/MCAssembler.h"
#include "llvm/MC/MCContext.h"
#include "llvm/MC/MCStreamer.h"
#include "llvm/MC/MCSymbolELF.h"
#include "llvm/Support/Casting.h"
using namespace llvm;
#define DEBUG_TYPE "csky-mc-expr"
const CSKYMCExpr *CSKYMCExpr::create(const MCExpr *Expr, VariantKind Kind,
MCContext &Ctx) {
return new (Ctx) CSKYMCExpr(Kind, Expr);
}
StringRef CSKYMCExpr::getVariantKindName(VariantKind Kind) {
switch (Kind) {
default:
llvm_unreachable("Invalid ELF symbol kind");
case VK_CSKY_None:
case VK_CSKY_ADDR:
return "";
case VK_CSKY_ADDR_HI16:
return "@HI16";
case VK_CSKY_ADDR_LO16:
return "@LO16";
case VK_CSKY_GOT_IMM18_BY4:
case VK_CSKY_GOT:
return "@GOT";
case VK_CSKY_GOTPC:
return "@GOTPC";
case VK_CSKY_GOTOFF:
return "@GOTOFF";
case VK_CSKY_PLT_IMM18_BY4:
case VK_CSKY_PLT:
return "@PLT";
case VK_CSKY_TLSLE:
return "@TPOFF";
case VK_CSKY_TLSIE:
return "@GOTTPOFF";
case VK_CSKY_TLSGD:
return "@TLSGD32";
case VK_CSKY_TLSLDO:
return "@TLSLDO32";
case VK_CSKY_TLSLDM:
return "@TLSLDM32";
}
}
void CSKYMCExpr::visitUsedExpr(MCStreamer &Streamer) const {
Streamer.visitUsedExpr(*getSubExpr());
}
void CSKYMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
Expr->print(OS, MAI);
OS << getVariantKindName(getKind());
}
static void fixELFSymbolsInTLSFixupsImpl(const MCExpr *Expr, MCAssembler &Asm) {
switch (Expr->getKind()) {
case MCExpr::Target:
llvm_unreachable("Can't handle nested target expression");
break;
case MCExpr::Constant:
break;
case MCExpr::Binary: {
const MCBinaryExpr *BE = cast<MCBinaryExpr>(Expr);
fixELFSymbolsInTLSFixupsImpl(BE->getLHS(), Asm);
fixELFSymbolsInTLSFixupsImpl(BE->getRHS(), Asm);
break;
}
case MCExpr::SymbolRef: {
// We're known to be under a TLS fixup, so any symbol should be
// modified. There should be only one.
const MCSymbolRefExpr &SymRef = *cast<MCSymbolRefExpr>(Expr);
cast<MCSymbolELF>(SymRef.getSymbol()).setType(ELF::STT_TLS);
break;
}
case MCExpr::Unary:
fixELFSymbolsInTLSFixupsImpl(cast<MCUnaryExpr>(Expr)->getSubExpr(), Asm);
break;
}
}
void CSKYMCExpr::fixELFSymbolsInTLSFixups(MCAssembler &Asm) const {
switch (getKind()) {
default:
return;
case VK_CSKY_TLSLE:
case VK_CSKY_TLSIE:
case VK_CSKY_TLSGD:
break;
}
fixELFSymbolsInTLSFixupsImpl(getSubExpr(), Asm);
}
bool CSKYMCExpr::evaluateAsRelocatableImpl(MCValue &Res,
const MCAsmLayout *Layout,
const MCFixup *Fixup) const {
if (!getSubExpr()->evaluateAsRelocatable(Res, Layout, Fixup))
return false;
// Some custom fixup types are not valid with symbol difference expressions
if (Res.getSymA() && Res.getSymB()) {
switch (getKind()) {
default:
return true;
case VK_CSKY_GOT:
case VK_CSKY_GOT_IMM18_BY4:
case VK_CSKY_GOTPC:
case VK_CSKY_GOTOFF:
case VK_CSKY_PLT:
case VK_CSKY_PLT_IMM18_BY4:
case VK_CSKY_TLSIE:
case VK_CSKY_TLSLE:
case VK_CSKY_TLSGD:
case VK_CSKY_TLSLDO:
case VK_CSKY_TLSLDM:
return false;
}
}
return true;
}
|
