slang_backend.cpp revision 6315f76e3cc6ff2d012d1183a0b030d4ff0dc808 
1#include "slang_backend.h"
2
3#include "llvm/Module.h"
4#include "llvm/Metadata.h"
5#include "llvm/LLVMContext.h"
6
7#include "llvm/Target/TargetMachine.h"
8#include "llvm/Target/TargetOptions.h"
9#include "llvm/Target/TargetRegistry.h"
10#include "llvm/Target/SubtargetFeature.h"
11
12#include "llvm/CodeGen/RegAllocRegistry.h"
13#include "llvm/CodeGen/SchedulerRegistry.h"
14
15#include "llvm/Assembly/PrintModulePass.h"
16#include "llvm/Bitcode/ReaderWriter.h"
17
18#include "clang/AST/Decl.h"
19#include "clang/AST/DeclGroup.h"
20#include "clang/AST/ASTContext.h"
21
22#include "clang/Basic/TargetInfo.h"
23#include "clang/Basic/Diagnostic.h"
24#include "clang/Basic/TargetOptions.h"
25
26#include "clang/Frontend/FrontendDiagnostic.h"
27
28#include "clang/CodeGen/ModuleBuilder.h"
29
30#include "slang.h"
31
32using namespace slang;
33
34bool Backend::CreateCodeGenPasses() {
35  if (mOutputType != SlangCompilerOutput_Assembly &&
36      mOutputType != SlangCompilerOutput_Obj)
37    return true;
38
39  // Now we add passes for code emitting
40  if (mCodeGenPasses) {
41    return true;
42  } else {
43    mCodeGenPasses = new llvm::FunctionPassManager(mpModule);
44    mCodeGenPasses->add(new llvm::TargetData(*mpTargetData));
45  }
46
47  // Create the TargetMachine for generating code.
48  std::string Triple = mpModule->getTargetTriple();
49
50  std::string Error;
51  const llvm::Target* TargetInfo =
52      llvm::TargetRegistry::lookupTarget(Triple, Error);
53  if (TargetInfo == NULL) {
54    mDiags.Report(clang::diag::err_fe_unable_to_create_target) << Error;
55    return false;
56  }
57
58  llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim;
59
60  // Use hardware FPU.
61  //
62  // FIXME: Need to detect the CPU capability and decide whether to use softfp.
63  // To use softfp, change following 2 lines to
64  //
65  //  llvm::FloatABIType = llvm::FloatABI::Soft;
66  //  llvm::UseSoftFloat = true;
67  llvm::FloatABIType = llvm::FloatABI::Hard;
68  llvm::UseSoftFloat = false;
69
70  // BCC needs all unknown symbols resolved at compilation time. So we don't
71  // need any relocation model.
72  llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static);
73
74
75  // The target with pointer size greater than 32 (e.g. x86_64 architecture) may
76  // need large data address model
77  if (mpTargetData->getPointerSizeInBits() > 32)
78    llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);
79  else
80    // This is set for the linker (specify how large of the virtual addresses we
81    // can access for all unknown symbols.)
82
83    llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
84
85  // Setup feature string
86  std::string FeaturesStr;
87  if (mTargetOpts.CPU.size() || mTargetOpts.Features.size()) {
88    llvm::SubtargetFeatures Features;
89
90    Features.setCPU(mTargetOpts.CPU);
91
92    for (std::vector<std::string>::const_iterator
93             I = mTargetOpts.Features.begin(), E = mTargetOpts.Features.end();
94         I != E;
95         I++)
96      Features.AddFeature(*I);
97
98    FeaturesStr = Features.getString();
99  }
100  llvm::TargetMachine *TM =
101      TargetInfo->createTargetMachine(Triple, FeaturesStr);
102
103  // Register scheduler
104  llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);
105
106  // Register allocation policy:
107  //  createFastRegisterAllocator: fast but bad quality
108  //  createLinearScanRegisterAllocator: not so fast but good quality
109  llvm::RegisterRegAlloc::setDefault((mCodeGenOpts.OptimizationLevel == 0) ?
110                                     llvm::createFastRegisterAllocator :
111                                     llvm::createLinearScanRegisterAllocator);
112
113  llvm::CodeGenOpt::Level OptLevel = llvm::CodeGenOpt::Default;
114  if (mCodeGenOpts.OptimizationLevel == 0)
115    OptLevel = llvm::CodeGenOpt::None;
116  else if (mCodeGenOpts.OptimizationLevel == 3)
117    OptLevel = llvm::CodeGenOpt::Aggressive;
118
119  llvm::TargetMachine::CodeGenFileType CGFT =
120      llvm::TargetMachine::CGFT_AssemblyFile;
121  if (mOutputType == SlangCompilerOutput_Obj)
122    CGFT = llvm::TargetMachine::CGFT_ObjectFile;
123  if (TM->addPassesToEmitFile(*mCodeGenPasses, FormattedOutStream,
124                              CGFT, OptLevel)) {
125    mDiags.Report(clang::diag::err_fe_unable_to_interface_with_target);
126    return false;
127  }
128
129  return true;
130}
131
132Backend::Backend(clang::Diagnostic &Diags,
133                 const clang::CodeGenOptions &CodeGenOpts,
134                 const clang::TargetOptions &TargetOpts,
135                 const PragmaList &Pragmas,
136                 llvm::raw_ostream *OS,
137                 SlangCompilerOutputTy OutputType,
138                 clang::SourceManager &SourceMgr,
139                 bool AllowRSPrefix)
140    : ASTConsumer(),
141      mCodeGenOpts(CodeGenOpts),
142      mTargetOpts(TargetOpts),
143      mSourceMgr(SourceMgr),
144      mpOS(OS),
145      mOutputType(OutputType),
146      mpTargetData(NULL),
147      mGen(NULL),
148      mPerFunctionPasses(NULL),
149      mPerModulePasses(NULL),
150      mCodeGenPasses(NULL),
151      mAllowRSPrefix(AllowRSPrefix),
152      mLLVMContext(llvm::getGlobalContext()),
153      mDiags(Diags),
154      mpModule(NULL),
155      mPragmas(Pragmas) {
156  FormattedOutStream.setStream(*mpOS,
157                               llvm::formatted_raw_ostream::PRESERVE_STREAM);
158  mGen = CreateLLVMCodeGen(mDiags, "", mCodeGenOpts, mLLVMContext);
159  return;
160}
161
162void Backend::Initialize(clang::ASTContext &Ctx) {
163  mGen->Initialize(Ctx);
164
165  mpModule = mGen->GetModule();
166  mpTargetData = new llvm::TargetData(Slang::TargetDescription);
167
168  return;
169}
170
171void Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
172  // Disallow user-defined functions with prefix "rs"
173  if (!mAllowRSPrefix) {
174    clang::DeclGroupRef::iterator I;
175    for (I = D.begin(); I != D.end(); I++) {
176      clang::FunctionDecl *FD = dyn_cast<clang::FunctionDecl>(*I);
177      if (!FD || !FD->isThisDeclarationADefinition()) continue;
178      if (FD->getName().startswith("rs")) {
179        mDiags.Report(clang::FullSourceLoc(FD->getLocStart(), mSourceMgr),
180                      mDiags.getCustomDiagID(clang::Diagnostic::Error,
181                                             "invalid function name prefix,"
182                                             " \"rs\" is reserved: '%0'")
183                      )
184            << FD->getNameAsString();
185      }
186    }
187  }
188
189  mGen->HandleTopLevelDecl(D);
190  return;
191}
192
193void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) {
194  mGen->HandleTranslationUnit(Ctx);
195
196  // Here, we complete a translation unit (whole translation unit is now in LLVM
197  // IR). Now, interact with LLVM backend to generate actual machine code (asm
198  // or machine code, whatever.)
199
200  // Silently ignore if we weren't initialized for some reason.
201  if (!mpModule || !mpTargetData)
202    return;
203
204  llvm::Module *M = mGen->ReleaseModule();
205  if (!M) {
206    // The module has been released by IR gen on failures, do not double free.
207    mpModule = NULL;
208    return;
209  }
210
211  assert(mpModule == M && "Unexpected module change during LLVM IR generation");
212
213  // Insert #pragma information into metadata section of module
214  if (!mPragmas.empty()) {
215    llvm::NamedMDNode *PragmaMetadata =
216        mpModule->getOrInsertNamedMetadata(Slang::PragmaMetadataName);
217    for (PragmaList::const_iterator I = mPragmas.begin(), E = mPragmas.end();
218         I != E;
219         I++) {
220      llvm::SmallVector<llvm::Value*, 2> Pragma;
221      // Name goes first
222      Pragma.push_back(llvm::MDString::get(mLLVMContext, I->first));
223      // And then value
224      Pragma.push_back(llvm::MDString::get(mLLVMContext, I->second));
225      // Create MDNode and insert into PragmaMetadata
226      PragmaMetadata->addOperand(
227          llvm::MDNode::get(mLLVMContext, Pragma.data(), Pragma.size()));
228    }
229  }
230
231  HandleTranslationUnitEx(Ctx);
232
233  // Create passes for optimization and code emission
234
235  // Create and run per-function passes
236  CreateFunctionPasses();
237  if (mPerFunctionPasses) {
238    mPerFunctionPasses->doInitialization();
239
240    for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
241         I != E;
242         I++)
243      if (!I->isDeclaration())
244        mPerFunctionPasses->run(*I);
245
246    mPerFunctionPasses->doFinalization();
247  }
248
249  // Create and run module passes
250  CreateModulePasses();
251  if (mPerModulePasses)
252    mPerModulePasses->run(*mpModule);
253
254  switch (mOutputType) {
255    case SlangCompilerOutput_Assembly:
256    case SlangCompilerOutput_Obj: {
257      if (!CreateCodeGenPasses())
258        return;
259
260      mCodeGenPasses->doInitialization();
261
262      for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
263          I != E;
264          I++)
265        if (!I->isDeclaration())
266          mCodeGenPasses->run(*I);
267
268      mCodeGenPasses->doFinalization();
269      break;
270    }
271    case SlangCompilerOutput_LL: {
272      llvm::PassManager *LLEmitPM = new llvm::PassManager();
273      LLEmitPM->add(llvm::createPrintModulePass(&FormattedOutStream));
274      LLEmitPM->run(*mpModule);
275      break;
276    }
277
278    case SlangCompilerOutput_Bitcode: {
279      llvm::PassManager *BCEmitPM = new llvm::PassManager();
280      BCEmitPM->add(llvm::createBitcodeWriterPass(FormattedOutStream));
281      BCEmitPM->run(*mpModule);
282      break;
283    }
284    case SlangCompilerOutput_Nothing: {
285      return;
286      break;
287    }
288    default: {
289      assert(false && "Unknown output type");
290      break;
291    }
292  }
293
294  FormattedOutStream.flush();
295
296  return;
297}
298
299void Backend::HandleTagDeclDefinition(clang::TagDecl *D) {
300  mGen->HandleTagDeclDefinition(D);
301  return;
302}
303
304void Backend::CompleteTentativeDefinition(clang::VarDecl *D) {
305  mGen->CompleteTentativeDefinition(D);
306  return;
307}
308
309Backend::~Backend() {
310  delete mpModule;
311  delete mpTargetData;
312  delete mGen;
313  delete mPerFunctionPasses;
314  delete mPerModulePasses;
315  delete mCodeGenPasses;
316  return;
317}
318