slang_backend.cpp - platform/frameworks/compile/slang - Gitiles

 /*
  * Copyright 2010, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "slang_backend.h"

 #include "llvm/Module.h"
 #include "llvm/Metadata.h"
 #include "llvm/LLVMContext.h"

 #include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include "llvm/Target/TargetRegistry.h"
 #include "llvm/Target/SubtargetFeature.h"

 #include "llvm/CodeGen/RegAllocRegistry.h"
 #include "llvm/CodeGen/SchedulerRegistry.h"

 #include "llvm/Assembly/PrintModulePass.h"
 #include "llvm/Bitcode/ReaderWriter.h"

 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclGroup.h"
 #include "clang/AST/ASTContext.h"

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/TargetOptions.h"

 #include "clang/Frontend/CodeGenOptions.h"
 #include "clang/Frontend/FrontendDiagnostic.h"

 #include "clang/CodeGen/ModuleBuilder.h"

 #include "slang.h"

 using namespace slang;

 void Backend::CreateFunctionPasses() {
   if (!mPerFunctionPasses) {
     mPerFunctionPasses = new llvm::FunctionPassManager(mpModule);
     mPerFunctionPasses->add(new llvm::TargetData(mpModule));

     llvm::createStandardFunctionPasses(mPerFunctionPasses,
                                        mCodeGenOpts.OptimizationLevel);
   }
   return;
 }

 void Backend::CreateModulePasses() {
   if (!mPerModulePasses) {
     mPerModulePasses = new llvm::PassManager();
     mPerModulePasses->add(new llvm::TargetData(mpModule));

     llvm::createStandardModulePasses(mPerModulePasses,
                                      mCodeGenOpts.OptimizationLevel,
                                      mCodeGenOpts.OptimizeSize,
                                      mCodeGenOpts.UnitAtATime,
                                      mCodeGenOpts.UnrollLoops,
                                      /* SimplifyLibCalls = */true,
                                      /* HaveExceptions = */false,
                                      /* InliningPass = */NULL);
   }
   return;
 }

 bool Backend::CreateCodeGenPasses() {
   if ((mOT != Slang::OT_Assembly) && (mOT != Slang::OT_Object))
     return true;

   // Now we add passes for code emitting
   if (mCodeGenPasses) {
     return true;
   } else {
     mCodeGenPasses = new llvm::FunctionPassManager(mpModule);
     mCodeGenPasses->add(new llvm::TargetData(mpModule));
   }

   // Create the TargetMachine for generating code.
   std::string Triple = mpModule->getTargetTriple();

   std::string Error;
   const llvm::Target* TargetInfo =
       llvm::TargetRegistry::lookupTarget(Triple, Error);
   if (TargetInfo == NULL) {
     mDiags.Report(clang::diag::err_fe_unable_to_create_target) << Error;
     return false;
   }

   llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim;

   // Use hardware FPU.
   //
   // FIXME: Need to detect the CPU capability and decide whether to use softfp.
   // To use softfp, change following 2 lines to
   //
   //  llvm::FloatABIType = llvm::FloatABI::Soft;
   //  llvm::UseSoftFloat = true;
   llvm::FloatABIType = llvm::FloatABI::Hard;
   llvm::UseSoftFloat = false;

   // BCC needs all unknown symbols resolved at compilation time. So we don't
   // need any relocation model.
   llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static);


   // This is set for the linker (specify how large of the virtual addresses we
   // can access for all unknown symbols.)
   if (mpModule->getPointerSize() == llvm::Module::Pointer32)
     llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
   else
     // The target may have pointer size greater than 32 (e.g. x86_64
     // architecture) may need large data address model
     llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);

   // Setup feature string
   std::string FeaturesStr;
   if (mTargetOpts.CPU.size() || mTargetOpts.Features.size()) {
     llvm::SubtargetFeatures Features;

     Features.setCPU(mTargetOpts.CPU);

     for (std::vector<std::string>::const_iterator
              I = mTargetOpts.Features.begin(), E = mTargetOpts.Features.end();
          I != E;
          I++)
       Features.AddFeature(*I);

     FeaturesStr = Features.getString();
   }
   llvm::TargetMachine *TM =
       TargetInfo->createTargetMachine(Triple, FeaturesStr);

   // Register scheduler
   llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);

   // Register allocation policy:
   //  createFastRegisterAllocator: fast but bad quality
   //  createLinearScanRegisterAllocator: not so fast but good quality
   llvm::RegisterRegAlloc::setDefault((mCodeGenOpts.OptimizationLevel == 0) ?
                                      llvm::createFastRegisterAllocator :
                                      llvm::createLinearScanRegisterAllocator);

   llvm::CodeGenOpt::Level OptLevel = llvm::CodeGenOpt::Default;
   if (mCodeGenOpts.OptimizationLevel == 0)
     OptLevel = llvm::CodeGenOpt::None;
   else if (mCodeGenOpts.OptimizationLevel == 3)
     OptLevel = llvm::CodeGenOpt::Aggressive;

   llvm::TargetMachine::CodeGenFileType CGFT =
       llvm::TargetMachine::CGFT_AssemblyFile;
   if (mOT == Slang::OT_Object)
     CGFT = llvm::TargetMachine::CGFT_ObjectFile;
   if (TM->addPassesToEmitFile(*mCodeGenPasses, FormattedOutStream,
                               CGFT, OptLevel)) {
     mDiags.Report(clang::diag::err_fe_unable_to_interface_with_target);
     return false;
   }

   return true;
 }

 Backend::Backend(clang::Diagnostic &Diags,
                  const clang::CodeGenOptions &CodeGenOpts,
                  const clang::TargetOptions &TargetOpts,
                  const PragmaList &Pragmas,
                  llvm::raw_ostream *OS,
                  Slang::OutputType OT)
     : ASTConsumer(),
       mCodeGenOpts(CodeGenOpts),
       mTargetOpts(TargetOpts),
       mpModule(NULL),
       mpOS(OS),
       mOT(OT),
       mGen(NULL),
       mPerFunctionPasses(NULL),
       mPerModulePasses(NULL),
       mCodeGenPasses(NULL),
       mLLVMContext(llvm::getGlobalContext()),
       mDiags(Diags),
       mPragmas(Pragmas) {
   FormattedOutStream.setStream(*mpOS,
                                llvm::formatted_raw_ostream::PRESERVE_STREAM);
   mGen = CreateLLVMCodeGen(mDiags, "", mCodeGenOpts, mLLVMContext);
   return;
 }

 void Backend::Initialize(clang::ASTContext &Ctx) {
   mGen->Initialize(Ctx);

   mpModule = mGen->GetModule();

   return;
 }

 void Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
   mGen->HandleTopLevelDecl(D);
   return;
 }

 void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) {
   HandleTranslationUnitPre(Ctx);

   mGen->HandleTranslationUnit(Ctx);

   // Here, we complete a translation unit (whole translation unit is now in LLVM
   // IR). Now, interact with LLVM backend to generate actual machine code (asm
   // or machine code, whatever.)

   // Silently ignore if we weren't initialized for some reason.
   if (!mpModule)
     return;

   llvm::Module *M = mGen->ReleaseModule();
   if (!M) {
     // The module has been released by IR gen on failures, do not double free.
     mpModule = NULL;
     return;
   }

   assert(mpModule == M && "Unexpected module change during LLVM IR generation");

   // Insert #pragma information into metadata section of module
   if (!mPragmas.empty()) {
     llvm::NamedMDNode *PragmaMetadata =
         mpModule->getOrInsertNamedMetadata(Slang::PragmaMetadataName);
     for (PragmaList::const_iterator I = mPragmas.begin(), E = mPragmas.end();
          I != E;
          I++) {
       llvm::SmallVector<llvm::Value*, 2> Pragma;
       // Name goes first
       Pragma.push_back(llvm::MDString::get(mLLVMContext, I->first));
       // And then value
       Pragma.push_back(llvm::MDString::get(mLLVMContext, I->second));
       // Create MDNode and insert into PragmaMetadata
       PragmaMetadata->addOperand(
           llvm::MDNode::get(mLLVMContext, Pragma.data(), Pragma.size()));
     }
   }

   HandleTranslationUnitPost(mpModule);

   // Create passes for optimization and code emission

   // Create and run per-function passes
   CreateFunctionPasses();
   if (mPerFunctionPasses) {
     mPerFunctionPasses->doInitialization();

     for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
          I != E;
          I++)
       if (!I->isDeclaration())
         mPerFunctionPasses->run(*I);

     mPerFunctionPasses->doFinalization();
   }

   // Create and run module passes
   CreateModulePasses();
   if (mPerModulePasses)
     mPerModulePasses->run(*mpModule);

   switch (mOT) {
     case Slang::OT_Assembly:
     case Slang::OT_Object: {
       if (!CreateCodeGenPasses())
         return;

       mCodeGenPasses->doInitialization();

       for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
           I != E;
           I++)
         if (!I->isDeclaration())
           mCodeGenPasses->run(*I);

       mCodeGenPasses->doFinalization();
       break;
     }
     case Slang::OT_LLVMAssembly: {
       llvm::PassManager *LLEmitPM = new llvm::PassManager();
       LLEmitPM->add(llvm::createPrintModulePass(&FormattedOutStream));
       LLEmitPM->run(*mpModule);
       break;
     }
     case Slang::OT_Bitcode: {
       llvm::PassManager *BCEmitPM = new llvm::PassManager();
       BCEmitPM->add(llvm::createBitcodeWriterPass(FormattedOutStream));
       BCEmitPM->run(*mpModule);
       break;
     }
     case Slang::OT_Nothing: {
       return;
     }
     default: {
       assert(false && "Unknown output type");
     }
   }

   FormattedOutStream.flush();

   return;
 }

 void Backend::HandleTagDeclDefinition(clang::TagDecl *D) {
   mGen->HandleTagDeclDefinition(D);
   return;
 }

 void Backend::CompleteTentativeDefinition(clang::VarDecl *D) {
   mGen->CompleteTentativeDefinition(D);
   return;
 }

 Backend::~Backend() {
   delete mpModule;
   delete mGen;
   delete mPerFunctionPasses;
   delete mPerModulePasses;
   delete mCodeGenPasses;
   return;
 }
	/*
	* Copyright 2010, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "slang_backend.h"

	#include "llvm/Module.h"
	#include "llvm/Metadata.h"
	#include "llvm/LLVMContext.h"

	#include "llvm/Target/TargetData.h"
	#include "llvm/Target/TargetMachine.h"
	#include "llvm/Target/TargetOptions.h"
	#include "llvm/Target/TargetRegistry.h"
	#include "llvm/Target/SubtargetFeature.h"

	#include "llvm/CodeGen/RegAllocRegistry.h"
	#include "llvm/CodeGen/SchedulerRegistry.h"

	#include "llvm/Assembly/PrintModulePass.h"
	#include "llvm/Bitcode/ReaderWriter.h"

	#include "clang/AST/Decl.h"
	#include "clang/AST/DeclGroup.h"
	#include "clang/AST/ASTContext.h"

	#include "clang/Basic/TargetInfo.h"
	#include "clang/Basic/Diagnostic.h"
	#include "clang/Basic/TargetOptions.h"

	#include "clang/Frontend/CodeGenOptions.h"
	#include "clang/Frontend/FrontendDiagnostic.h"

	#include "clang/CodeGen/ModuleBuilder.h"

	#include "slang.h"

	using namespace slang;

	void Backend::CreateFunctionPasses() {
	if (!mPerFunctionPasses) {
	mPerFunctionPasses = new llvm::FunctionPassManager(mpModule);
	mPerFunctionPasses->add(new llvm::TargetData(mpModule));

	llvm::createStandardFunctionPasses(mPerFunctionPasses,
	mCodeGenOpts.OptimizationLevel);
	}
	return;
	}

	void Backend::CreateModulePasses() {
	if (!mPerModulePasses) {
	mPerModulePasses = new llvm::PassManager();
	mPerModulePasses->add(new llvm::TargetData(mpModule));

	llvm::createStandardModulePasses(mPerModulePasses,
	mCodeGenOpts.OptimizationLevel,
	mCodeGenOpts.OptimizeSize,
	mCodeGenOpts.UnitAtATime,
	mCodeGenOpts.UnrollLoops,
	/* SimplifyLibCalls = */true,
	/* HaveExceptions = */false,
	/* InliningPass = */NULL);
	}
	return;
	}

	bool Backend::CreateCodeGenPasses() {
	if ((mOT != Slang::OT_Assembly) && (mOT != Slang::OT_Object))
	return true;

	// Now we add passes for code emitting
	if (mCodeGenPasses) {
	return true;
	} else {
	mCodeGenPasses = new llvm::FunctionPassManager(mpModule);
	mCodeGenPasses->add(new llvm::TargetData(mpModule));
	}

	// Create the TargetMachine for generating code.
	std::string Triple = mpModule->getTargetTriple();

	std::string Error;
	const llvm::Target* TargetInfo =
	llvm::TargetRegistry::lookupTarget(Triple, Error);
	if (TargetInfo == NULL) {
	mDiags.Report(clang::diag::err_fe_unable_to_create_target) << Error;
	return false;
	}

	llvm::NoFramePointerElim = mCodeGenOpts.DisableFPElim;

	// Use hardware FPU.
	//
	// FIXME: Need to detect the CPU capability and decide whether to use softfp.
	// To use softfp, change following 2 lines to
	//
	// llvm::FloatABIType = llvm::FloatABI::Soft;
	// llvm::UseSoftFloat = true;
	llvm::FloatABIType = llvm::FloatABI::Hard;
	llvm::UseSoftFloat = false;

	// BCC needs all unknown symbols resolved at compilation time. So we don't
	// need any relocation model.
	llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static);


	// This is set for the linker (specify how large of the virtual addresses we
	// can access for all unknown symbols.)
	if (mpModule->getPointerSize() == llvm::Module::Pointer32)
	llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
	else
	// The target may have pointer size greater than 32 (e.g. x86_64
	// architecture) may need large data address model
	llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);

	// Setup feature string
	std::string FeaturesStr;
	if (mTargetOpts.CPU.size() \|\| mTargetOpts.Features.size()) {
	llvm::SubtargetFeatures Features;

	Features.setCPU(mTargetOpts.CPU);

	for (std::vector<std::string>::const_iterator
	I = mTargetOpts.Features.begin(), E = mTargetOpts.Features.end();
	I != E;
	I++)
	Features.AddFeature(*I);

	FeaturesStr = Features.getString();
	}
	llvm::TargetMachine *TM =
	TargetInfo->createTargetMachine(Triple, FeaturesStr);

	// Register scheduler
	llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);

	// Register allocation policy:
	// createFastRegisterAllocator: fast but bad quality
	// createLinearScanRegisterAllocator: not so fast but good quality
	llvm::RegisterRegAlloc::setDefault((mCodeGenOpts.OptimizationLevel == 0) ?
	llvm::createFastRegisterAllocator :
	llvm::createLinearScanRegisterAllocator);

	llvm::CodeGenOpt::Level OptLevel = llvm::CodeGenOpt::Default;
	if (mCodeGenOpts.OptimizationLevel == 0)
	OptLevel = llvm::CodeGenOpt::None;
	else if (mCodeGenOpts.OptimizationLevel == 3)
	OptLevel = llvm::CodeGenOpt::Aggressive;

	llvm::TargetMachine::CodeGenFileType CGFT =
	llvm::TargetMachine::CGFT_AssemblyFile;
	if (mOT == Slang::OT_Object)
	CGFT = llvm::TargetMachine::CGFT_ObjectFile;
	if (TM->addPassesToEmitFile(*mCodeGenPasses, FormattedOutStream,
	CGFT, OptLevel)) {
	mDiags.Report(clang::diag::err_fe_unable_to_interface_with_target);
	return false;
	}

	return true;
	}

	Backend::Backend(clang::Diagnostic &Diags,
	const clang::CodeGenOptions &CodeGenOpts,
	const clang::TargetOptions &TargetOpts,
	const PragmaList &Pragmas,
	llvm::raw_ostream *OS,
	Slang::OutputType OT)
	: ASTConsumer(),
	mCodeGenOpts(CodeGenOpts),
	mTargetOpts(TargetOpts),
	mpModule(NULL),
	mpOS(OS),
	mOT(OT),
	mGen(NULL),
	mPerFunctionPasses(NULL),
	mPerModulePasses(NULL),
	mCodeGenPasses(NULL),
	mLLVMContext(llvm::getGlobalContext()),
	mDiags(Diags),
	mPragmas(Pragmas) {
	FormattedOutStream.setStream(*mpOS,
	llvm::formatted_raw_ostream::PRESERVE_STREAM);
	mGen = CreateLLVMCodeGen(mDiags, "", mCodeGenOpts, mLLVMContext);
	return;
	}

	void Backend::Initialize(clang::ASTContext &Ctx) {
	mGen->Initialize(Ctx);

	mpModule = mGen->GetModule();

	return;
	}

	void Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
	mGen->HandleTopLevelDecl(D);
	return;
	}

	void Backend::HandleTranslationUnit(clang::ASTContext &Ctx) {
	HandleTranslationUnitPre(Ctx);

	mGen->HandleTranslationUnit(Ctx);

	// Here, we complete a translation unit (whole translation unit is now in LLVM
	// IR). Now, interact with LLVM backend to generate actual machine code (asm
	// or machine code, whatever.)

	// Silently ignore if we weren't initialized for some reason.
	if (!mpModule)
	return;

	llvm::Module *M = mGen->ReleaseModule();
	if (!M) {
	// The module has been released by IR gen on failures, do not double free.
	mpModule = NULL;
	return;
	}

	assert(mpModule == M && "Unexpected module change during LLVM IR generation");

	// Insert #pragma information into metadata section of module
	if (!mPragmas.empty()) {
	llvm::NamedMDNode *PragmaMetadata =
	mpModule->getOrInsertNamedMetadata(Slang::PragmaMetadataName);
	for (PragmaList::const_iterator I = mPragmas.begin(), E = mPragmas.end();
	I != E;
	I++) {
	llvm::SmallVector<llvm::Value*, 2> Pragma;
	// Name goes first
	Pragma.push_back(llvm::MDString::get(mLLVMContext, I->first));
	// And then value
	Pragma.push_back(llvm::MDString::get(mLLVMContext, I->second));
	// Create MDNode and insert into PragmaMetadata
	PragmaMetadata->addOperand(
	llvm::MDNode::get(mLLVMContext, Pragma.data(), Pragma.size()));
	}
	}

	HandleTranslationUnitPost(mpModule);

	// Create passes for optimization and code emission

	// Create and run per-function passes
	CreateFunctionPasses();
	if (mPerFunctionPasses) {
	mPerFunctionPasses->doInitialization();

	for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
	I != E;
	I++)
	if (!I->isDeclaration())
	mPerFunctionPasses->run(*I);

	mPerFunctionPasses->doFinalization();
	}

	// Create and run module passes
	CreateModulePasses();
	if (mPerModulePasses)
	mPerModulePasses->run(*mpModule);

	switch (mOT) {
	case Slang::OT_Assembly:
	case Slang::OT_Object: {
	if (!CreateCodeGenPasses())
	return;

	mCodeGenPasses->doInitialization();

	for (llvm::Module::iterator I = mpModule->begin(), E = mpModule->end();
	I != E;
	I++)
	if (!I->isDeclaration())
	mCodeGenPasses->run(*I);

	mCodeGenPasses->doFinalization();
	break;
	}
	case Slang::OT_LLVMAssembly: {
	llvm::PassManager *LLEmitPM = new llvm::PassManager();
	LLEmitPM->add(llvm::createPrintModulePass(&FormattedOutStream));
	LLEmitPM->run(*mpModule);
	break;
	}
	case Slang::OT_Bitcode: {
	llvm::PassManager *BCEmitPM = new llvm::PassManager();
	BCEmitPM->add(llvm::createBitcodeWriterPass(FormattedOutStream));
	BCEmitPM->run(*mpModule);
	break;
	}
	case Slang::OT_Nothing: {
	return;
	}
	default: {
	assert(false && "Unknown output type");
	}
	}

	FormattedOutStream.flush();

	return;
	}

	void Backend::HandleTagDeclDefinition(clang::TagDecl *D) {
	mGen->HandleTagDeclDefinition(D);
	return;
	}

	void Backend::CompleteTentativeDefinition(clang::VarDecl *D) {
	mGen->CompleteTentativeDefinition(D);
	return;
	}

	Backend::~Backend() {
	delete mpModule;
	delete mGen;
	delete mPerFunctionPasses;
	delete mPerModulePasses;
	delete mCodeGenPasses;
	return;
	}