Fix llvm + clang build with Intel compiler

[yvvan]

Summary

I've tested it on Windows with 64-bit icl

These are mostly workarounds for https://software.intel.com/en-us/comment/1919743 , https://software.intel.com/en-us/forums/intel-c-compiler/topic/749369 and few more enum-related issues

[nhaehnle]

I don't think we should add workarounds for broken compilers.

[zturner]

In D44426#1040938, @nhaehnle wrote:

I don't think we should add workarounds for broken compilers.

I don't follow. What should we do then? If LLVM doesn't compile on a compiler which we claim is supported, then how should we proceed?

[nhaehnle]

Is that compiler really supported? Look at this:

void operator delete(void *) = delete;

It's been there in the code since early 2015. The bitwise OR on ELF::xxx has been there even longer.

Are you telling me that we officially support a compiler, but nobody has actually used it for more than 3 years? What's going on here?

[yvvan]

@nhaehnle And that's the problem. There's no build machine for intel compiler and nobody cares.
And if somebody like me want to build it - there's no solution rather than searching for workarounds yourself.
This patch is not that complex in the end as you see so it should be possible to support one more compiler with not too many headache.

That's why I suggest this patch to at least make people know that it's possible to build. Or probably to grab someone's interest to the problem and set up builds.

[erichkeane]

Adding @mibintc to take a look, as she's a good representative of the ICC dev team.

[mibintc]

I added some inline comments. You are using the Intel 18.0 compiler on Windows - what version of Visual Studio is in the environment?

include/llvm-c/Target.h

25

I really think all the Intel-compiler bug workarounds should be version specific. For example, in the boost.org customizations we have checks like this:
#if defined(INTEL_COMPILER) && (INTEL_COMPILER >= 1500)

I believe you are using the most recent Intel compiler, 18.0, which has version 1800. Let's assume the bug will either be fixed in our 18.0 compiler or in our next compiler which would be numbered 1900, so the check could be like this:
#if defined(INTEL_COMPILER) && (INTEL_COMPILER < 1900) // employ the workaround for the Intel 18.0 compiler and older

This way the workaround will "disappear" when the bug gets fixed.

For that matter I wonder if it's still necessary to use the workaround for the Microsoft compiler?

Thanks for reporting the bug into the Intel forum. If we put a bug workaround into LLVM it would be very nice to have the bug reported to the offending compiler.

include/llvm/ADT/BitmaskEnum.h

73

what problem is being worked around here? I checked your post into the Intel compiler forum "enum members are not visible to template specialization" and I can observe the bug on our Windows compiler but not our Linux compiler.

include/llvm/Analysis/AliasAnalysis.h

254

is this a necessary workaround for the Intel compiler? It's not pretty. Suggest we add the #if around it? Long term i hope this would not be necessary.

lib/Target/AMDGPU/SIISelLowering.cpp

6131

this assesrts with Intel compiler? Or the expression needs to be rewritten with static_cast as above?

[yvvan]

In D44426#1042162, @mibintc wrote:

I added some inline comments. You are using the Intel 18.0 compiler on Windows - what version of Visual Studio is in the environment?

Yes, I'm using 18.0

include/llvm-c/Target.h

25

This one will probably not be fixed because I was answered that it's the predicted behavior and that I need not to "#define inline __inline" if I use intel compiler
I agree though about versions which need to be taken into account

include/llvm/ADT/BitmaskEnum.h

73

it was recently accepted. the issues is that E::LLVM_BITMASK_LARGEST_ENUMERATOR from line 80 here is always invalid with intel compiler and the whole set of operator overloads is ignored
at least on Windows :)

include/llvm/Analysis/AliasAnalysis.h

254

i'm not sure that adding #if around makes it easier to understand :)
of course I can add it everywhere I append enums with static_cast<int>

lib/Target/AMDGPU/SIISelLowering.cpp

6131

"needs to be rewritten with static_cast" - correct. it can be done but I was a bit lazy and statioc_assert does not affect the outcome of build :)

[mibintc]

include/llvm-c/Target.h

25

thanks

include/llvm/ADT/BitmaskEnum.h

73

Thanks. I found the bug report for this one in the icc bug tracking database. It's CMPLRS-47898. With luck it will be fixed in the next update (ballpark based on previous release cadence, 3 months)

include/llvm/Analysis/AliasAnalysis.h

254

The modification for the Intel compiler is so ugly that I'd rather it get wrapped with the #if, and eventually the workaround could get discarded. Imagine yourself 20 years from now staring at that code and wondering why it is written that way. The #if makes it stand out, and easier to find later, and easier to restore to pristine state, when you want to clean it up.

I tried a small test case with the Intel compiler but i couldn't see the problem, must be too simple-minded.
typedef enum { a,b,c,d,e } letters;
char conv( letters l) {

switch(l) {
case a: return 'a';
case a | b : return 'b';
default : return 'z';
}

}

lib/Target/AMDGPU/SIISelLowering.cpp

6131

ok, it's got the if intel so: lgtm

include/llvm-c/Target.h

 #include "llvm-c/Types.h"
 #include "llvm/Config/llvm-config.h"
 
-#if defined(_MSC_VER) && !defined(inline)
+#if defined(_MSC_VER) && !defined(inline) && !defined(__INTEL_COMPILER)
 #define inline __inline
 #endif
 

include/llvm/ADT/BitmaskEnum.h

 template <typename E, typename Enable = void>
 struct is_bitmask_enum : std::false_type {};
 
+#ifdef __INTEL_COMPILER
+template <typename E>
+struct is_bitmask_enum<E, typename std::enable_if<std::is_enum<E>::value>::type> : std::true_type {};
+#endif
+
 template <typename E>
 struct is_bitmask_enum<
     E, typename std::enable_if<sizeof(E::LLVM_BITMASK_LARGEST_ENUMERATOR) >=

 
 /// Get a bitmask with 1s in all places up to the high-order bit of E's largest
 /// value.
+#ifndef __INTEL_COMPILER
 template <typename E> typename std::underlying_type<E>::type Mask() {
   // On overflow, NextPowerOf2 returns zero with the type uint64_t, so
   // subtracting 1 gives us the mask with all bits set, like we want.

              E::LLVM_BITMASK_LARGEST_ENUMERATOR)) -
          1;
 }
+#else
+template <typename E> typename std::underlying_type<E>::type Mask() {
+  return std::numeric_limits<std::underlying_type<E>::type>::max();
+}
+#endif
 
 /// Check that Val is in range for E, and return Val cast to E's underlying
 /// type.

include/llvm/Analysis/AliasAnalysis.h

   /// This property corresponds to the LLVM IR
   /// inaccessiblemem_or_argmemonly attribute.
   FMRB_OnlyAccessesInaccessibleOrArgMem = FMRL_InaccessibleMem |
-                                          FMRL_ArgumentPointees |
+                                          static_cast<int>(FMRL_ArgumentPointees) |
                                           static_cast<int>(ModRefInfo::ModRef),
 
   /// This function does not perform any non-local stores or volatile loads,

lib/CodeGen/AsmPrinter/AsmPrinterDwarf.cpp

     return "sdata4";
   case dwarf::DW_EH_PE_sdata8:
     return "sdata8";
-  case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4:
+  case dwarf::DW_EH_PE_pcrel | static_cast<int>(dwarf::DW_EH_PE_udata4):
     return "pcrel udata4";
-  case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4:
+  case dwarf::DW_EH_PE_pcrel | static_cast<int>(dwarf::DW_EH_PE_sdata4):
     return "pcrel sdata4";
-  case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8:
+  case dwarf::DW_EH_PE_pcrel | static_cast<int>(dwarf::DW_EH_PE_udata8):
     return "pcrel udata8";
-  case dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8:
+  case dwarf::DW_EH_PE_pcrel | static_cast<int>(dwarf::DW_EH_PE_sdata8):
     return "pcrel sdata8";
-  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata4
+  case dwarf::DW_EH_PE_indirect | static_cast<int>(dwarf::DW_EH_PE_pcrel) | static_cast<int>(dwarf::DW_EH_PE_udata4)
       :
     return "indirect pcrel udata4";
-  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4
+  case dwarf::DW_EH_PE_indirect | static_cast<int>(dwarf::DW_EH_PE_pcrel) | static_cast<int>(dwarf::DW_EH_PE_sdata4)
       :
     return "indirect pcrel sdata4";
-  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_udata8
+  case dwarf::DW_EH_PE_indirect | static_cast<int>(dwarf::DW_EH_PE_pcrel) | static_cast<int>(dwarf::DW_EH_PE_udata8)
       :
     return "indirect pcrel udata8";
-  case dwarf::DW_EH_PE_indirect | dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata8
+  case dwarf::DW_EH_PE_indirect | static_cast<int>(dwarf::DW_EH_PE_pcrel) | static_cast<int>(dwarf::DW_EH_PE_sdata8)
       :
     return "indirect pcrel sdata8";
   }

lib/Target/AMDGPU/SIISelLowering.cpp

                               SIInstrFlags::P_SUBNORMAL |
                               SIInstrFlags::P_NORMAL;
 
+#ifndef __INTEL_COMPILER
         static_assert(((~(SIInstrFlags::S_NAN |
                           SIInstrFlags::Q_NAN |
                           SIInstrFlags::N_INFINITY |
                           SIInstrFlags::P_INFINITY)) & 0x3ff) == Mask,
                       "mask not equal");
+#endif
 
         SDLoc DL(N);
         return DAG.getNode(AMDGPUISD::FP_CLASS, DL, MVT::i1,

tools/clang/include/clang/Analysis/Analyses/ThreadSafetyTIL.h

 
   /// SExpr objects cannot be deleted.
   // This declaration is public to workaround a gcc bug that breaks building
-  // with REQUIRES_EH=1.
+  // with REQUIRES_EH=1. Do not mark it 'delete' to avoid error with intel compiler.
+#ifdef __INTEL_COMPILER
+  void operator delete(void *);
+#else
   void operator delete(void *) = delete;
+#endif
 
   /// Returns the instruction ID for this expression.
   /// All basic block instructions have a unique ID (i.e. virtual register).

tools/llvm-nm/llvm-nm.cpp

     case ELF::SHT_PROGBITS:
     case ELF::SHT_DYNAMIC:
       switch (SecI->getFlags()) {
-      case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR):
+      case (ELF::SHF_ALLOC | static_cast<int>(ELF::SHF_EXECINSTR)):
         return 't';
-      case (ELF::SHF_TLS | ELF::SHF_ALLOC | ELF::SHF_WRITE):
-      case (ELF::SHF_ALLOC | ELF::SHF_WRITE):
+      case (ELF::SHF_TLS | static_cast<int>(ELF::SHF_ALLOC) | static_cast<int>(ELF::SHF_WRITE)):
+      case (ELF::SHF_ALLOC | static_cast<int>(ELF::SHF_WRITE)):
         return 'd';
       case ELF::SHF_ALLOC:
-      case (ELF::SHF_ALLOC | ELF::SHF_MERGE):
-      case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS):
+      case (ELF::SHF_ALLOC | static_cast<int>(ELF::SHF_MERGE)):
+      case (ELF::SHF_ALLOC | static_cast<int>(ELF::SHF_MERGE) | static_cast<int>(ELF::SHF_STRINGS)):
         return 'r';
       }
       break;