Movatterモバイル変換

Go to the documentation of this file.

1//===- ModuleSymbolTable.cpp - symbol table for in-memory IR --------------===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8//

9// This class represents a symbol table built from in-memory IR. It provides

10// access to GlobalValues and should only be used if such access is required

11// (e.g. in the LTO implementation).

12//

13//===----------------------------------------------------------------------===//

15#include "llvm/Object/ModuleSymbolTable.h"

16#include "RecordStreamer.h"

17#include "llvm/ADT/StringRef.h"

18#include "llvm/IR/DiagnosticInfo.h"

19#include "llvm/IR/Function.h"

20#include "llvm/IR/GlobalAlias.h"

21#include "llvm/IR/GlobalValue.h"

22#include "llvm/IR/GlobalVariable.h"

23#include "llvm/IR/InlineAsm.h"

24#include "llvm/IR/Module.h"

25#include "llvm/MC/MCAsmInfo.h"

26#include "llvm/MC/MCContext.h"

27#include "llvm/MC/MCInstrInfo.h"

28#include "llvm/MC/MCObjectFileInfo.h"

29#include "llvm/MC/MCParser/MCAsmParser.h"

30#include "llvm/MC/MCParser/MCTargetAsmParser.h"

31#include "llvm/MC/MCRegisterInfo.h"

32#include "llvm/MC/MCSubtargetInfo.h"

33#include "llvm/MC/MCSymbol.h"

34#include "llvm/MC/MCTargetOptions.h"

35#include "llvm/MC/TargetRegistry.h"

36#include "llvm/Object/SymbolicFile.h"

37#include "llvm/Support/Casting.h"

38#include "llvm/Support/ErrorHandling.h"

39#include "llvm/Support/MemoryBuffer.h"

40#include "llvm/Support/SMLoc.h"

41#include "llvm/Support/SourceMgr.h"

42#include "llvm/Support/raw_ostream.h"

43#include "llvm/TargetParser/Triple.h"

44#include <cassert>

45#include <cstdint>

46#include <memory>

47#include <string>

49using namespacellvm;

50using namespaceobject;

52voidModuleSymbolTable::addModule(Module *M) {

53if (FirstMod)

54assert(FirstMod->getTargetTriple() == M->getTargetTriple());

55else

56 FirstMod = M;

58for (GlobalValue &GV : M->global_values())

59 SymTab.push_back(&GV);

61CollectAsmSymbols(*M, [this](StringRef Name,BasicSymbolRef::Flags Flags) {

62 SymTab.push_back(new (AsmSymbols.Allocate())

63AsmSymbol(std::string(Name), Flags));

64 });

65}

67staticvoid

68initializeRecordStreamer(constModule &M,

69function_ref<void(RecordStreamer &)>Init) {

70// This function may be called twice, once for ModuleSummaryIndexAnalysis and

71// the other when writing the IR symbol table. If parsing inline assembly has

72// caused errors in the first run, suppress the second run.

73if (M.getContext().getDiagHandlerPtr()->HasErrors)

74return;

75StringRef InlineAsm = M.getModuleInlineAsm();

76if (InlineAsm.empty())

77return;

79 std::string Err;

80constTriple TT(M.getTargetTriple());

81constTarget *T =TargetRegistry::lookupTarget(TT.str(), Err);

82assert(T &&T->hasMCAsmParser());

84 std::unique_ptr<MCRegisterInfo>MRI(T->createMCRegInfo(TT.str()));

85if (!MRI)

86return;

88MCTargetOptions MCOptions;

89 std::unique_ptr<MCAsmInfo> MAI(T->createMCAsmInfo(*MRI, TT.str(), MCOptions));

90if (!MAI)

91return;

93 std::unique_ptr<MCSubtargetInfo> STI(

94T->createMCSubtargetInfo(TT.str(),"",""));

95if (!STI)

96return;

98 std::unique_ptr<MCInstrInfo> MCII(T->createMCInstrInfo());

99if (!MCII)

100return;

101

102 std::unique_ptr<MemoryBuffer> Buffer(

103MemoryBuffer::getMemBuffer(InlineAsm,"<inline asm>"));

104SourceMgr SrcMgr;

105SrcMgr.AddNewSourceBuffer(std::move(Buffer),SMLoc());

106

107MCContext MCCtx(TT, MAI.get(),MRI.get(), STI.get(), &SrcMgr);

108 std::unique_ptr<MCObjectFileInfo> MOFI(

109T->createMCObjectFileInfo(MCCtx,/*PIC=*/false));

110 MCCtx.setObjectFileInfo(MOFI.get());

111RecordStreamer Streamer(MCCtx, M);

112T->createNullTargetStreamer(Streamer);

113

114 std::unique_ptr<MCAsmParser>Parser(

115createMCAsmParser(SrcMgr, MCCtx, Streamer, *MAI));

116

117 std::unique_ptr<MCTargetAsmParser> TAP(

118T->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));

119if (!TAP)

120return;

121

122 MCCtx.setDiagnosticHandler([&](constSMDiagnostic &SMD,bool IsInlineAsm,

123constSourceMgr &SrcMgr,

124 std::vector<const MDNode *> &LocInfos) {

125 M.getContext().diagnose(

126DiagnosticInfoSrcMgr(SMD, M.getName(), IsInlineAsm,/*LocCookie=*/0));

127 });

128

129// Module-level inline asm is assumed to use At&t syntax (see

130// AsmPrinter::doInitialization()).

131Parser->setAssemblerDialect(InlineAsm::AD_ATT);

132

133Parser->setTargetParser(*TAP);

134if (Parser->Run(false))

135return;

136

137Init(Streamer);

138}

139

140voidModuleSymbolTable::CollectAsmSymbols(

141constModule &M,

142function_ref<void(StringRef,BasicSymbolRef::Flags)>AsmSymbol) {

143initializeRecordStreamer(M, [&](RecordStreamer &Streamer) {

144 Streamer.flushSymverDirectives();

145

146for (auto &KV : Streamer) {

147StringRef Key = KV.first();

148RecordStreamer::State Value = KV.second;

149// FIXME: For now we just assume that all asm symbols are executable.

150uint32_t Res =BasicSymbolRef::SF_Executable;

151switch (Value) {

152caseRecordStreamer::NeverSeen:

153llvm_unreachable("NeverSeen should have been replaced earlier");

154caseRecordStreamer::DefinedGlobal:

155 Res |=BasicSymbolRef::SF_Global;

156break;

157caseRecordStreamer::Defined:

158break;

159caseRecordStreamer::Global:

160caseRecordStreamer::Used:

161 Res |=BasicSymbolRef::SF_Undefined;

162 Res |=BasicSymbolRef::SF_Global;

163break;

164caseRecordStreamer::DefinedWeak:

165 Res |=BasicSymbolRef::SF_Weak;

166 Res |=BasicSymbolRef::SF_Global;

167break;

168caseRecordStreamer::UndefinedWeak:

169 Res |=BasicSymbolRef::SF_Weak;

170 Res |=BasicSymbolRef::SF_Undefined;

171 }

172AsmSymbol(Key,BasicSymbolRef::Flags(Res));

173 }

174 });

175

176// In ELF, object code generated for x86-32 and some code models of x86-64 may

177// reference the special symbol _GLOBAL_OFFSET_TABLE_ that is not used in the

178// IR. Record it like inline asm symbols.

179Triple TT(M.getTargetTriple());

180if (!TT.isOSBinFormatELF() || !TT.isX86())

181return;

182auto CM = M.getCodeModel();

183if (TT.getArch() ==Triple::x86 || CM ==CodeModel::Medium ||

184 CM ==CodeModel::Large) {

185AsmSymbol("_GLOBAL_OFFSET_TABLE_",

186BasicSymbolRef::Flags(BasicSymbolRef::SF_Undefined |

187BasicSymbolRef::SF_Global));

188 }

189}

190

191voidModuleSymbolTable::CollectAsmSymvers(

192constModule &M,function_ref<void(StringRef,StringRef)> AsmSymver) {

193initializeRecordStreamer(M, [&](RecordStreamer &Streamer) {

194for (auto &KV : Streamer.symverAliases())

195for (auto &Alias : KV.second)

196 AsmSymver(KV.first->getName(), Alias);

197 });

198}

199

200voidModuleSymbolTable::printSymbolName(raw_ostream &OS,Symbol S) const{

201if (isa<AsmSymbol *>(S)) {

202 OS << cast<AsmSymbol *>(S)->first;

203return;

204 }

205

206auto *GV = cast<GlobalValue *>(S);

207if (GV->hasDLLImportStorageClass())

208OS <<"__imp_";

209

210 Mang.getNameWithPrefix(OS, GV,false);

211}

212

213uint32_t ModuleSymbolTable::getSymbolFlags(Symbol S) const{

214if (isa<AsmSymbol *>(S))

215return cast<AsmSymbol *>(S)->second;

216

217auto *GV = cast<GlobalValue *>(S);

218

219uint32_t Res =BasicSymbolRef::SF_None;

220if (GV->isDeclarationForLinker())

221 Res |=BasicSymbolRef::SF_Undefined;

222elseif (GV->hasHiddenVisibility() && !GV->hasLocalLinkage())

223 Res |=BasicSymbolRef::SF_Hidden;

224if (constGlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {

225if (GVar->isConstant())

226 Res |=BasicSymbolRef::SF_Const;

227 }

228if (constGlobalObject *GO = GV->getAliaseeObject())

229if (isa<Function>(GO) || isa<GlobalIFunc>(GO))

230 Res |=BasicSymbolRef::SF_Executable;

231if (isa<GlobalAlias>(GV))

232 Res |=BasicSymbolRef::SF_Indirect;

233if (GV->hasPrivateLinkage())

234 Res |=BasicSymbolRef::SF_FormatSpecific;

235if (!GV->hasLocalLinkage())

236 Res |=BasicSymbolRef::SF_Global;

237if (GV->hasCommonLinkage())

238 Res |=BasicSymbolRef::SF_Common;

239if (GV->hasLinkOnceLinkage() || GV->hasWeakLinkage() ||

240 GV->hasExternalWeakLinkage())

241 Res |=BasicSymbolRef::SF_Weak;

242

243if (GV->getName().starts_with("llvm."))

244 Res |=BasicSymbolRef::SF_FormatSpecific;

245elseif (auto *Var = dyn_cast<GlobalVariable>(GV)) {

246if (Var->getSection() =="llvm.metadata")

247 Res |=BasicSymbolRef::SF_FormatSpecific;

248 }

249

250return Res;

251}

MRI

unsigned const MachineRegisterInfo * MRI

Definition:AArch64AdvSIMDScalarPass.cpp:105

for

for(const MachineOperand &MO :llvm::drop_begin(OldMI.operands(), Desc.getNumOperands()))

Definition:AArch64ExpandPseudoInsts.cpp:115

Casting.h

DiagnosticInfo.h

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Module.h This file contains the declarations for the Module class.

initializeRecordStreamer

static void initializeRecordStreamer(const Module &M, function_ref< void(RecordStreamer &)> Init)

Definition:ModuleSymbolTable.cpp:68

ModuleSymbolTable.h

RecordStreamer.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

SMLoc.h

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

llvm::DiagnosticInfoSrcMgr

Diagnostic information for SMDiagnostic reporting.

Definition:DiagnosticInfo.h:1162

llvm::GlobalObject

Definition:GlobalObject.h:27

llvm::GlobalValue

Definition:GlobalValue.h:48

llvm::GlobalValue::getAliaseeObject

const GlobalObject * getAliaseeObject() const

Definition:Globals.cpp:400

llvm::GlobalVariable

Definition:GlobalVariable.h:39

llvm::Init

Definition:Record.h:285

llvm::InlineAsm

Definition:InlineAsm.h:34

llvm::InlineAsm::AD_ATT

@ AD_ATT

Definition:InlineAsm.h:37

llvm::MCContext

Context object for machine code objects.

Definition:MCContext.h:83

llvm::MCContext::setObjectFileInfo

void setObjectFileInfo(const MCObjectFileInfo *Mofi)

Definition:MCContext.h:410

llvm::MCContext::setDiagnosticHandler

void setDiagnosticHandler(DiagHandlerTy DiagHandler)

Definition:MCContext.h:406

llvm::MCTargetOptions

Definition:MCTargetOptions.h:39

llvm::Mangler::getNameWithPrefix

void getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV, bool CannotUsePrivateLabel) const

Print the appropriate prefix and the specified global variable's name.

Definition:Mangler.cpp:121

llvm::MemoryBuffer::getMemBuffer

static std::unique_ptr< MemoryBuffer > getMemBuffer(StringRef InputData, StringRef BufferName="", bool RequiresNullTerminator=true)

Open the specified memory range as a MemoryBuffer.

Definition:MemoryBuffer.cpp:129

llvm::ModuleSymbolTable::addModule

void addModule(Module *M)

Definition:ModuleSymbolTable.cpp:52

llvm::ModuleSymbolTable::CollectAsmSymvers

static void CollectAsmSymvers(const Module &M, function_ref< void(StringRef, StringRef)> AsmSymver)

Parse inline ASM and collect the symvers directives that are defined in the current module.

Definition:ModuleSymbolTable.cpp:191

llvm::ModuleSymbolTable::AsmSymbol

std::pair< std::string, uint32_t > AsmSymbol

Definition:ModuleSymbolTable.h:35

llvm::ModuleSymbolTable::printSymbolName

void printSymbolName(raw_ostream &OS, Symbol S) const

Definition:ModuleSymbolTable.cpp:200

llvm::ModuleSymbolTable::getSymbolFlags

uint32_t getSymbolFlags(Symbol S) const

Definition:ModuleSymbolTable.cpp:213

llvm::ModuleSymbolTable::CollectAsmSymbols

static void CollectAsmSymbols(const Module &M, function_ref< void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol)

Parse inline ASM and collect the symbols that are defined or referenced in the current module.

Definition:ModuleSymbolTable.cpp:140

llvm::Module

A Module instance is used to store all the information related to an LLVM module.

Definition:Module.h:65

llvm::Module::getTargetTriple

const std::string & getTargetTriple() const

Get the target triple which is a string describing the target host.

Definition:Module.h:298

llvm::PointerUnion

A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...

Definition:PointerUnion.h:118

llvm::RecordStreamer

Definition:RecordStreamer.h:25

llvm::RecordStreamer::State

State

Definition:RecordStreamer.h:27

llvm::RecordStreamer::DefinedWeak

@ DefinedWeak

Definition:RecordStreamer.h:27

llvm::RecordStreamer::Used

@ Used

Definition:RecordStreamer.h:27

llvm::RecordStreamer::Global

@ Global

Definition:RecordStreamer.h:27

llvm::RecordStreamer::UndefinedWeak

@ UndefinedWeak

Definition:RecordStreamer.h:28

llvm::RecordStreamer::DefinedGlobal

@ DefinedGlobal

Definition:RecordStreamer.h:27

llvm::RecordStreamer::NeverSeen

@ NeverSeen

Definition:RecordStreamer.h:27

llvm::RecordStreamer::Defined

@ Defined

Definition:RecordStreamer.h:27

llvm::RecordStreamer::symverAliases

iterator_range< const_symver_iterator > symverAliases()

Definition:RecordStreamer.cpp:128

llvm::RecordStreamer::flushSymverDirectives

void flushSymverDirectives()

Definition:RecordStreamer.cpp:132

llvm::SMDiagnostic

Instances of this class encapsulate one diagnostic report, allowing printing to a raw_ostream as a ca...

Definition:SourceMgr.h:281

llvm::SMLoc

Represents a location in source code.

Definition:SMLoc.h:23

llvm::SourceMgr

This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling.

Definition:SourceMgr.h:31

llvm::SourceMgr::AddNewSourceBuffer

unsigned AddNewSourceBuffer(std::unique_ptr< MemoryBuffer > F, SMLoc IncludeLoc)

Add a new source buffer to this source manager.

Definition:SourceMgr.h:144

llvm::SpecificBumpPtrAllocator::Allocate

T * Allocate(size_t num=1)

Allocate space for an array of objects without constructing them.

Definition:Allocator.h:439

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::Target

Target - Wrapper for Target specific information.

Definition:TargetRegistry.h:144

llvm::Triple

Triple - Helper class for working with autoconf configuration names.

Definition:Triple.h:44

llvm::Triple::x86

@ x86

Definition:Triple.h:85

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::function_ref

An efficient, type-erasing, non-owning reference to a callable.

Definition:STLFunctionalExtras.h:37

llvm::object::BasicSymbolRef::Flags

Flags

Definition:SymbolicFile.h:108

llvm::object::BasicSymbolRef::SF_Global

@ SF_Global

Definition:SymbolicFile.h:111

llvm::object::BasicSymbolRef::SF_Hidden

@ SF_Hidden

Definition:SymbolicFile.h:120

llvm::object::BasicSymbolRef::SF_Executable

@ SF_Executable

Definition:SymbolicFile.h:122

llvm::object::BasicSymbolRef::SF_Common

@ SF_Common

Definition:SymbolicFile.h:114

llvm::object::BasicSymbolRef::SF_Indirect

@ SF_Indirect

Definition:SymbolicFile.h:115

llvm::object::BasicSymbolRef::SF_FormatSpecific

@ SF_FormatSpecific

Definition:SymbolicFile.h:117

llvm::object::BasicSymbolRef::SF_Weak

@ SF_Weak

Definition:SymbolicFile.h:112

llvm::object::BasicSymbolRef::SF_Undefined

@ SF_Undefined

Definition:SymbolicFile.h:110

llvm::object::BasicSymbolRef::SF_None

@ SF_None

Definition:SymbolicFile.h:109

llvm::object::BasicSymbolRef::SF_Const

@ SF_Const

Definition:SymbolicFile.h:121

llvm::object::Parser

Definition:COFFModuleDefinition.cpp:139

llvm::raw_ostream

This class implements an extremely fast bulk output stream that can only output to a stream.

Definition:raw_ostream.h:52

uint32_t

ErrorHandling.h

llvm_unreachable

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

Definition:ErrorHandling.h:143

llvm::CodeModel::Medium

@ Medium

Definition:CodeGen.h:31

llvm::CodeModel::Large

@ Large

Definition:CodeGen.h:31

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::SrcMgr

SourceMgr SrcMgr

Definition:Error.cpp:24

llvm::createMCAsmParser

MCAsmParser * createMCAsmParser(SourceMgr &, MCContext &, MCStreamer &, const MCAsmInfo &, unsigned CB=0)

Create an MCAsmParser instance for parsing assembly similar to gas syntax.

Definition:AsmParser.cpp:6478

raw_ostream.h

llvm::TargetRegistry::lookupTarget

static const Target * lookupTarget(StringRef Triple, std::string &Error)

lookupTarget - Lookup a target based on a target triple.

Definition:TargetRegistry.cpp:154