File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/clang/lib/CodeGen

usr / src / contrib / llvm-project / clang / lib / CodeGen /

📁 ..
📄 ABIInfo.h(5.01 KB)
📄 Address.h(3.28 KB)
📄 BackendUtil.cpp(67.92 KB)
📄 CGAtomic.cpp(85.95 KB)
📄 CGBlocks.cpp(111.14 KB)
📄 CGBlocks.h(8.94 KB)
📄 CGBuilder.h(13.78 KB)
📄 CGBuiltin.cpp(695.8 KB)
📄 CGCUDANV.cpp(35.16 KB)
📄 CGCUDARuntime.cpp(1.53 KB)
📄 CGCUDARuntime.h(3.4 KB)
📄 CGCXX.cpp(11.8 KB)
📄 CGCXXABI.cpp(12.47 KB)
📄 CGCXXABI.h(27.9 KB)
📄 CGCall.cpp(197.3 KB)
📄 CGCall.h(11.62 KB)
📄 CGClass.cpp(113.54 KB)
📄 CGCleanup.cpp(46.97 KB)
📄 CGCleanup.h(19.28 KB)
📄 CGCoroutine.cpp(27.82 KB)
📄 CGDebugInfo.cpp(191.42 KB)
📄 CGDebugInfo.h(34.73 KB)
📄 CGDecl.cpp(97.98 KB)
📄 CGDeclCXX.cpp(34.73 KB)
📄 CGException.cpp(80.38 KB)
📄 CGExpr.cpp(209.78 KB)
📄 CGExprAgg.cpp(77.04 KB)
📄 CGExprCXX.cpp(90.39 KB)
📄 CGExprComplex.cpp(44.9 KB)
📄 CGExprConstant.cpp(86.17 KB)
📄 CGExprScalar.cpp(196.29 KB)
📄 CGGPUBuiltin.cpp(6.17 KB)
📄 CGLoopInfo.cpp(29.17 KB)
📄 CGLoopInfo.h(10.5 KB)
📄 CGNonTrivialStruct.cpp(41.4 KB)
📄 CGObjC.cpp(142.79 KB)
📄 CGObjCGNU.cpp(168.38 KB)
📄 CGObjCMac.cpp(304.84 KB)
📄 CGObjCRuntime.cpp(14.68 KB)
📄 CGObjCRuntime.h(14.81 KB)
📄 CGOpenCLRuntime.cpp(7.08 KB)
📄 CGOpenCLRuntime.h(3.44 KB)
📄 CGOpenMPRuntime.cpp(501.86 KB)
📄 CGOpenMPRuntime.h(111.87 KB)
📄 CGOpenMPRuntimeNVPTX.cpp(215.42 KB)
📄 CGOpenMPRuntimeNVPTX.h(22.59 KB)
📄 CGRecordLayout.h(7.84 KB)
📄 CGRecordLayoutBuilder.cpp(38.24 KB)
📄 CGStmt.cpp(92.92 KB)
📄 CGStmtOpenMP.cpp(278.04 KB)
📄 CGVTT.cpp(6.81 KB)
📄 CGVTables.cpp(55.02 KB)
📄 CGVTables.h(6.38 KB)
📄 CGValue.h(21.24 KB)
📄 CodeGenABITypes.cpp(5 KB)
📄 CodeGenAction.cpp(46.2 KB)
📄 CodeGenFunction.cpp(95.34 KB)
📄 CodeGenFunction.h(200.94 KB)
📄 CodeGenModule.cpp(228.13 KB)
📄 CodeGenModule.h(60.91 KB)
📄 CodeGenPGO.cpp(36.17 KB)
📄 CodeGenPGO.h(4.36 KB)
📄 CodeGenTBAA.cpp(16.92 KB)
📄 CodeGenTBAA.h(9.19 KB)
📄 CodeGenTypeCache.h(3.28 KB)
📄 CodeGenTypes.cpp(32.35 KB)
📄 CodeGenTypes.h(13.42 KB)
📄 ConstantEmitter.h(6.65 KB)
📄 ConstantInitBuilder.cpp(10.29 KB)
📄 CoverageMappingGen.cpp(54.64 KB)
📄 CoverageMappingGen.h(4.04 KB)
📄 EHScopeStack.h(14.38 KB)
📄 ItaniumCXXABI.cpp(176.66 KB)
📄 MacroPPCallbacks.cpp(6.41 KB)
📄 MacroPPCallbacks.h(4.54 KB)
📄 MicrosoftCXXABI.cpp(175.41 KB)
📄 ModuleBuilder.cpp(11.79 KB)
📄 ObjectFilePCHContainerOperations.cpp(12.93 KB)
📄 PatternInit.cpp(4.1 KB)
📄 PatternInit.h(722 B)
📄 SanitizerMetadata.cpp(4.21 KB)
📄 SanitizerMetadata.h(1.63 KB)
📄 SwiftCallingConv.cpp(29.76 KB)
📄 TargetInfo.cpp(403.11 KB)
📄 TargetInfo.h(15.43 KB)
📄 VarBypassDetector.cpp(5.1 KB)
📄 VarBypassDetector.h(2.29 KB)

Editing: ModuleBuilder.cpp

//===--- ModuleBuilder.cpp - Emit LLVM Code from ASTs ---------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This builds an AST and converts it to LLVM Code.
//
//===----------------------------------------------------------------------===//

#include "clang/CodeGen/ModuleBuilder.h"
#include "CGDebugInfo.h"
#include "CodeGenModule.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclObjC.h"
#include "clang/AST/Expr.h"
#include "clang/Basic/CodeGenOptions.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/TargetInfo.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include <memory>

using namespace clang;
using namespace CodeGen;

namespace {
  class CodeGeneratorImpl : public CodeGenerator {
    DiagnosticsEngine &Diags;
    ASTContext *Ctx;
    const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
    const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
    const CodeGenOptions CodeGenOpts;  // Intentionally copied in.

unsigned HandlingTopLevelDecls;

/// Use this when emitting decls to block re-entrant decl emission. It will
    /// emit all deferred decls on scope exit. Set EmitDeferred to false if decl
    /// emission must be deferred longer, like at the end of a tag definition.
    struct HandlingTopLevelDeclRAII {
      CodeGeneratorImpl &Self;
      bool EmitDeferred;
      HandlingTopLevelDeclRAII(CodeGeneratorImpl &Self,
                               bool EmitDeferred = true)
          : Self(Self), EmitDeferred(EmitDeferred) {
        ++Self.HandlingTopLevelDecls;
      }
      ~HandlingTopLevelDeclRAII() {
        unsigned Level = --Self.HandlingTopLevelDecls;
        if (Level == 0 && EmitDeferred)
          Self.EmitDeferredDecls();
      }
    };

CoverageSourceInfo *CoverageInfo;

protected:
    std::unique_ptr<llvm::Module> M;
    std::unique_ptr<CodeGen::CodeGenModule> Builder;

private:
    SmallVector<FunctionDecl *, 8> DeferredInlineMemberFuncDefs;

static llvm::StringRef ExpandModuleName(llvm::StringRef ModuleName,
                                            const CodeGenOptions &CGO) {
      if (ModuleName == "-" && !CGO.MainFileName.empty())
        return CGO.MainFileName;
      return ModuleName;
    }

public:
    CodeGeneratorImpl(DiagnosticsEngine &diags, llvm::StringRef ModuleName,
                      const HeaderSearchOptions &HSO,
                      const PreprocessorOptions &PPO, const CodeGenOptions &CGO,
                      llvm::LLVMContext &C,
                      CoverageSourceInfo *CoverageInfo = nullptr)
        : Diags(diags), Ctx(nullptr), HeaderSearchOpts(HSO),
          PreprocessorOpts(PPO), CodeGenOpts(CGO), HandlingTopLevelDecls(0),
          CoverageInfo(CoverageInfo),
          M(new llvm::Module(ExpandModuleName(ModuleName, CGO), C)) {
      C.setDiscardValueNames(CGO.DiscardValueNames);
    }

~CodeGeneratorImpl() override {
      // There should normally not be any leftover inline method definitions.
      assert(DeferredInlineMemberFuncDefs.empty() ||
             Diags.hasErrorOccurred());
    }

CodeGenModule &CGM() {
      return *Builder;
    }

llvm::Module *GetModule() {
      return M.get();
    }

CGDebugInfo *getCGDebugInfo() {
      return Builder->getModuleDebugInfo();
    }

llvm::Module *ReleaseModule() {
      return M.release();
    }

const Decl *GetDeclForMangledName(StringRef MangledName) {
      GlobalDecl Result;
      if (!Builder->lookupRepresentativeDecl(MangledName, Result))
        return nullptr;
      const Decl *D = Result.getCanonicalDecl().getDecl();
      if (auto FD = dyn_cast<FunctionDecl>(D)) {
        if (FD->hasBody(FD))
          return FD;
      } else if (auto TD = dyn_cast<TagDecl>(D)) {
        if (auto Def = TD->getDefinition())
          return Def;
      }
      return D;
    }

llvm::Constant *GetAddrOfGlobal(GlobalDecl global, bool isForDefinition) {
      return Builder->GetAddrOfGlobal(global, ForDefinition_t(isForDefinition));
    }

llvm::Module *StartModule(llvm::StringRef ModuleName,
                              llvm::LLVMContext &C) {
      assert(!M && "Replacing existing Module?");
      M.reset(new llvm::Module(ExpandModuleName(ModuleName, CodeGenOpts), C));
      Initialize(*Ctx);
      return M.get();
    }

void Initialize(ASTContext &Context) override {
      Ctx = &Context;

M->setTargetTriple(Ctx->getTargetInfo().getTriple().getTriple());
      M->setDataLayout(Ctx->getTargetInfo().getDataLayout());
      const auto &SDKVersion = Ctx->getTargetInfo().getSDKVersion();
      if (!SDKVersion.empty())
        M->setSDKVersion(SDKVersion);
      Builder.reset(new CodeGen::CodeGenModule(Context, HeaderSearchOpts,
                                               PreprocessorOpts, CodeGenOpts,
                                               *M, Diags, CoverageInfo));

for (auto &&Lib : CodeGenOpts.DependentLibraries)
        Builder->AddDependentLib(Lib);
      for (auto &&Opt : CodeGenOpts.LinkerOptions)
        Builder->AppendLinkerOptions(Opt);
    }

void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
      if (Diags.hasErrorOccurred())
        return;

Builder->HandleCXXStaticMemberVarInstantiation(VD);
    }

bool HandleTopLevelDecl(DeclGroupRef DG) override {
      if (Diags.hasErrorOccurred())
        return true;

HandlingTopLevelDeclRAII HandlingDecl(*this);

// Make sure to emit all elements of a Decl.
      for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
        Builder->EmitTopLevelDecl(*I);

return true;
    }

void EmitDeferredDecls() {
      if (DeferredInlineMemberFuncDefs.empty())
        return;

// Emit any deferred inline method definitions. Note that more deferred
      // methods may be added during this loop, since ASTConsumer callbacks
      // can be invoked if AST inspection results in declarations being added.
      HandlingTopLevelDeclRAII HandlingDecl(*this);
      for (unsigned I = 0; I != DeferredInlineMemberFuncDefs.size(); ++I)
        Builder->EmitTopLevelDecl(DeferredInlineMemberFuncDefs[I]);
      DeferredInlineMemberFuncDefs.clear();
    }

void HandleInlineFunctionDefinition(FunctionDecl *D) override {
      if (Diags.hasErrorOccurred())
        return;

assert(D->doesThisDeclarationHaveABody());

// We may want to emit this definition. However, that decision might be
      // based on computing the linkage, and we have to defer that in case we
      // are inside of something that will change the method's final linkage,
      // e.g.
      //   typedef struct {
      //     void bar();
      //     void foo() { bar(); }
      //   } A;
      DeferredInlineMemberFuncDefs.push_back(D);

// Provide some coverage mapping even for methods that aren't emitted.
      // Don't do this for templated classes though, as they may not be
      // instantiable.
      if (!D->getLexicalDeclContext()->isDependentContext())
        Builder->AddDeferredUnusedCoverageMapping(D);
    }

/// HandleTagDeclDefinition - This callback is invoked each time a TagDecl
    /// to (e.g. struct, union, enum, class) is completed. This allows the
    /// client hack on the type, which can occur at any point in the file
    /// (because these can be defined in declspecs).
    void HandleTagDeclDefinition(TagDecl *D) override {
      if (Diags.hasErrorOccurred())
        return;

// Don't allow re-entrant calls to CodeGen triggered by PCH
      // deserialization to emit deferred decls.
      HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);

Builder->UpdateCompletedType(D);

// For MSVC compatibility, treat declarations of static data members with
      // inline initializers as definitions.
      if (Ctx->getTargetInfo().getCXXABI().isMicrosoft()) {
        for (Decl *Member : D->decls()) {
          if (VarDecl *VD = dyn_cast<VarDecl>(Member)) {
            if (Ctx->isMSStaticDataMemberInlineDefinition(VD) &&
                Ctx->DeclMustBeEmitted(VD)) {
              Builder->EmitGlobal(VD);
            }
          }
        }
      }
      // For OpenMP emit declare reduction functions, if required.
      if (Ctx->getLangOpts().OpenMP) {
        for (Decl *Member : D->decls()) {
          if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Member)) {
            if (Ctx->DeclMustBeEmitted(DRD))
              Builder->EmitGlobal(DRD);
          } else if (auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Member)) {
            if (Ctx->DeclMustBeEmitted(DMD))
              Builder->EmitGlobal(DMD);
          }
        }
      }
    }

void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
      if (Diags.hasErrorOccurred())
        return;

// Don't allow re-entrant calls to CodeGen triggered by PCH
      // deserialization to emit deferred decls.
      HandlingTopLevelDeclRAII HandlingDecl(*this, /*EmitDeferred=*/false);

if (CodeGen::CGDebugInfo *DI = Builder->getModuleDebugInfo())
        if (const RecordDecl *RD = dyn_cast<RecordDecl>(D))
          DI->completeRequiredType(RD);
    }

void HandleTranslationUnit(ASTContext &Ctx) override {
      // Release the Builder when there is no error.
      if (!Diags.hasErrorOccurred() && Builder)
        Builder->Release();

// If there are errors before or when releasing the Builder, reset
      // the module to stop here before invoking the backend.
      if (Diags.hasErrorOccurred()) {
        if (Builder)
          Builder->clear();
        M.reset();
        return;
      }
    }

void AssignInheritanceModel(CXXRecordDecl *RD) override {
      if (Diags.hasErrorOccurred())
        return;

Builder->RefreshTypeCacheForClass(RD);
    }

void CompleteTentativeDefinition(VarDecl *D) override {
      if (Diags.hasErrorOccurred())
        return;

Builder->EmitTentativeDefinition(D);
    }

void CompleteExternalDeclaration(VarDecl *D) override {
      Builder->EmitExternalDeclaration(D);
    }

void HandleVTable(CXXRecordDecl *RD) override {
      if (Diags.hasErrorOccurred())
        return;

Builder->EmitVTable(RD);
    }
  };
}

void CodeGenerator::anchor() { }

CodeGenModule &CodeGenerator::CGM() {
  return static_cast<CodeGeneratorImpl*>(this)->CGM();
}

llvm::Module *CodeGenerator::GetModule() {
  return static_cast<CodeGeneratorImpl*>(this)->GetModule();
}

llvm::Module *CodeGenerator::ReleaseModule() {
  return static_cast<CodeGeneratorImpl*>(this)->ReleaseModule();
}

CGDebugInfo *CodeGenerator::getCGDebugInfo() {
  return static_cast<CodeGeneratorImpl*>(this)->getCGDebugInfo();
}

const Decl *CodeGenerator::GetDeclForMangledName(llvm::StringRef name) {
  return static_cast<CodeGeneratorImpl*>(this)->GetDeclForMangledName(name);
}

llvm::Constant *CodeGenerator::GetAddrOfGlobal(GlobalDecl global,
                                               bool isForDefinition) {
  return static_cast<CodeGeneratorImpl*>(this)
           ->GetAddrOfGlobal(global, isForDefinition);
}

llvm::Module *CodeGenerator::StartModule(llvm::StringRef ModuleName,
                                         llvm::LLVMContext &C) {
  return static_cast<CodeGeneratorImpl*>(this)->StartModule(ModuleName, C);
}

CodeGenerator *clang::CreateLLVMCodeGen(
    DiagnosticsEngine &Diags, llvm::StringRef ModuleName,
    const HeaderSearchOptions &HeaderSearchOpts,
    const PreprocessorOptions &PreprocessorOpts, const CodeGenOptions &CGO,
    llvm::LLVMContext &C, CoverageSourceInfo *CoverageInfo) {
  return new CodeGeneratorImpl(Diags, ModuleName, HeaderSearchOpts,
                               PreprocessorOpts, CGO, C, CoverageInfo);
}

003 File Manager

Editing: ModuleBuilder.cpp

Upload File

Create Folder