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