slang_backend.cpp revision 41ebf534161bb67f6207a070c1f6a895dc853408 
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/TargetData.h"
24#include "llvm/Target/TargetMachine.h"
25#include "llvm/Target/TargetOptions.h"
26#include "llvm/Target/TargetRegistry.h"
27#include "llvm/Target/SubtargetFeature.h"
28
29#include "llvm/CodeGen/RegAllocRegistry.h"
30#include "llvm/CodeGen/SchedulerRegistry.h"
31
32#include "llvm/Assembly/PrintModulePass.h"
33#include "llvm/Bitcode/ReaderWriter.h"
34
35#include "clang/AST/Decl.h"
36#include "clang/AST/DeclGroup.h"
37#include "clang/AST/ASTContext.h"
38
39#include "clang/Basic/TargetInfo.h"
40#include "clang/Basic/Diagnostic.h"
41#include "clang/Basic/TargetOptions.h"
42
43#include "clang/Frontend/CodeGenOptions.h"
44#include "clang/Frontend/FrontendDiagnostic.h"
45
46#include "clang/CodeGen/ModuleBuilder.h"
47
48#include "slang.h"
49
50using namespace slang;
51
52void Backend::CreateFunctionPasses() {
53  if (!mPerFunctionPasses) {
54    mPerFunctionPasses = new llvm::FunctionPassManager(mpModule);
55    mPerFunctionPasses->add(new llvm::TargetData(mpModule));
56
57    llvm::createStandardFunctionPasses(mPerFunctionPasses,
58                                       mCodeGenOpts.OptimizationLevel);
59  }
60  return;
61}
62
63void Backend::CreateModulePasses() {
64  if (!mPerModulePasses) {
65    mPerModulePasses = new llvm::PassManager();
66    mPerModulePasses->add(new llvm::TargetData(mpModule));
67
68    llvm::createStandardModulePasses(mPerModulePasses,
69                                     mCodeGenOpts.OptimizationLevel,
70                                     mCodeGenOpts.OptimizeSize,
71                                     mCodeGenOpts.UnitAtATime,
72                                     mCodeGenOpts.UnrollLoops,
73                                     /* SimplifyLibCalls = */true,
74                                     /* HaveExceptions = */false,
75                                     /* InliningPass = */NULL);
76  }
77  return;
78}
79
80bool Backend::CreateCodeGenPasses() {
81  if ((mOT != Slang::OT_Assembly) && (mOT != Slang::OT_Object))
82    return true;
83
84  // Now we add passes for code emitting
85  if (mCodeGenPasses) {
86    return true;
87  } else {
88    mCodeGenPasses = new llvm::FunctionPassManager(mpModule);
89    mCodeGenPasses->add(new llvm::TargetData(mpModule));
90  }
91
92  // Create the TargetMachine for generating code.
93  std::string Triple = mpModule->getTargetTriple();
94
95  std::string Error;
96  const llvm::Target* TargetInfo =
97      llvm::TargetRegistry::lookupTarget(Triple, Error);
98  if (TargetInfo == NULL) {
99    mDiags.Report(clang::diag::err_fe_unable_to_create_target) << Error;
100    return false;
101  }
102
103  llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim;
104
105  // Use hardware FPU.
106  //
107  // FIXME: Need to detect the CPU capability and decide whether to use softfp.
108  // To use softfp, change following 2 lines to
109  //
110  //  llvm::FloatABIType = llvm::FloatABI::Soft;
111  //  llvm::UseSoftFloat = true;
112  llvm::FloatABIType = llvm::FloatABI::Hard;
113  llvm::UseSoftFloat = false;
114
115  // BCC needs all unknown symbols resolved at compilation time. So we don't
116  // need any relocation model.
117  llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static);
118
119
120  // This is set for the linker (specify how large of the virtual addresses we
121  // can access for all unknown symbols.)
122  if (mpModule->getPointerSize() == llvm::Module::Pointer32)
123    llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
124  else
125    // The target may have pointer size greater than 32 (e.g. x86_64
126    // architecture) may need large data address model
127    llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);
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      mGen(NULL),
188      mPerFunctionPasses(NULL),
189      mPerModulePasses(NULL),
190      mCodeGenPasses(NULL),
191      mLLVMContext(llvm::getGlobalContext()),
192      mDiags(Diags),
193      mpModule(NULL),
194      mPragmas(Pragmas) {
195  FormattedOutStream.setStream(*mpOS,
196                               llvm::formatted_raw_ostream::PRESERVE_STREAM);
197  mGen = CreateLLVMCodeGen(mDiags, "", mCodeGenOpts, mLLVMContext);
198  return;
199}
200
201void Backend::Initialize(clang::ASTContext &Ctx) {
202  mGen->Initialize(Ctx);
203
204  mpModule = mGen->GetModule();
205
206  return;
207}
208
209void Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
210  mGen->HandleTopLevelDecl(D);
211  return;
212}
213
214void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) {
215  mGen->HandleTranslationUnit(Ctx);
216
217  // Here, we complete a translation unit (whole translation unit is now in LLVM
218  // IR). Now, interact with LLVM backend to generate actual machine code (asm
219  // or machine code, whatever.)
220
221  // Silently ignore if we weren't initialized for some reason.
222  if (!mpModule)
223    return;
224
225  llvm::Module *M = mGen->ReleaseModule();
226  if (!M) {
227    // The module has been released by IR gen on failures, do not double free.
228    mpModule = NULL;
229    return;
230  }
231
232  assert(mpModule == M && "Unexpected module change during LLVM IR generation");
233
234  // Insert #pragma information into metadata section of module
235  if (!mPragmas.empty()) {
236    llvm::NamedMDNode *PragmaMetadata =
237        mpModule->getOrInsertNamedMetadata(Slang::PragmaMetadataName);
238    for (PragmaList::const_iterator I = mPragmas.begin(), E = mPragmas.end();
239         I != E;
240         I++) {
241      llvm::SmallVector<llvm::Value*, 2> Pragma;
242      // Name goes first
243      Pragma.push_back(llvm::MDString::get(mLLVMContext, I->first));
244      // And then value
245      Pragma.push_back(llvm::MDString::get(mLLVMContext, I->second));
246      // Create MDNode and insert into PragmaMetadata
247      PragmaMetadata->addOperand(
248          llvm::MDNode::get(mLLVMContext, Pragma.data(), Pragma.size()));
249    }
250  }
251
252  HandleTranslationUnitEx(Ctx);
253
254  // Create passes for optimization and code emission
255
256  // Create and run per-function passes
257  CreateFunctionPasses();
258  if (mPerFunctionPasses) {
259    mPerFunctionPasses->doInitialization();
260
261    for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
262         I != E;
263         I++)
264      if (!I->isDeclaration())
265        mPerFunctionPasses->run(*I);
266
267    mPerFunctionPasses->doFinalization();
268  }
269
270  // Create and run module passes
271  CreateModulePasses();
272  if (mPerModulePasses)
273    mPerModulePasses->run(*mpModule);
274
275  switch (mOT) {
276    case Slang::OT_Assembly:
277    case Slang::OT_Object: {
278      if (!CreateCodeGenPasses())
279        return;
280
281      mCodeGenPasses->doInitialization();
282
283      for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
284          I != E;
285          I++)
286        if (!I->isDeclaration())
287          mCodeGenPasses->run(*I);
288
289      mCodeGenPasses->doFinalization();
290      break;
291    }
292    case Slang::OT_LLVMAssembly: {
293      llvm::PassManager *LLEmitPM = new llvm::PassManager();
294      LLEmitPM->add(llvm::createPrintModulePass(&FormattedOutStream));
295      LLEmitPM->run(*mpModule);
296      break;
297    }
298    case Slang::OT_Bitcode: {
299      llvm::PassManager *BCEmitPM = new llvm::PassManager();
300      BCEmitPM->add(llvm::createBitcodeWriterPass(FormattedOutStream));
301      BCEmitPM->run(*mpModule);
302      break;
303    }
304    case Slang::OT_Nothing: {
305      return;
306    }
307    default: {
308      assert(false && "Unknown output type");
309    }
310  }
311
312  FormattedOutStream.flush();
313
314  return;
315}
316
317void Backend::HandleTagDeclDefinition(clang::TagDecl *D) {
318  mGen->HandleTagDeclDefinition(D);
319  return;
320}
321
322void Backend::CompleteTentativeDefinition(clang::VarDecl *D) {
323  mGen->CompleteTentativeDefinition(D);
324  return;
325}
326
327Backend::~Backend() {
328  delete mpModule;
329  delete mGen;
330  delete mPerFunctionPasses;
331  delete mPerModulePasses;
332  delete mCodeGenPasses;
333  return;
334}
335