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

Generated by: LCOV version 1.13