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