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