slang_backend.cpp

/*
 * Copyright 2010-2012, 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 <string>
#include <vector>
#include <iostream>

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

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

#include "clang/CodeGen/ModuleBuilder.h"

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

#include "llvm/ADT/Twine.h"
#include "llvm/ADT/StringExtras.h"

#include "llvm/Bitcode/ReaderWriter.h"

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

#include "llvm/IR/Constant.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/DebugLoc.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/IRPrintingPasses.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"

#include "llvm/Transforms/IPO/PassManagerBuilder.h"

#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Support/TargetRegistry.h"

#include "llvm/MC/SubtargetFeature.h"

#include "slang_assert.h"
#include "slang.h"
#include "slang_bitcode_gen.h"
#include "slang_rs_context.h"
#include "slang_rs_export_foreach.h"
#include "slang_rs_export_func.h"
#include "slang_rs_export_reduce.h"
#include "slang_rs_export_type.h"
#include "slang_rs_export_var.h"
#include "slang_rs_metadata.h"

#include "rs_cc_options.h"

#include "StripUnkAttr/strip_unknown_attributes_pass.h"

namespace {
class VersionInfoPass : public llvm::ModulePass {
  const clang::CodeGenOptions &mCodeGenOpts;

  const char *getSlangLLVMVersion() const {
    if (mCodeGenOpts.getDebugInfo() != clang::codegenoptions::NoDebugInfo)
      return LLVM_VERSION_STRING;
    return nullptr;
  }

public:
  static char ID;
  VersionInfoPass(const clang::CodeGenOptions &codegenOpts)
      : ModulePass(ID), mCodeGenOpts(codegenOpts) {}
  virtual bool runOnModule(llvm::Module &M) override {
    const char *versionString = getSlangLLVMVersion();
    if (!versionString)
      return false;
    auto &ctx = M.getContext();
    auto md = M.getOrInsertNamedMetadata("slang.llvm.version");
    auto ver = llvm::MDString::get(ctx, versionString);
    md->addOperand(
        llvm::MDNode::get(ctx, llvm::ArrayRef<llvm::Metadata *>(ver)));
    return true;
  }
};

char VersionInfoPass::ID = 0;

llvm::ModulePass *createVersionInfoPass(const clang::CodeGenOptions &cgo) {
  return new VersionInfoPass(cgo);
}
}

namespace slang {

void Backend::CreateFunctionPasses() {
  if (!mPerFunctionPasses) {
    mPerFunctionPasses = new llvm::legacy::FunctionPassManager(mpModule);

    llvm::PassManagerBuilder PMBuilder;
    PMBuilder.OptLevel = mCodeGenOpts.OptimizationLevel;
    PMBuilder.populateFunctionPassManager(*mPerFunctionPasses);
  }
}

void Backend::CreateModulePasses() {
  if (!mPerModulePasses) {
    mPerModulePasses = new llvm::legacy::PassManager();

    llvm::PassManagerBuilder PMBuilder;
    PMBuilder.OptLevel = mCodeGenOpts.OptimizationLevel;
    PMBuilder.SizeLevel = mCodeGenOpts.OptimizeSize;
    PMBuilder.DisableUnitAtATime = 0; // TODO Pirama confirm if this is right

    if (mCodeGenOpts.UnrollLoops) {
      PMBuilder.DisableUnrollLoops = 0;
    } else {
      PMBuilder.DisableUnrollLoops = 1;
    }

    PMBuilder.populateModulePassManager(*mPerModulePasses);
    // Add a pass to strip off unknown/unsupported attributes.
    mPerModulePasses->add(createStripUnknownAttributesPass());
    if (!mContext->isCompatLib()) {
      // The version info pass is used to ensure that debugging
      // is matched between slang and bcc.
      mPerModulePasses->add(createVersionInfoPass(mCodeGenOpts));
    }
  }
}

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::legacy::FunctionPassManager(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 == nullptr) {
    mDiagEngine.Report(clang::diag::err_fe_unable_to_create_target) << Error;
    return false;
  }

  // Target Machine Options
  llvm::TargetOptions Options;

  // Use soft-float ABI for ARM (which is the target used by Slang during code
  // generation).  Codegen still uses hardware FPU by default.  To use software
  // floating point, add 'soft-float' feature to FeaturesStr below.
  Options.FloatABIType = llvm::FloatABI::Soft;

  // BCC needs all unknown symbols resolved at compilation time. So we don't
  // need any relocation model.
  llvm::Reloc::Model RM = llvm::Reloc::Static;

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

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

    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, mTargetOpts.CPU, FeaturesStr,
                                    Options, RM, CM);

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

  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, mBufferOutStream,
                              CGFT, OptLevel)) {
    mDiagEngine.Report(clang::diag::err_fe_unable_to_interface_with_target);
    return false;
  }

  return true;
}

Backend::Backend(RSContext *Context, clang::DiagnosticsEngine *DiagEngine,
                 const RSCCOptions &Opts,
                 const clang::HeaderSearchOptions &HeaderSearchOpts,
                 const clang::PreprocessorOptions &PreprocessorOpts,
                 const clang::CodeGenOptions &CodeGenOpts,
                 const clang::TargetOptions &TargetOpts, PragmaList *Pragmas,
                 llvm::raw_ostream *OS, Slang::OutputType OT,
                 clang::SourceManager &SourceMgr, bool AllowRSPrefix,
                 bool IsFilterscript)
    : ASTConsumer(), mTargetOpts(TargetOpts), mpModule(nullptr), mpOS(OS),
      mOT(OT), mGen(nullptr), mPerFunctionPasses(nullptr),
      mPerModulePasses(nullptr), mCodeGenPasses(nullptr),
      mBufferOutStream(*mpOS), mContext(Context),
      mSourceMgr(SourceMgr), mASTPrint(Opts.mASTPrint), mAllowRSPrefix(AllowRSPrefix),
      mIsFilterscript(IsFilterscript), mExportVarMetadata(nullptr),
      mExportFuncMetadata(nullptr), mExportForEachNameMetadata(nullptr),
      mExportForEachSignatureMetadata(nullptr),
      mExportReduceMetadata(nullptr),
      mExportTypeMetadata(nullptr), mRSObjectSlotsMetadata(nullptr),
      mRefCount(mContext->getASTContext()),
      mASTChecker(Context, Context->getTargetAPI(), IsFilterscript),
      mForEachHandler(Context),
      mLLVMContext(slang::getGlobalLLVMContext()), mDiagEngine(*DiagEngine),
      mCodeGenOpts(CodeGenOpts), mPragmas(Pragmas) {
  mGen = CreateLLVMCodeGen(mDiagEngine, "", HeaderSearchOpts, PreprocessorOpts,
      mCodeGenOpts, mLLVMContext);
}

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

  mpModule = mGen->GetModule();
}

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

  if (mASTPrint)
    Ctx.getTranslationUnitDecl()->dump();

  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 = nullptr;
    return;
  }

  slangAssert(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::Metadata*, 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));
    }
  }

  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::legacy::PassManager *LLEmitPM = new llvm::legacy::PassManager();
      LLEmitPM->add(llvm::createPrintModulePass(mBufferOutStream));
      LLEmitPM->run(*mpModule);
      break;
    }
    case Slang::OT_Bitcode: {
      writeBitcode(mBufferOutStream, *mpModule, getTargetAPI(),
                   mCodeGenOpts.OptimizationLevel, mCodeGenOpts.getDebugInfo());
      break;
    }
    case Slang::OT_Nothing: {
      return;
    }
    default: {
      slangAssert(false && "Unknown output type");
    }
  }
}

// Insert explicit padding fields into struct to follow the current layout.
//
// A similar algorithm is present in PadHelperFunctionStruct().
void Backend::PadStruct(clang::RecordDecl* RD) {
  // Example of padding:
  //
  //   // ORIGINAL CODE                   // TRANSFORMED CODE
  //   struct foo {                       struct foo {
  //     int a;                             int a;
  //     // 4 bytes of padding              char <RS_PADDING_FIELD_NAME>[4];
  //     long b;                            long b;
  //     int c;                             int c;
  //     // 4 bytes of (tail) padding       char <RS_PADDING_FIELD_NAME>[4];
  //   };                                 };

  // We collect all of RD's fields in a vector FieldsInfo.  We
  // represent tail padding as an entry in the FieldsInfo vector with a
  // null FieldDecl.
  typedef std::pair<size_t, clang::FieldDecl*> FieldInfoType;  // (pre-field padding bytes, field)
  std::vector<FieldInfoType> FieldsInfo;

  // RenderScript is C99-based, so we only expect to see fields.  We
  // could iterate over fields, but instead let's iterate over
  // everything, to verify that there are only fields.
  for (clang::Decl* D : RD->decls()) {
    clang::FieldDecl* FD = clang::dyn_cast<clang::FieldDecl>(D);
    slangAssert(FD && "found a non field declaration within a struct");
    FieldsInfo.push_back(std::make_pair(size_t(0), FD));
  }

  clang::ASTContext& ASTC = mContext->getASTContext();

  // ASTContext caches record layout.  We may transform the record in a way
  // that would render this cached information incorrect.  clang does
  // not provide any way to invalidate this cached information.  We
  // take the following approach:
  //
  // 1. ASSUME that record layout has not yet been computed for RD.
  //
  // 2. Create a temporary clone of RD, and compute its layout.
  //    ASSUME that we know how to clone RD in a way that copies all the
  //    properties that are relevant to its layout.
  //
  // 3. Use the layout information from the temporary clone to
  //    transform RD.
  //
  // NOTE: ASTContext also caches TypeInfo (see
  //       ASTContext::getTypeInfo()).  ASSUME that inserting padding
  //       fields doesn't change the type in any way that affects
  //       TypeInfo.
  //
  // NOTE: A RecordType knows its associated RecordDecl -- so even
  //       while we're manipulating RD, the associated RecordType
  //       still recognizes RD as its RecordDecl.  ASSUME that we
  //       don't do anything during our manipulation that would cause
  //       the RecordType to be followed to RD while RD is in a
  //       partially transformed state.

  // The assumptions above may be brittle, and if they are incorrect,
  // we may get mysterious failures.

  // create a temporary clone
  clang::RecordDecl* RDForLayout =
      clang::RecordDecl::Create(ASTC, clang::TTK_Struct, RD->getDeclContext(),
                                clang::SourceLocation(), clang::SourceLocation(),
                                nullptr /* IdentifierInfo */);
  RDForLayout->startDefinition();
  RDForLayout->setTypeForDecl(RD->getTypeForDecl());
  if (RD->hasAttrs())
    RDForLayout->setAttrs(RD->getAttrs());
  RDForLayout->completeDefinition();

  // move all fields from RD to RDForLayout
  for (const auto &info : FieldsInfo) {
    RD->removeDecl(info.second);
    info.second->setLexicalDeclContext(RDForLayout);
    RDForLayout->addDecl(info.second);
  }

  const clang::ASTRecordLayout& RL = ASTC.getASTRecordLayout(RDForLayout);

  // An exportable type cannot contain a bitfield.  However, it's
  // possible that this current type might have a bitfield and yet
  // share a common initial sequence with an exportable type, so even
  // if the current type has a bitfield, the current type still
  // needs to have explicit padding inserted (in case the two types
  // under discussion are members of a union).  We don't need to
  // insert any padding after the bitfield, however, because that
  // would be beyond the common initial sequence.
  bool foundBitField = false;

  // Is there any padding in this struct?
  bool foundPadding = false;

  unsigned fieldNo = 0;
  uint64_t fieldPrePaddingOffset = 0;  // byte offset of pre-field padding within struct
  for (auto &info : FieldsInfo) {
    const clang::FieldDecl* FD = info.second;

    if ((foundBitField = FD->isBitField()))
      break;

    const uint64_t fieldOffset = RL.getFieldOffset(fieldNo) >> 3;
    const size_t prePadding = fieldOffset - fieldPrePaddingOffset;
    foundPadding |= (prePadding != 0);
    info.first = prePadding;

    // get ready for the next field
    //
    //   assumes that getTypeSize() is the storage size of the Type -- for example,
    //   that it includes a struct's tail padding (if any)
    //
    fieldPrePaddingOffset = fieldOffset + (ASTC.getTypeSize(FD->getType()) >> 3);
    ++fieldNo;
  }

  if (!foundBitField) {
    // In order to ensure that the front end (including reflected
    // code) and back end agree on struct size (not just field
    // offsets) we may need to add explicit tail padding, just as we'e
    // added explicit padding between fields.
    slangAssert(RL.getSize().getQuantity() >= fieldPrePaddingOffset);
    if (const size_t tailPadding = RL.getSize().getQuantity() - fieldPrePaddingOffset) {
      foundPadding = true;
      FieldsInfo.push_back(std::make_pair(tailPadding, nullptr));
    }
  }

  if (false /* change to "true" for extra debugging output */) {
   if (foundPadding) {
     std::cout << "PadStruct(" << RD->getNameAsString() << "):" << std::endl;
     for (const auto &info : FieldsInfo)
       std::cout << "  " << info.first << ", " << (info.second ? info.second->getNameAsString() : "<tail>") << std::endl;
   }
  }

  if (foundPadding && Slang::IsLocInRSHeaderFile(RD->getLocation(), mSourceMgr)) {
    mContext->ReportError(RD->getLocation(), "system structure contains padding: '%0'")
        << RD->getName();
  }

  // now move fields from RDForLayout to RD, and add any necessary
  // padding fields
  const clang::QualType byteType = ASTC.getIntTypeForBitwidth(8, false /* not signed */);
  clang::IdentifierInfo* const paddingIdentifierInfo = &ASTC.Idents.get(RS_PADDING_FIELD_NAME);
  for (const auto &info : FieldsInfo) {
    if (info.first != 0) {
      // Create a padding field: "char <RS_PADDING_FIELD_NAME>[<info.first>];"

      // TODO: Do we need to do anything else to keep this field from being shown in debugger?
      //       There's no source location, and the field is marked as implicit.
      const clang::QualType paddingType =
          ASTC.getConstantArrayType(byteType,
                                    llvm::APInt(sizeof(info.first) << 3, info.first),
                                    clang::ArrayType::Normal, 0 /* IndexTypeQuals */);
      clang::FieldDecl* const FD =
          clang::FieldDecl::Create(ASTC, RD, clang::SourceLocation(), clang::SourceLocation(),
                                   paddingIdentifierInfo,
                                   paddingType,
                                   nullptr,  // TypeSourceInfo*
                                   nullptr,  // BW (bitwidth)
                                   false,    // Mutable = false
                                   clang::ICIS_NoInit);
      FD->setImplicit(true);
      RD->addDecl(FD);
    }
    if (info.second != nullptr) {
      RDForLayout->removeDecl(info.second);
      info.second->setLexicalDeclContext(RD);
      RD->addDecl(info.second);
    }
  }

  // There does not appear to be any safe way to delete a RecordDecl
  // -- for example, there is no RecordDecl destructor to invalidate
  // cached record layout, and if we were to get unlucky, some future
  // RecordDecl could be allocated in the same place as a deleted
  // RDForLayout and "inherit" the cached record layout from
  // RDForLayout.
}

void Backend::HandleTagDeclDefinition(clang::TagDecl *D) {
  // we want to insert explicit padding fields into structs per http://b/29154200 and http://b/28070272
  switch (D->getTagKind()) {
    case clang::TTK_Struct:
      PadStruct(llvm::cast<clang::RecordDecl>(D));
      break;

    case clang::TTK_Union:
      // cannot be part of an exported type
      break;

    case clang::TTK_Enum:
      // a scalar
      break;

    case clang::TTK_Class:
    case clang::TTK_Interface:
    default:
      slangAssert(false && "Unexpected TagTypeKind");
      break;
  }
  mGen->HandleTagDeclDefinition(D);
}

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

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

// 1) Add zero initialization of local RS object types
void Backend::AnnotateFunction(clang::FunctionDecl *FD) {
  if (FD &&
      FD->hasBody() &&
      !FD->isImplicit() &&
      !Slang::IsLocInRSHeaderFile(FD->getLocation(), mSourceMgr)) {
    mRefCount.Init();
    mRefCount.SetDeclContext(FD);
    mRefCount.HandleParamsAndLocals(FD);
  }
}

bool Backend::HandleTopLevelDecl(clang::DeclGroupRef D) {
  // Find and remember the types for rs_allocation and rs_script_call_t so
  // they can be used later for translating rsForEach() calls.
  for (clang::DeclGroupRef::iterator I = D.begin(), E = D.end();
       (mContext->getAllocationType().isNull() ||
        mContext->getScriptCallType().isNull()) &&
       I != E; I++) {
    if (clang::TypeDecl* TD = llvm::dyn_cast<clang::TypeDecl>(*I)) {
      clang::StringRef TypeName = TD->getName();
      if (TypeName.equals("rs_allocation")) {
        mContext->setAllocationType(TD);
      } else if (TypeName.equals("rs_script_call_t")) {
        mContext->setScriptCallType(TD);
      }
    }
  }

  // Disallow user-defined functions with prefix "rs"
  if (!mAllowRSPrefix) {
    // Iterate all function declarations in the program.
    for (clang::DeclGroupRef::iterator I = D.begin(), E = D.end();
         I != E; I++) {
      clang::FunctionDecl *FD = llvm::dyn_cast<clang::FunctionDecl>(*I);
      if (FD == nullptr)
        continue;
      if (!FD->getName().startswith("rs"))  // Check prefix
        continue;
      if (!Slang::IsLocInRSHeaderFile(FD->getLocation(), mSourceMgr))
        mContext->ReportError(FD->getLocation(),
                              "invalid function name prefix, "
                              "\"rs\" is reserved: '%0'")
            << FD->getName();
    }
  }

  for (clang::DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; I++) {
    clang::FunctionDecl *FD = llvm::dyn_cast<clang::FunctionDecl>(*I);
    if (FD) {
      // Handle forward reference from pragma (see
      // RSReducePragmaHandler::HandlePragma for backward reference).
      mContext->markUsedByReducePragma(FD, RSContext::CheckNameYes);
      if (FD->isGlobal()) {
        // Check that we don't have any array parameters being misinterpreted as
        // kernel pointers due to the C type system's array to pointer decay.
        size_t numParams = FD->getNumParams();
        for (size_t i = 0; i < numParams; i++) {
          const clang::ParmVarDecl *PVD = FD->getParamDecl(i);
          clang::QualType QT = PVD->getOriginalType();
          if (QT->isArrayType()) {
            mContext->ReportError(
                PVD->getTypeSpecStartLoc(),
                "exported function parameters may not have array type: %0")
                << QT;
          }
        }
        AnnotateFunction(FD);
      }
    }

    if (getTargetAPI() >= SLANG_FEATURE_SINGLE_SOURCE_API) {
      if (FD && FD->hasBody() && !FD->isImplicit() &&
          !Slang::IsLocInRSHeaderFile(FD->getLocation(), mSourceMgr)) {
        if (FD->hasAttr<clang::RenderScriptKernelAttr>()) {
          // Log functions with attribute "kernel" by their names, and assign
          // them slot numbers. Any other function cannot be used in a
          // rsForEach() or rsForEachWithOptions() call, including old-style
          // kernel functions which are defined without the "kernel" attribute.
          mContext->addForEach(FD);
        }
        // Look for any kernel launch calls and translate them into using the
        // internal API.
        // Report a compiler error on kernel launches inside a kernel.
        mForEachHandler.handleForEachCalls(FD, getTargetAPI());
      }
    }
  }

  return mGen->HandleTopLevelDecl(D);
}

void Backend::HandleTranslationUnitPre(clang::ASTContext &C) {
  clang::TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();

  if (!mContext->processReducePragmas(this))
    return;

  // If we have an invalid RS/FS AST, don't check further.
  if (!mASTChecker.Validate()) {
    return;
  }

  if (mIsFilterscript) {
    mContext->addPragma("rs_fp_relaxed", "");
  }

  int version = mContext->getVersion();
  if (version == 0) {
    // Not setting a version is an error
    mDiagEngine.Report(
        mSourceMgr.getLocForEndOfFile(mSourceMgr.getMainFileID()),
        mDiagEngine.getCustomDiagID(
            clang::DiagnosticsEngine::Error,
            "missing pragma for version in source file"));
  } else {
    slangAssert(version == 1);
  }

  if (mContext->getReflectJavaPackageName().empty()) {
    mDiagEngine.Report(
        mSourceMgr.getLocForEndOfFile(mSourceMgr.getMainFileID()),
        mDiagEngine.getCustomDiagID(clang::DiagnosticsEngine::Error,
                                    "missing \"#pragma rs "
                                    "java_package_name(com.foo.bar)\" "
                                    "in source file"));
    return;
  }

  // Create a static global destructor if necessary (to handle RS object
  // runtime cleanup).
  clang::FunctionDecl *FD = mRefCount.CreateStaticGlobalDtor();
  if (FD) {
    HandleTopLevelDecl(clang::DeclGroupRef(FD));
  }

  // Process any static function declarations
  for (clang::DeclContext::decl_iterator I = TUDecl->decls_begin(),
          E = TUDecl->decls_end(); I != E; I++) {
    if ((I->getKind() >= clang::Decl::firstFunction) &&
        (I->getKind() <= clang::Decl::lastFunction)) {
      clang::FunctionDecl *FD = llvm::dyn_cast<clang::FunctionDecl>(*I);
      if (FD && !FD->isGlobal()) {
        AnnotateFunction(FD);
      }
    }
  }
}

///////////////////////////////////////////////////////////////////////////////
void Backend::dumpExportVarInfo(llvm::Module *M) {
  int slotCount = 0;
  if (mExportVarMetadata == nullptr)
    mExportVarMetadata = M->getOrInsertNamedMetadata(RS_EXPORT_VAR_MN);

  llvm::SmallVector<llvm::Metadata *, 2> ExportVarInfo;

  // We emit slot information (#rs_object_slots) for any reference counted
  // RS type or pointer (which can also be bound).

  for (RSContext::const_export_var_iterator I = mContext->export_vars_begin(),
          E = mContext->export_vars_end();
       I != E;
       I++) {
    const RSExportVar *EV = *I;
    const RSExportType *ET = EV->getType();
    bool countsAsRSObject = false;

    // Variable name
    ExportVarInfo.push_back(
        llvm::MDString::get(mLLVMContext, EV->getName().c_str()));

    // Type name
    switch (ET->getClass()) {
      case RSExportType::ExportClassPrimitive: {
        const RSExportPrimitiveType *PT =
            static_cast<const RSExportPrimitiveType*>(ET);
        ExportVarInfo.push_back(
            llvm::MDString::get(
              mLLVMContext, llvm::utostr(PT->getType())));
        if (PT->isRSObjectType()) {
          countsAsRSObject = true;
        }
        break;
      }
      case RSExportType::ExportClassPointer: {
        ExportVarInfo.push_back(
            llvm::MDString::get(
              mLLVMContext, ("*" + static_cast<const RSExportPointerType*>(ET)
                ->getPointeeType()->getName()).c_str()));
        break;
      }
      case RSExportType::ExportClassMatrix: {
        ExportVarInfo.push_back(
            llvm::MDString::get(
              mLLVMContext, llvm::utostr(
                  /* TODO Strange value.  This pushes just a number, quite
                   * different than the other cases.  What is this used for?
                   * These are the metadata values that some partner drivers
                   * want to reference (for TBAA, etc.). We may want to look
                   * at whether these provide any reasonable value (or have
                   * distinct enough values to actually depend on).
                   */
                DataTypeRSMatrix2x2 +
                static_cast<const RSExportMatrixType*>(ET)->getDim() - 2)));
        break;
      }
      case RSExportType::ExportClassVector:
      case RSExportType::ExportClassConstantArray:
      case RSExportType::ExportClassRecord: {
        ExportVarInfo.push_back(
            llvm::MDString::get(mLLVMContext,
              EV->getType()->getName().c_str()));
        break;
      }
    }

    mExportVarMetadata->addOperand(
        llvm::MDNode::get(mLLVMContext, ExportVarInfo));
    ExportVarInfo.clear();

    if (mRSObjectSlotsMetadata == nullptr) {
      mRSObjectSlotsMetadata =
          M->getOrInsertNamedMetadata(RS_OBJECT_SLOTS_MN);
    }

    if (countsAsRSObject) {
      mRSObjectSlotsMetadata->addOperand(llvm::MDNode::get(mLLVMContext,
          llvm::MDString::get(mLLVMContext, llvm::utostr(slotCount))));
    }

    slotCount++;
  }
}

// A similar algorithm is present in Backend::PadStruct().
static void PadHelperFunctionStruct(llvm::Module *M,
                                    llvm::StructType **paddedStructType,
                                    std::vector<unsigned> *origFieldNumToPaddedFieldNum,
                                    llvm::StructType *origStructType) {
  slangAssert(origFieldNumToPaddedFieldNum->empty());
  origFieldNumToPaddedFieldNum->resize(2 * origStructType->getNumElements());

  llvm::LLVMContext &llvmContext = M->getContext();

  const llvm::DataLayout *DL = &M->getDataLayout();
  const llvm::StructLayout *SL = DL->getStructLayout(origStructType);

  // Field types -- including any padding fields we need to insert.
  std::vector<llvm::Type *> paddedFieldTypes;
  paddedFieldTypes.reserve(2 * origStructType->getNumElements());

  // Is there any padding in this struct?
  bool foundPadding = false;

  llvm::Type *const byteType = llvm::Type::getInt8Ty(llvmContext);
  unsigned origFieldNum = 0, paddedFieldNum = 0;
  uint64_t fieldPrePaddingOffset = 0;  // byte offset of pre-field padding within struct
  for (llvm::Type *fieldType : origStructType->elements()) {
    const uint64_t fieldOffset = SL->getElementOffset(origFieldNum);
    const size_t prePadding = fieldOffset - fieldPrePaddingOffset;
    if (prePadding != 0) {
      foundPadding = true;
      paddedFieldTypes.push_back(llvm::ArrayType::get(byteType, prePadding));
      ++paddedFieldNum;
    }
    paddedFieldTypes.push_back(fieldType);
    (*origFieldNumToPaddedFieldNum)[origFieldNum] = paddedFieldNum;

    // get ready for the next field
    fieldPrePaddingOffset = fieldOffset + DL->getTypeAllocSize(fieldType);
    ++origFieldNum;
    ++paddedFieldNum;
  }

  // In order to ensure that the front end (including reflected code)
  // and back end agree on struct size (not just field offsets) we may
  // need to add explicit tail padding, just as we'e added explicit
  // padding between fields.
  slangAssert(SL->getSizeInBytes() >= fieldPrePaddingOffset);
  if (const size_t tailPadding = SL->getSizeInBytes() - fieldPrePaddingOffset) {
    foundPadding = true;
    paddedFieldTypes.push_back(llvm::ArrayType::get(byteType, tailPadding));
  }

  *paddedStructType = (foundPadding
                       ? llvm::StructType::get(llvmContext, paddedFieldTypes)
                       : origStructType);
}

void Backend::dumpExportFunctionInfo(llvm::Module *M) {
  if (mExportFuncMetadata == nullptr)
    mExportFuncMetadata =
        M->getOrInsertNamedMetadata(RS_EXPORT_FUNC_MN);

  llvm::SmallVector<llvm::Metadata *, 1> ExportFuncInfo;

  for (RSContext::const_export_func_iterator
          I = mContext->export_funcs_begin(),
          E = mContext->export_funcs_end();
       I != E;
       I++) {
    const RSExportFunc *EF = *I;

    // Function name
    if (!EF->hasParam()) {
      ExportFuncInfo.push_back(llvm::MDString::get(mLLVMContext,
                                                   EF->getName().c_str()));
    } else {
      llvm::Function *F = M->getFunction(EF->getName());
      llvm::Function *HelperFunction;
      const std::string HelperFunctionName(".helper_" + EF->getName());

      slangAssert(F && "Function marked as exported disappeared in Bitcode");

      // Create helper function
      {
        llvm::StructType *OrigHelperFunctionParameterTy = nullptr;
        llvm::StructType *PaddedHelperFunctionParameterTy = nullptr;

        std::vector<unsigned> OrigFieldNumToPaddedFieldNum;
        std::vector<bool> isPassedViaPtr;

        if (!F->getArgumentList().empty()) {
          std::vector<llvm::Type*> HelperFunctionParameterTys;
          for (llvm::Function::arg_iterator AI = F->arg_begin(),
                                            AE = F->arg_end();
               AI != AE; AI++) {
            if (AI->getType()->isPointerTy() &&
                AI->getType()->getPointerElementType()->isStructTy()) {
              HelperFunctionParameterTys.push_back(
                  AI->getType()->getPointerElementType());
              isPassedViaPtr.push_back(true);
            } else {
              // on 64-bit architecture(s), a vector type could be too big
              // to be passed in a register and instead passed
              // via a pointer to a temporary copy
              llvm::Type *Ty = AI->getType();
              bool viaPtr = false;
              if (Ty->isPointerTy() && Ty->getPointerElementType()) {
                Ty = Ty->getPointerElementType();
                viaPtr = true;
              }
              HelperFunctionParameterTys.push_back(Ty);
              isPassedViaPtr.push_back(viaPtr);
            }
          }
          OrigHelperFunctionParameterTy =
              llvm::StructType::get(mLLVMContext, HelperFunctionParameterTys);
          PadHelperFunctionStruct(M,
                                  &PaddedHelperFunctionParameterTy, &OrigFieldNumToPaddedFieldNum,
                                  OrigHelperFunctionParameterTy);
        }

        if (!EF->checkParameterPacketType(OrigHelperFunctionParameterTy)) {
          fprintf(stderr, "Failed to export function %s: parameter type "
                          "mismatch during creation of helper function.\n",
                  EF->getName().c_str());

          const RSExportRecordType *Expected = EF->getParamPacketType();
          if (Expected) {
            fprintf(stderr, "Expected:\n");
            Expected->getLLVMType()->dump();
          }
          if (OrigHelperFunctionParameterTy) {
            fprintf(stderr, "Got:\n");
            OrigHelperFunctionParameterTy->dump();
          }
          abort();
        }

        std::vector<llvm::Type*> Params;
        if (PaddedHelperFunctionParameterTy) {
          llvm::PointerType *HelperFunctionParameterTyP =
              llvm::PointerType::getUnqual(PaddedHelperFunctionParameterTy);
          Params.push_back(HelperFunctionParameterTyP);
        }

        llvm::FunctionType * HelperFunctionType =
            llvm::FunctionType::get(F->getReturnType(),
                                    Params,
                                    /* IsVarArgs = */false);

        HelperFunction =
            llvm::Function::Create(HelperFunctionType,
                                   llvm::GlobalValue::ExternalLinkage,
                                   HelperFunctionName,
                                   M);

        HelperFunction->addFnAttr(llvm::Attribute::NoInline);
        HelperFunction->setCallingConv(F->getCallingConv());

        // Create helper function body
        {
          llvm::Argument *HelperFunctionParameter =
              &(*HelperFunction->arg_begin());
          llvm::BasicBlock *BB =
              llvm::BasicBlock::Create(mLLVMContext, "entry", HelperFunction);
          llvm::IRBuilder<> *IB = new llvm::IRBuilder<>(BB);
          llvm::SmallVector<llvm::Value*, 6> Params;
          llvm::Value *Idx[2];

          Idx[0] =
              llvm::ConstantInt::get(llvm::Type::getInt32Ty(mLLVMContext), 0);

          // getelementptr and load instruction for all elements in
          // parameter .p
          for (size_t origFieldNum = 0; origFieldNum < EF->getNumParameters(); origFieldNum++) {
            // getelementptr
            Idx[1] = llvm::ConstantInt::get(
              llvm::Type::getInt32Ty(mLLVMContext), OrigFieldNumToPaddedFieldNum[origFieldNum]);

            llvm::Value *Ptr = NULL;

            Ptr = IB->CreateInBoundsGEP(HelperFunctionParameter, Idx);

            // Load is only required for non-struct ptrs
            if (isPassedViaPtr[origFieldNum]) {
                Params.push_back(Ptr);
            } else {
                llvm::Value *V = IB->CreateLoad(Ptr);
                Params.push_back(V);
            }
          }

          // Call and pass the all elements as parameter to F
          llvm::CallInst *CI = IB->CreateCall(F, Params);

          CI->setCallingConv(F->getCallingConv());

          if (F->getReturnType() == llvm::Type::getVoidTy(mLLVMContext)) {
            IB->CreateRetVoid();
          } else {
            IB->CreateRet(CI);
          }

          delete IB;
        }
      }

      ExportFuncInfo.push_back(
          llvm::MDString::get(mLLVMContext, HelperFunctionName.c_str()));
    }

    mExportFuncMetadata->addOperand(
        llvm::MDNode::get(mLLVMContext, ExportFuncInfo));
    ExportFuncInfo.clear();
  }
}

void Backend::dumpExportForEachInfo(llvm::Module *M) {
  if (mExportForEachNameMetadata == nullptr) {
    mExportForEachNameMetadata =
        M->getOrInsertNamedMetadata(RS_EXPORT_FOREACH_NAME_MN);
  }
  if (mExportForEachSignatureMetadata == nullptr) {
    mExportForEachSignatureMetadata =
        M->getOrInsertNamedMetadata(RS_EXPORT_FOREACH_MN);
  }

  llvm::SmallVector<llvm::Metadata *, 1> ExportForEachName;
  llvm::SmallVector<llvm::Metadata *, 1> ExportForEachInfo;

  for (RSContext::const_export_foreach_iterator
          I = mContext->export_foreach_begin(),
          E = mContext->export_foreach_end();
       I != E;
       I++) {
    const RSExportForEach *EFE = *I;

    ExportForEachName.push_back(
        llvm::MDString::get(mLLVMContext, EFE->getName().c_str()));

    mExportForEachNameMetadata->addOperand(
        llvm::MDNode::get(mLLVMContext, ExportForEachName));
    ExportForEachName.clear();

    ExportForEachInfo.push_back(
        llvm::MDString::get(mLLVMContext,
                            llvm::utostr(EFE->getSignatureMetadata())));

    mExportForEachSignatureMetadata->addOperand(
        llvm::MDNode::get(mLLVMContext, ExportForEachInfo));
    ExportForEachInfo.clear();
  }
}

void Backend::dumpExportReduceInfo(llvm::Module *M) {
  if (!mExportReduceMetadata) {
    mExportReduceMetadata =
      M->getOrInsertNamedMetadata(RS_EXPORT_REDUCE_MN);
  }

  llvm::SmallVector<llvm::Metadata *, 6> ExportReduceInfo;
  // Add operand to ExportReduceInfo, padding out missing operands with
  // nullptr.
  auto addOperand = [&ExportReduceInfo](uint32_t Idx, llvm::Metadata *N) {
    while (Idx > ExportReduceInfo.size())
      ExportReduceInfo.push_back(nullptr);
    ExportReduceInfo.push_back(N);
  };
  // Add string operand to ExportReduceInfo, padding out missing operands
  // with nullptr.
  // If string is empty, then do not add it unless Always is true.
  auto addString = [&addOperand, this](uint32_t Idx, const std::string &S,
                                       bool Always = true) {
    if (Always || !S.empty())
      addOperand(Idx, llvm::MDString::get(mLLVMContext, S));
  };

  // Add the description of the reduction kernels to the metadata node.
  for (auto I = mContext->export_reduce_begin(),
            E = mContext->export_reduce_end();
       I != E; ++I) {
    ExportReduceInfo.clear();

    int Idx = 0;

    addString(Idx++, (*I)->getNameReduce());

    addOperand(Idx++, llvm::MDString::get(mLLVMContext, llvm::utostr((*I)->getAccumulatorTypeSize())));

    llvm::SmallVector<llvm::Metadata *, 2> Accumulator;
    Accumulator.push_back(
      llvm::MDString::get(mLLVMContext, (*I)->getNameAccumulator()));
    Accumulator.push_back(llvm::MDString::get(
      mLLVMContext,
      llvm::utostr((*I)->getAccumulatorSignatureMetadata())));
    addOperand(Idx++, llvm::MDTuple::get(mLLVMContext, Accumulator));

    addString(Idx++, (*I)->getNameInitializer(), false);
    addString(Idx++, (*I)->getNameCombiner(), false);
    addString(Idx++, (*I)->getNameOutConverter(), false);
    addString(Idx++, (*I)->getNameHalter(), false);

    mExportReduceMetadata->addOperand(
      llvm::MDTuple::get(mLLVMContext, ExportReduceInfo));
  }
}

void Backend::dumpExportTypeInfo(llvm::Module *M) {
  llvm::SmallVector<llvm::Metadata *, 1> ExportTypeInfo;

  for (RSContext::const_export_type_iterator
          I = mContext->export_types_begin(),
          E = mContext->export_types_end();
       I != E;
       I++) {
    // First, dump type name list to export
    const RSExportType *ET = I->getValue();

    ExportTypeInfo.clear();
    // Type name
    ExportTypeInfo.push_back(
        llvm::MDString::get(mLLVMContext, ET->getName().c_str()));

    if (ET->getClass() == RSExportType::ExportClassRecord) {
      const RSExportRecordType *ERT =
          static_cast<const RSExportRecordType*>(ET);

      if (mExportTypeMetadata == nullptr)
        mExportTypeMetadata =
            M->getOrInsertNamedMetadata(RS_EXPORT_TYPE_MN);

      mExportTypeMetadata->addOperand(
          llvm::MDNode::get(mLLVMContext, ExportTypeInfo));

      // Now, export struct field information to %[struct name]
      std::string StructInfoMetadataName("%");
      StructInfoMetadataName.append(ET->getName());
      llvm::NamedMDNode *StructInfoMetadata =
          M->getOrInsertNamedMetadata(StructInfoMetadataName);
      llvm::SmallVector<llvm::Metadata *, 3> FieldInfo;

      slangAssert(StructInfoMetadata->getNumOperands() == 0 &&
                  "Metadata with same name was created before");
      for (RSExportRecordType::const_field_iterator FI = ERT->fields_begin(),
              FE = ERT->fields_end();
           FI != FE;
           FI++) {
        const RSExportRecordType::Field *F = *FI;

        // 1. field name
        FieldInfo.push_back(llvm::MDString::get(mLLVMContext,
                                                F->getName().c_str()));

        // 2. field type name
        FieldInfo.push_back(
            llvm::MDString::get(mLLVMContext,
                                F->getType()->getName().c_str()));

        StructInfoMetadata->addOperand(
            llvm::MDNode::get(mLLVMContext, FieldInfo));
        FieldInfo.clear();
      }
    }   // ET->getClass() == RSExportType::ExportClassRecord
  }
}

void Backend::HandleTranslationUnitPost(llvm::Module *M) {

  if (!mContext->is64Bit()) {
    M->setDataLayout("e-p:32:32-i64:64-v128:64:128-n32-S64");
  }

  if (!mContext->processExports())
    return;

  if (mContext->hasExportVar())
    dumpExportVarInfo(M);

  if (mContext->hasExportFunc())
    dumpExportFunctionInfo(M);

  if (mContext->hasExportForEach())
    dumpExportForEachInfo(M);

  if (mContext->hasExportReduce())
    dumpExportReduceInfo(M);

  if (mContext->hasExportType())
    dumpExportTypeInfo(M);
}

}  // namespace slang