LCOV - code coverage report
Current view: top level - lib/Target - TargetMachineC.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 0 76 0.0 %
Date: 2018-02-21 17:27:13 Functions: 0 23 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- TargetMachine.cpp -------------------------------------------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the LLVM-C part of TargetMachine.h
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm-c/Core.h"
      15             : #include "llvm-c/Target.h"
      16             : #include "llvm-c/TargetMachine.h"
      17             : #include "llvm/Analysis/TargetTransformInfo.h"
      18             : #include "llvm/IR/DataLayout.h"
      19             : #include "llvm/IR/LegacyPassManager.h"
      20             : #include "llvm/IR/Module.h"
      21             : #include "llvm/Support/CodeGenCWrappers.h"
      22             : #include "llvm/Support/FileSystem.h"
      23             : #include "llvm/Support/FormattedStream.h"
      24             : #include "llvm/Support/Host.h"
      25             : #include "llvm/Support/TargetRegistry.h"
      26             : #include "llvm/Support/raw_ostream.h"
      27             : #include "llvm/Target/TargetMachine.h"
      28             : #include <cassert>
      29             : #include <cstdlib>
      30             : #include <cstring>
      31             : 
      32             : using namespace llvm;
      33             : 
      34             : static TargetMachine *unwrap(LLVMTargetMachineRef P) {
      35             :   return reinterpret_cast<TargetMachine *>(P);
      36             : }
      37             : static Target *unwrap(LLVMTargetRef P) {
      38             :   return reinterpret_cast<Target*>(P);
      39             : }
      40             : static LLVMTargetMachineRef wrap(const TargetMachine *P) {
      41             :   return reinterpret_cast<LLVMTargetMachineRef>(const_cast<TargetMachine *>(P));
      42             : }
      43             : static LLVMTargetRef wrap(const Target * P) {
      44             :   return reinterpret_cast<LLVMTargetRef>(const_cast<Target*>(P));
      45             : }
      46             : 
      47           0 : LLVMTargetRef LLVMGetFirstTarget() {
      48           0 :   if (TargetRegistry::targets().begin() == TargetRegistry::targets().end()) {
      49             :     return nullptr;
      50             :   }
      51             : 
      52           0 :   const Target *target = &*TargetRegistry::targets().begin();
      53           0 :   return wrap(target);
      54             : }
      55           0 : LLVMTargetRef LLVMGetNextTarget(LLVMTargetRef T) {
      56           0 :   return wrap(unwrap(T)->getNext());
      57             : }
      58             : 
      59           0 : LLVMTargetRef LLVMGetTargetFromName(const char *Name) {
      60             :   StringRef NameRef = Name;
      61           0 :   auto I = find_if(TargetRegistry::targets(),
      62           0 :                    [&](const Target &T) { return T.getName() == NameRef; });
      63           0 :   return I != TargetRegistry::targets().end() ? wrap(&*I) : nullptr;
      64             : }
      65             : 
      66           0 : LLVMBool LLVMGetTargetFromTriple(const char* TripleStr, LLVMTargetRef *T,
      67             :                                  char **ErrorMessage) {
      68             :   std::string Error;
      69             : 
      70           0 :   *T = wrap(TargetRegistry::lookupTarget(TripleStr, Error));
      71             : 
      72           0 :   if (!*T) {
      73           0 :     if (ErrorMessage)
      74           0 :       *ErrorMessage = strdup(Error.c_str());
      75             : 
      76             :     return 1;
      77             :   }
      78             : 
      79             :   return 0;
      80             : }
      81             : 
      82           0 : const char * LLVMGetTargetName(LLVMTargetRef T) {
      83           0 :   return unwrap(T)->getName();
      84             : }
      85             : 
      86           0 : const char * LLVMGetTargetDescription(LLVMTargetRef T) {
      87           0 :   return unwrap(T)->getShortDescription();
      88             : }
      89             : 
      90           0 : LLVMBool LLVMTargetHasJIT(LLVMTargetRef T) {
      91           0 :   return unwrap(T)->hasJIT();
      92             : }
      93             : 
      94           0 : LLVMBool LLVMTargetHasTargetMachine(LLVMTargetRef T) {
      95           0 :   return unwrap(T)->hasTargetMachine();
      96             : }
      97             : 
      98           0 : LLVMBool LLVMTargetHasAsmBackend(LLVMTargetRef T) {
      99           0 :   return unwrap(T)->hasMCAsmBackend();
     100             : }
     101             : 
     102           0 : LLVMTargetMachineRef LLVMCreateTargetMachine(LLVMTargetRef T,
     103             :         const char *Triple, const char *CPU, const char *Features,
     104             :         LLVMCodeGenOptLevel Level, LLVMRelocMode Reloc,
     105             :         LLVMCodeModel CodeModel) {
     106             :   Optional<Reloc::Model> RM;
     107           0 :   switch (Reloc){
     108             :     case LLVMRelocStatic:
     109             :       RM = Reloc::Static;
     110             :       break;
     111             :     case LLVMRelocPIC:
     112             :       RM = Reloc::PIC_;
     113             :       break;
     114             :     case LLVMRelocDynamicNoPic:
     115             :       RM = Reloc::DynamicNoPIC;
     116             :       break;
     117             :     default:
     118             :       break;
     119             :   }
     120             : 
     121             :   bool JIT;
     122           0 :   Optional<CodeModel::Model> CM = unwrap(CodeModel, JIT);
     123             : 
     124             :   CodeGenOpt::Level OL;
     125             :   switch (Level) {
     126             :     case LLVMCodeGenLevelNone:
     127             :       OL = CodeGenOpt::None;
     128             :       break;
     129             :     case LLVMCodeGenLevelLess:
     130             :       OL = CodeGenOpt::Less;
     131             :       break;
     132             :     case LLVMCodeGenLevelAggressive:
     133             :       OL = CodeGenOpt::Aggressive;
     134             :       break;
     135             :     default:
     136             :       OL = CodeGenOpt::Default;
     137             :       break;
     138             :   }
     139             : 
     140           0 :   TargetOptions opt;
     141           0 :   return wrap(unwrap(T)->createTargetMachine(Triple, CPU, Features, opt, RM, CM,
     142           0 :                                              OL, JIT));
     143             : }
     144             : 
     145           0 : void LLVMDisposeTargetMachine(LLVMTargetMachineRef T) { delete unwrap(T); }
     146             : 
     147           0 : LLVMTargetRef LLVMGetTargetMachineTarget(LLVMTargetMachineRef T) {
     148           0 :   const Target* target = &(unwrap(T)->getTarget());
     149           0 :   return wrap(target);
     150             : }
     151             : 
     152           0 : char* LLVMGetTargetMachineTriple(LLVMTargetMachineRef T) {
     153             :   std::string StringRep = unwrap(T)->getTargetTriple().str();
     154           0 :   return strdup(StringRep.c_str());
     155             : }
     156             : 
     157           0 : char* LLVMGetTargetMachineCPU(LLVMTargetMachineRef T) {
     158             :   std::string StringRep = unwrap(T)->getTargetCPU();
     159           0 :   return strdup(StringRep.c_str());
     160             : }
     161             : 
     162           0 : char* LLVMGetTargetMachineFeatureString(LLVMTargetMachineRef T) {
     163             :   std::string StringRep = unwrap(T)->getTargetFeatureString();
     164           0 :   return strdup(StringRep.c_str());
     165             : }
     166             : 
     167           0 : void LLVMSetTargetMachineAsmVerbosity(LLVMTargetMachineRef T,
     168             :                                       LLVMBool VerboseAsm) {
     169           0 :   unwrap(T)->Options.MCOptions.AsmVerbose = VerboseAsm;
     170           0 : }
     171             : 
     172           0 : LLVMTargetDataRef LLVMCreateTargetDataLayout(LLVMTargetMachineRef T) {
     173           0 :   return wrap(new DataLayout(unwrap(T)->createDataLayout()));
     174             : }
     175             : 
     176           0 : static LLVMBool LLVMTargetMachineEmit(LLVMTargetMachineRef T, LLVMModuleRef M,
     177             :                                       raw_pwrite_stream &OS,
     178             :                                       LLVMCodeGenFileType codegen,
     179             :                                       char **ErrorMessage) {
     180             :   TargetMachine* TM = unwrap(T);
     181             :   Module* Mod = unwrap(M);
     182             : 
     183           0 :   legacy::PassManager pass;
     184             : 
     185             :   std::string error;
     186             : 
     187           0 :   Mod->setDataLayout(TM->createDataLayout());
     188             : 
     189             :   TargetMachine::CodeGenFileType ft;
     190           0 :   switch (codegen) {
     191             :     case LLVMAssemblyFile:
     192             :       ft = TargetMachine::CGFT_AssemblyFile;
     193             :       break;
     194           0 :     default:
     195             :       ft = TargetMachine::CGFT_ObjectFile;
     196           0 :       break;
     197             :   }
     198           0 :   if (TM->addPassesToEmitFile(pass, OS, ft)) {
     199             :     error = "TargetMachine can't emit a file of this type";
     200           0 :     *ErrorMessage = strdup(error.c_str());
     201           0 :     return true;
     202             :   }
     203             : 
     204           0 :   pass.run(*Mod);
     205             : 
     206           0 :   OS.flush();
     207             :   return false;
     208             : }
     209             : 
     210           0 : LLVMBool LLVMTargetMachineEmitToFile(LLVMTargetMachineRef T, LLVMModuleRef M,
     211             :   char* Filename, LLVMCodeGenFileType codegen, char** ErrorMessage) {
     212             :   std::error_code EC;
     213           0 :   raw_fd_ostream dest(Filename, EC, sys::fs::F_None);
     214           0 :   if (EC) {
     215           0 :     *ErrorMessage = strdup(EC.message().c_str());
     216           0 :     return true;
     217             :   }
     218           0 :   bool Result = LLVMTargetMachineEmit(T, M, dest, codegen, ErrorMessage);
     219             :   dest.flush();
     220           0 :   return Result;
     221             : }
     222             : 
     223           0 : LLVMBool LLVMTargetMachineEmitToMemoryBuffer(LLVMTargetMachineRef T,
     224             :   LLVMModuleRef M, LLVMCodeGenFileType codegen, char** ErrorMessage,
     225             :   LLVMMemoryBufferRef *OutMemBuf) {
     226             :   SmallString<0> CodeString;
     227             :   raw_svector_ostream OStream(CodeString);
     228           0 :   bool Result = LLVMTargetMachineEmit(T, M, OStream, codegen, ErrorMessage);
     229             : 
     230           0 :   StringRef Data = OStream.str();
     231           0 :   *OutMemBuf =
     232           0 :       LLVMCreateMemoryBufferWithMemoryRangeCopy(Data.data(), Data.size(), "");
     233           0 :   return Result;
     234             : }
     235             : 
     236           0 : char *LLVMGetDefaultTargetTriple(void) {
     237           0 :   return strdup(sys::getDefaultTargetTriple().c_str());
     238             : }
     239             : 
     240           0 : void LLVMAddAnalysisPasses(LLVMTargetMachineRef T, LLVMPassManagerRef PM) {
     241           0 :   unwrap(PM)->add(
     242           0 :       createTargetTransformInfoWrapperPass(unwrap(T)->getTargetIRAnalysis()));
     243           0 : }

Generated by: LCOV version 1.13