Add a target environment for CoreCLR.

[pgavlin]

Summary

Although targeting CoreCLR is very similar to targeting MSVC, we expect there to be certain important differences that the backend must be aware of. At the moment, we're only aware of one--stack probes must be emitted differently when targeting CoreCLR--but there are likely to be others.

I'll submit the changes necessary to emit stack probes for CoreCLR in a separate review.

[AndyAyers]

LGTM

[nikola]

I'm a small potato but LGTM.

[rnk]

Can you elaborate on the chkstk difference? Various other people like the rust folks have use cases for controlling that, so if that's the only codegen difference, I'd rather not have a new environment. At this point, we have a function attribute "stack-probe-size" that essentially controls the guard page size, and we can easily add another attribute to control the stack check symbol to call. Lots of high level languages want to catch stack overflow and they usually want it to call into their runtime.

[compnerd]

AFAIK, the stack probe itself is different on the CLR (additional parameters need to be setup). I do agree with @rnk that it seems a bit excessive to have an entire environment for the minor divergences. Could we get away with squirreling away information in either the DL or as metadata? Unless of course, there are serious divergences that we are overlooking (which would be nice to have called out when we add this new environment).

[AndyAyers]

Currently in LLILC's main branch there's just one use: the CoreCLR has to expand the stack checks inline (both for prolog and in-body cases); there is no library helper available to call.

We also plan to use this environment to provide custom lowering of LLVM operators to special helper methods provided by the CoreCLR (memcpy, int-float conversion, frem, etc). Right now we're lowering to calls early and so missing out on potential optimizations.

We also are using this for some aspects of the EH work we're bringing up.

[rnk]

In D11012#208587, @AndyAyers wrote:

Currently in LLILC's main branch there's just one use: the CoreCLR has to expand the stack checks inline (both for prolog and in-body cases); there is no library helper available to call.

We also plan to use this environment to provide custom lowering of LLVM operators to special helper methods provided by the CoreCLR (memcpy, int-float conversion, frem, etc). Right now we're lowering to calls early and so missing out on potential optimizations.

We also are using this for some aspects of the EH work we're bringing up.

OK, this seems like a good use for a string function attribute. To go along with "stack-probe-size", I'm thinking "stack-probe-function". An empty string value means there is no function provided by the runtime, and we need to splat out some ORs or a loop for dynamic alloca.

[majnemer]

I think it makes sense for this to be its own triple because it will need custom SDAG trickery.

[rnk]

Agreed, if we need to change the lowering of FP operations, like calling a different set of runtime functions, then this should probably be an environment.

[pgavlin]

Rebased against latest changes.

llvm/trunk/include/llvm/ADT/Triple.h

enum EnvironmentType {
     EABI,
     EABIHF,
     Android,
 
     MSVC,
     Itanium,
     Cygnus,
     AMDOpenCL,
-    LastEnvironmentType = AMDOpenCL
+    CoreCLR,
+    LastEnvironmentType = CoreCLR
   };
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
     ELF,
     MachO,
   };
return getOS() == Triple::Win32 &&
            (getEnvironment() == Triple::UnknownEnvironment ||
             getEnvironment() == Triple::MSVC);
   }
 
   bool isKnownWindowsMSVCEnvironment() const {
     return getOS() == Triple::Win32 && getEnvironment() == Triple::MSVC;
   }
 
+  bool isWindowsCoreCLREnvironment() const {
+    return getOS() == Triple::Win32 && getEnvironment() == Triple::CoreCLR;
+  }
+
   bool isWindowsItaniumEnvironment() const {
     return getOS() == Triple::Win32 && getEnvironment() == Triple::Itanium;
   }
 
   bool isWindowsCygwinEnvironment() const {
     return getOS() == Triple::Win32 && getEnvironment() == Triple::Cygnus;
   }
 

llvm/trunk/lib/Support/Triple.cpp

const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   case CODE16: return "code16";
   case EABI: return "eabi";
   case EABIHF: return "eabihf";
   case Android: return "android";
   case MSVC: return "msvc";
   case Itanium: return "itanium";
   case Cygnus: return "cygnus";
   case AMDOpenCL: return "amdopencl";
+  case CoreCLR: return "coreclr";
   }
 
   llvm_unreachable("Invalid EnvironmentType!");
 }
 
 static Triple::ArchType parseBPFArch(StringRef ArchName) {
   if (ArchName.equals("bpf")) {
     if (sys::IsLittleEndianHost)
return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .StartsWith("gnux32", Triple::GNUX32)
     .StartsWith("code16", Triple::CODE16)
     .StartsWith("gnu", Triple::GNU)
     .StartsWith("android", Triple::Android)
     .StartsWith("msvc", Triple::MSVC)
     .StartsWith("itanium", Triple::Itanium)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("amdopencl", Triple::AMDOpenCL)
+    .StartsWith("coreclr", Triple::CoreCLR)
     .Default(Triple::UnknownEnvironment);
 }
 
 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
     .EndsWith("coff", Triple::COFF)
     .EndsWith("elf", Triple::ELF)
     .EndsWith("macho", Triple::MachO)

llvm/trunk/lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

static MCAsmInfo *createX86MCAsmInfo(const MCRegisterInfo &MRI,
   if (TheTriple.isOSBinFormatMachO()) {
     if (is64Bit)
       MAI = new X86_64MCAsmInfoDarwin(TheTriple);
     else
       MAI = new X86MCAsmInfoDarwin(TheTriple);
   } else if (TheTriple.isOSBinFormatELF()) {
     // Force the use of an ELF container.
     MAI = new X86ELFMCAsmInfo(TheTriple);
-  } else if (TheTriple.isWindowsMSVCEnvironment()) {
+  } else if (TheTriple.isWindowsMSVCEnvironment() ||
+             TheTriple.isWindowsCoreCLREnvironment()) {
     MAI = new X86MCAsmInfoMicrosoft(TheTriple);
   } else if (TheTriple.isOSCygMing() ||
              TheTriple.isWindowsItaniumEnvironment()) {
     MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
   } else {
     // The default is ELF.
     MAI = new X86ELFMCAsmInfo(TheTriple);
   }

llvm/trunk/lib/Target/X86/X86Subtarget.h

public:
   bool isTargetWindowsMSVC() const {
     return TargetTriple.isWindowsMSVCEnvironment();
   }
 
   bool isTargetKnownWindowsMSVC() const {
     return TargetTriple.isKnownWindowsMSVCEnvironment();
   }
 
+  bool isTargetWindowsCoreCLR() const {
+    return TargetTriple.isWindowsCoreCLREnvironment();
+  }
+
   bool isTargetWindowsCygwin() const {
     return TargetTriple.isWindowsCygwinEnvironment();
   }
 
   bool isTargetWindowsGNU() const {
     return TargetTriple.isWindowsGNUEnvironment();
   }
 

llvm/trunk/lib/Target/X86/X86TargetMachine.cpp

if (TT.getArch() == Triple::x86_64)
       return make_unique<X86_64MachoTargetObjectFile>();
     return make_unique<TargetLoweringObjectFileMachO>();
   }
 
   if (TT.isOSLinux() || TT.isOSNaCl())
     return make_unique<X86LinuxNaClTargetObjectFile>();
   if (TT.isOSBinFormatELF())
     return make_unique<X86ELFTargetObjectFile>();
-  if (TT.isKnownWindowsMSVCEnvironment())
+  if (TT.isKnownWindowsMSVCEnvironment() || TT.isWindowsCoreCLREnvironment())
     return make_unique<X86WindowsTargetObjectFile>();
   if (TT.isOSBinFormatCOFF())
     return make_unique<TargetLoweringObjectFileCOFF>();
   llvm_unreachable("unknown subtarget type");
 }
 
 static std::string computeDataLayout(const Triple &TT) {
   // X86 is little endian

llvm/trunk/test/CodeGen/WinEH/seh-catch-all.ll

-; RUN: opt -S -winehprepare < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-pc-windows-msvc < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc"
 
 @str.__except = internal unnamed_addr constant [9 x i8] c"__except\00", align 1
 
 ; Function Attrs: uwtable
 
 declare i32 @puts(i8*)
 
 define void @may_crash() {

llvm/trunk/test/CodeGen/WinEH/seh-inlined-finally.ll

-; RUN: opt -S -winehprepare < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-pc-windows-msvc < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
 
 ; Check that things work when the mid-level optimizer inlines the finally
 ; block.
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc"
 
 %struct._RTL_CRITICAL_SECTION = type { %struct._RTL_CRITICAL_SECTION_DEBUG*, i32, i32, i8*, i8*, i64 }
 %struct._RTL_CRITICAL_SECTION_DEBUG = type { i16, i16, %struct._RTL_CRITICAL_SECTION*, %struct._LIST_ENTRY, i32, i32, i32, i16, i16 }
 %struct._LIST_ENTRY = type { %struct._LIST_ENTRY*, %struct._LIST_ENTRY* }
 
 declare i32 @puts(i8*)
 declare void @may_crash()
 declare i32 @__C_specific_handler(...)

llvm/trunk/test/CodeGen/WinEH/seh-outlined-finally.ll

 ; RUN: opt -S -winehprepare -mtriple=x86_64-windows-msvc < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-windows-coreclr < %s | FileCheck %s
 
 ; Test case based on this code:
 ;
 ; extern "C" int _abnormal_termination();
 ; #pragma intrinsic(_abnormal_termination)
 ; extern "C" int printf(const char *, ...);
 ; extern "C" void may_crash() {
 ;   *(volatile int *)0 = 42;

 ;     printf("outer finally %d\n", _abnormal_termination());
 ;   }
 ; }
 ;
 ; Note that if the inner finally crashes, the outer finally still runs. There
 ; is nothing like a std::terminate call in this situation.
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc"
 
 @str_outer_finally = linkonce_odr unnamed_addr constant [18 x i8] c"outer finally %d\0A\00", align 1
 @str_inner_finally = linkonce_odr unnamed_addr constant [18 x i8] c"inner finally %d\0A\00", align 1
 
 ; Function Attrs: nounwind uwtable
 define void @may_crash() #0 {
 entry:
   store volatile i32 42, i32* null, align 4

llvm/trunk/test/CodeGen/WinEH/seh-prepared-basic.ll

-; RUN: llc < %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-pc-windows-msvc < %s | FileCheck %s
+; RUN: llc -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
 
 ; Test case based on this code:
 ; extern "C" unsigned long _exception_code();
 ; extern "C" int filt(unsigned long);
 ; extern "C" void g();
 ; extern "C" void do_except() {
 ;   __try {
 ;     g();
 ;   } __except(filt(_exception_code())) {
 ;   }
 ; }
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc"
 
 ; Function Attrs: uwtable
 define void @do_except() #0 personality i8* bitcast (i32 (...)* @__C_specific_handler to i8*) {
 entry:
   call void (...) @llvm.localescape()
   invoke void @g() #5
           to label %__try.cont unwind label %lpad1
 

llvm/trunk/test/CodeGen/WinEH/seh-resume-phi.ll

-; RUN: opt -S -winehprepare < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-pc-windows-msvc < %s | FileCheck %s
+; RUN: opt -S -winehprepare -mtriple=x86_64-pc-windows-coreclr < %s | FileCheck %s
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
-target triple = "x86_64-pc-windows-msvc"
 
 declare void @might_crash(i8* %ehptr)
 declare i32 @filt()
 declare void @cleanup()
 declare i32 @__C_specific_handler(...)
 declare i32 @llvm.eh.typeid.for(i8*)
 
 define void @resume_phi() personality i32 (...)* @__C_specific_handler {

llvm/trunk/test/CodeGen/WinEH/seh-simple.ll

 ; RUN: opt -S -winehprepare -mtriple=x86_64-windows-msvc < %s \
 ; RUN:    | FileCheck %s --check-prefix=CHECK --check-prefix=X64
+; RUN: opt -S -winehprepare -mtriple=x86_64-windows-coreclr < %s \
+; RUN:    | FileCheck %s --check-prefix=CHECK --check-prefix=X64
 
 ; This test should also pass in 32-bit using _except_handler3.
 ; RUN: sed -e 's/__C_specific_handler/_except_handler3/' %s \
 ; RUN:    | opt -S -winehprepare -mtriple=i686-windows-msvc \
 ; RUN:    | FileCheck %s --check-prefix=CHECK --check-prefix=X86
 
 declare void @cleanup()
 declare i32 @filt()

llvm/trunk/test/CodeGen/X86/stack-probe-size.ll

 ; This test is attempting to detect that the compiler correctly generates stack
 ; probe calls when the size of the local variables exceeds the specified stack
 ; probe size.
 ;
 ; Testing the default value of 4096 bytes makes sense, because the default
 ; stack probe size equals the page size (4096 bytes for all x86 targets), and
 ; this is unlikely to change in the future.
 ;
-; RUN: llc < %s | FileCheck %s
+; RUN: llc -mtriple=i686-windows-msvc < %s | FileCheck %s
+; RUN: llc -mtriple=i686-windows-coreclr < %s | FileCheck %s
 
 target datalayout = "e-m:w-p:32:32-i64:64-f80:32-n8:16:32-S32"
-target triple = "i686-pc-windows-msvc"
 
 define i32 @test1() "stack-probe-size"="0" {
   %buffer = alloca [4095 x i8]
 
   ret i32 0
 
 ; CHECK-LABEL: _test1:
 ; CHECK-NOT: subl $4095, %esp