Adding templates for LLVM patches - Incomplete

llvm/tools/hpvm/llvm_patches/.#patch_src.sh

+hsharif3@tyler.cs.illinois.edu.16670:1574121859
\ No newline at end of file

llvm/tools/hpvm/llvm_patches/apply_patch.sh

+#!/bin/sh
+
+### File Copies
+cp include/IR/IntrinsicsVISC.td  ../../../include/llvm/IR/IntrinsicsVISC.td
+
+## File Patches
+patch  /home/hsharif3/Github/llvm-project/llvm/include/llvm/IR/Attributes.td  <  ./include/IR/Attributes.td.patch 

llvm/tools/hpvm/llvm_patches/construct_patch.sh

+#!/bin/sh
+
+#### Patching Headers
+diff -u  ../../../include/llvm/Bitcode/LLVMBitCodes.h  include/Bitcode/LLVMBitCodes.h > include/Bitcode/LLVMBitCodes.h.patch 
+
+diff -u  ../../../include/llvm/IR/Attributes.td   include/IR/Attributes.td   > include/IR/Attributes.td.patch
+
+diff -u  ../../../include/llvm/IR/Intrinsics.td   include/IR/Intrinsics.td > include/IR/Intrinsics.td.patch
+
+cp include/IR/IntrinsicsVISC.td  ../../../include/llvm/IR/IntrinsicsVISC.td 
+
+diff -u  ../../../include/llvm/Support/Debug.h   include/Support/Debug.h > include/Support/Debug.h.patch
+
+
+#### Patching Sources
+
+diff -u  ../../../lib/AsmParser/LLLexer.cpp   lib/AsmParser/LLLexer.cpp > lib/AsmParser/LLLexer.cpp.patch 
+
+diff -u  ../../../lib/AsmParser/LLLexer.h   lib/AsmParser/LLLexer.h > lib/AsmParser/LLLexer.h.patch
+
+diff -u  ../../../lib/AsmParser/LLParser.cpp   lib/AsmParser/LLParser.cpp > lib/AsmParser/LLParser.cpp.patch
+
+diff -u  ../../../lib/AsmParser/LLParser.h   lib/AsmParser/LLParser.h > lib/AsmParser/LLParser.h.patch
+
+diff -u  ../../../lib/AsmParser/LLToken.h   lib/AsmParser/LLToken.h > lib/AsmParser/LLToken.h.patch
+
+diff -u  ../../../lib/IR/Attributes.cpp   lib/IR/Attributes.cpp > lib/IR/Attributes.cpp.patch
+
+diff -u  ../../../lib/Bitcode/Reader/BitcodeReader.cpp   lib/Bitcode/Reader/BitcodeReader.cpp > lib/Bitcode/Reader/BitcodeReader.cpp.patch
+
+diff -u  ../../../lib/Bitcode/Writer/BitcodeWriter.cpp   lib/Bitcode/Writer/BitcodeWriter.cpp > lib/Bitcode/Writer/BitcodeWriter.cpp.patch

llvm/tools/hpvm/llvm_patches/include/Bitcode/LLVMBitCodes.h.patch

+--- ../../../include/llvm/Bitcode/LLVMBitCodes.h	2019-12-29 18:23:33.020718342 -0600
++++ include/Bitcode/LLVMBitCodes.h	2019-12-29 18:49:23.479634563 -0600
+@@ -522,7 +522,12 @@
+   ATTR_KIND_INACCESSIBLEMEM_ONLY = 49,
+   ATTR_KIND_INACCESSIBLEMEM_OR_ARGMEMONLY = 50,
+   ATTR_KIND_ALLOC_SIZE = 51,
+-  ATTR_KIND_WRITEONLY = 52
++  ATTR_KIND_WRITEONLY = 52,
++
++  // VISC Attributes
++  ATTR_KIND_IN = 53,
++  ATTR_KIND_OUT = 54,
++  ATTR_KIND_INOUT = 55
+ };
+ 
+ enum ComdatSelectionKindCodes {

llvm/tools/hpvm/llvm_patches/include/IR/Attributes.td

+/// Attribute base class.
+class Attr<string S> {
+  // String representation of this attribute in the IR.
+  string AttrString = S;
+}
+
+/// Enum attribute.
+class EnumAttr<string S> : Attr<S>;
+
+/// StringBool attribute.
+class StrBoolAttr<string S> : Attr<S>;
+
+/// Target-independent enum attributes.
+
+/// Alignment of parameter (5 bits) stored as log2 of alignment with +1 bias.
+/// 0 means unaligned (different from align(1)).
+def Alignment : EnumAttr<"align">;
+
+/// The result of the function is guaranteed to point to a number of bytes that
+/// we can determine if we know the value of the function's arguments.
+def AllocSize : EnumAttr<"allocsize">;
+
+/// inline=always.
+def AlwaysInline : EnumAttr<"alwaysinline">;
+
+/// Function can access memory only using pointers based on its arguments.
+def ArgMemOnly : EnumAttr<"argmemonly">;
+
+/// Callee is recognized as a builtin, despite nobuiltin attribute on its
+/// declaration.
+def Builtin : EnumAttr<"builtin">;
+
+/// Pass structure by value.
+def ByVal : EnumAttr<"byval">;
+
+/// Marks function as being in a cold path.
+def Cold : EnumAttr<"cold">;
+
+/// Can only be moved to control-equivalent blocks.
+def Convergent : EnumAttr<"convergent">;
+
+/// Pointer is known to be dereferenceable.
+def Dereferenceable : EnumAttr<"dereferenceable">;
+
+/// Pointer is either null or dereferenceable.
+def DereferenceableOrNull : EnumAttr<"dereferenceable_or_null">;
+
+/// Function may only access memory that is inaccessible from IR.
+def InaccessibleMemOnly : EnumAttr<"inaccessiblememonly">;
+
+/// Function may only access memory that is either inaccessible from the IR,
+/// or pointed to by its pointer arguments.
+def InaccessibleMemOrArgMemOnly : EnumAttr<"inaccessiblemem_or_argmemonly">;
+
+/// Pass structure in an alloca.
+def InAlloca : EnumAttr<"inalloca">;
+
+/// Source said inlining was desirable.
+def InlineHint : EnumAttr<"inlinehint">;
+
+/// Force argument to be passed in register.
+def InReg : EnumAttr<"inreg">;
+
+/// Build jump-instruction tables and replace refs.
+def JumpTable : EnumAttr<"jumptable">;
+
+/// Function must be optimized for size first.
+def MinSize : EnumAttr<"minsize">;
+
+/// Naked function.
+def Naked : EnumAttr<"naked">;
+
+/// Nested function static chain.
+def Nest : EnumAttr<"nest">;
+
+/// Considered to not alias after call.
+def NoAlias : EnumAttr<"noalias">;
+
+/// Callee isn't recognized as a builtin.
+def NoBuiltin : EnumAttr<"nobuiltin">;
+
+/// Function creates no aliases of pointer.
+def NoCapture : EnumAttr<"nocapture">;
+
+/// Call cannot be duplicated.
+def NoDuplicate : EnumAttr<"noduplicate">;
+
+/// Disable implicit floating point insts.
+def NoImplicitFloat : EnumAttr<"noimplicitfloat">;
+
+/// inline=never.
+def NoInline : EnumAttr<"noinline">;
+
+/// Function is called early and/or often, so lazy binding isn't worthwhile.
+def NonLazyBind : EnumAttr<"nonlazybind">;
+
+/// Pointer is known to be not null.
+def NonNull : EnumAttr<"nonnull">;
+
+/// The function does not recurse.
+def NoRecurse : EnumAttr<"norecurse">;
+
+/// Disable redzone.
+def NoRedZone : EnumAttr<"noredzone">;
+
+/// Mark the function as not returning.
+def NoReturn : EnumAttr<"noreturn">;
+
+/// Function doesn't unwind stack.
+def NoUnwind : EnumAttr<"nounwind">;
+
+/// opt_size.
+def OptimizeForSize : EnumAttr<"optsize">;
+
+/// Function must not be optimized.
+def OptimizeNone : EnumAttr<"optnone">;
+
+/// Function does not access memory.
+def ReadNone : EnumAttr<"readnone">;
+
+/// Function only reads from memory.
+def ReadOnly : EnumAttr<"readonly">;
+
+/// Return value is always equal to this argument.
+def Returned : EnumAttr<"returned">;
+
+/// Function can return twice.
+def ReturnsTwice : EnumAttr<"returns_twice">;
+
+/// Safe Stack protection.
+def SafeStack : EnumAttr<"safestack">;
+
+/// Sign extended before/after call.
+def SExt : EnumAttr<"signext">;
+
+/// Alignment of stack for function (3 bits)  stored as log2 of alignment with
+/// +1 bias 0 means unaligned (different from alignstack=(1)).
+def StackAlignment : EnumAttr<"alignstack">;
+
+/// Stack protection.
+def StackProtect : EnumAttr<"ssp">;
+
+/// Stack protection required.
+def StackProtectReq : EnumAttr<"sspreq">;
+
+/// Strong Stack protection.
+def StackProtectStrong : EnumAttr<"sspstrong">;
+
+/// Hidden pointer to structure to return.
+def StructRet : EnumAttr<"sret">;
+
+/// AddressSanitizer is on.
+def SanitizeAddress : EnumAttr<"sanitize_address">;
+
+/// ThreadSanitizer is on.
+def SanitizeThread : EnumAttr<"sanitize_thread">;
+
+/// MemorySanitizer is on.
+def SanitizeMemory : EnumAttr<"sanitize_memory">;
+
+/// Argument is swift error.
+def SwiftError : EnumAttr<"swifterror">;
+
+/// Argument is swift self/context.
+def SwiftSelf : EnumAttr<"swiftself">;
+
+/// Function must be in a unwind table.
+def UWTable : EnumAttr<"uwtable">;
+
+/// Function only writes to memory.
+def WriteOnly : EnumAttr<"writeonly">;
+
+/// Zero extended before/after call.
+def ZExt : EnumAttr<"zeroext">;
+
+/// VISC Attributes
+/// Pointer to read only memory
+def In : EnumAttr<"in">;
+
+/// Pointer to write only memory
+def Out : EnumAttr<"out">;
+
+/// Pointer to read/write memory
+def InOut : EnumAttr<"inout">;
+
+/// Target-independent string attributes.
+def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">;
+def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">;
+def NoNansFPMath : StrBoolAttr<"no-nans-fp-math">;
+def UnsafeFPMath : StrBoolAttr<"unsafe-fp-math">;
+def NoJumpTables : StrBoolAttr<"no-jump-tables">;
+
+class CompatRule<string F> {
+  // The name of the function called to check the attribute of the caller and
+  // callee and decide whether inlining should be allowed. The function's
+  // signature must match "bool(const Function&, const Function &)", where the
+  // first parameter is the reference to the caller and the second parameter is
+  // the reference to the callee. It must return false if the attributes of the
+  // caller and callee are incompatible, and true otherwise.
+  string CompatFunc = F;
+}
+
+def : CompatRule<"isEqual<SanitizeAddressAttr>">;
+def : CompatRule<"isEqual<SanitizeThreadAttr>">;
+def : CompatRule<"isEqual<SanitizeMemoryAttr>">;
+def : CompatRule<"isEqual<SafeStackAttr>">;
+
+class MergeRule<string F> {
+  // The name of the function called to merge the attributes of the caller and
+  // callee. The function's signature must match
+  // "void(Function&, const Function &)", where the first parameter is the
+  // reference to the caller and the second parameter is the reference to the
+  // callee.
+  string MergeFunc = F;
+}
+
+def : MergeRule<"setAND<LessPreciseFPMADAttr>">;
+def : MergeRule<"setAND<NoInfsFPMathAttr>">;
+def : MergeRule<"setAND<NoNansFPMathAttr>">;
+def : MergeRule<"setAND<UnsafeFPMathAttr>">;
+def : MergeRule<"setOR<NoImplicitFloatAttr>">;
+def : MergeRule<"setOR<NoJumpTablesAttr>">;
+def : MergeRule<"adjustCallerSSPLevel">;

llvm/tools/hpvm/llvm_patches/include/IR/Attributes.td.patch

+--- ../../../include/llvm/IR/Attributes.td	2019-12-29 18:23:33.793781744 -0600
++++ include/IR/Attributes.td	2019-12-30 00:56:38.540423304 -0600
+@@ -173,6 +173,16 @@
+ /// Zero extended before/after call.
+ def ZExt : EnumAttr<"zeroext">;
+ 
++/// VISC Attributes
++/// Pointer to read only memory
++def In : EnumAttr<"in">;
++
++/// Pointer to write only memory
++def Out : EnumAttr<"out">;
++
++/// Pointer to read/write memory
++def InOut : EnumAttr<"inout">;
++
+ /// Target-independent string attributes.
+ def LessPreciseFPMAD : StrBoolAttr<"less-precise-fpmad">;
+ def NoInfsFPMath : StrBoolAttr<"no-infs-fp-math">;

llvm/tools/hpvm/llvm_patches/include/IR/Intrinsics.td.patch

+--- ../../../include/llvm/IR/Intrinsics.td	2019-12-29 18:23:33.896790192 -0600
++++ include/IR/Intrinsics.td	2019-12-29 18:50:41.881046510 -0600
+@@ -761,3 +761,4 @@
+ include "llvm/IR/IntrinsicsBPF.td"
+ include "llvm/IR/IntrinsicsSystemZ.td"
+ include "llvm/IR/IntrinsicsWebAssembly.td"
++include "llvm/IR/IntrinsicsVISC.td"

llvm/tools/hpvm/llvm_patches/include/IR/IntrinsicsVISC.td

+//===- IntrinsicsVISC.td - Defines VISC intrinsics ---------*- tablegen -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines all of the VISC-specific intrinsics.
+//
+//===----------------------------------------------------------------------===//
+
+let TargetPrefix = "visc" in {
+  /* All intrinsics start with "llvm.visc."
+   * As we do not want the compiler to mess with these intrinsics, we assume
+   * worst memory behavior for all these intrinsics.
+   */
+
+  /* Initialization intrinsic -
+   * i8* llvm.visc.setup(function*);
+   */
+  def int_visc_init : Intrinsic<[], [], []>;
+
+  /* Launch intrinsic - with streaming argument
+   * i8* llvm.visc.launch(i8*, ArgList*, i1);
+   */
+  def int_visc_launch : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                  llvm_ptr_ty, llvm_i1_ty], []>;
+
+  /* Push intrinsic - push data on streaming pipeline
+   * void llvm.visc.push(i8*, ArgList*);
+   */
+  def int_visc_push : Intrinsic<[], [llvm_ptr_ty, llvm_ptr_ty], []>;
+
+  /* Pop intrinsic - pop data from streaming pipeline
+   * i8* llvm.visc.pop(i8*);
+   */
+  def int_visc_pop : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Cleanup intrinsic -
+   * void llvm.visc.cleanup(i8*);
+   */
+  def int_visc_cleanup : Intrinsic<[], [], []>;
+
+  /* Wait intrinsic -
+   * void llvm.visc.wait(graphID*);
+   */
+  def int_visc_wait : Intrinsic<[], [llvm_ptr_ty], []>;
+
+  /* Track memory intrinsic -
+   * void llvm.visc.trackMemory(i8*, i64);
+   */
+  def int_visc_trackMemory : Intrinsic<[], [llvm_ptr_ty, llvm_i64_ty], []>;
+
+  /* Track memory intrinsic -
+   * void llvm.visc.untrackMemory(i8*);
+   */
+  def int_visc_untrackMemory : Intrinsic<[], [llvm_ptr_ty], []>;
+
+  /* Request memory intrinsic -
+   * void llvm.visc.requestMemory(i8*, i64);
+   */
+  def int_visc_requestMemory : Intrinsic<[], [llvm_ptr_ty, llvm_i64_ty], []>;
+
+  /* Create Node intrinsic -
+   * i8* llvm.visc.createNode(function*);
+   */
+  def int_visc_createNode : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Create Node 1D array intrinsic -
+   * i8* llvm.visc.createNode1D(function*, i64);
+   */
+  def int_visc_createNode1D : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                        llvm_i64_ty], []>;
+
+  /* Create Node 2D array intrinsic -
+   * i8* llvm.visc.createNode2D(function*, i64, i64);
+   */
+  def int_visc_createNode2D : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                        llvm_i64_ty, llvm_i64_ty], []>;
+
+  /* Create Node 3D array intrinsic -
+   * i8* llvm.visc.createNode2D(function*, i64, i64, i64);
+   */
+  def int_visc_createNode3D : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                        llvm_i64_ty, llvm_i64_ty, llvm_i64_ty],
+                                        []>;
+
+  /* Create dataflow edge intrinsic -
+   * i8* llvm.visc.createEdge(i8*, i8*, i1, i32, i32, i1);
+   */
+  def int_visc_createEdge : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty, llvm_ptr_ty,
+                                      llvm_i1_ty, llvm_i32_ty, llvm_i32_ty,
+                                      llvm_i1_ty],
+                                      []>;
+
+  /* Create bind input intrinsic -
+   * void llvm.visc.bind.input(i8*, i32, i32);
+   */
+  def int_visc_bind_input : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty,
+                                      llvm_i32_ty, llvm_i1_ty], []>;
+
+  /* Create bind output intrinsic -
+   * void llvm.visc.bind.output(i8*, i32, i32);
+   */
+  def int_visc_bind_output : Intrinsic<[], [llvm_ptr_ty, llvm_i32_ty,
+                                       llvm_i32_ty, llvm_i1_ty], []>;
+
+  /* Find associated dataflow node intrinsic -
+   * i8* llvm.visc.getNode();
+   */
+  def int_visc_getNode : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
+
+  /* Find parent dataflow node intrinsic -
+   * i8* llvm.visc.getParentNode(i8*);
+   */
+  def int_visc_getParentNode : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], [IntrNoMem]>;
+
+  /* Find the number of dimensions of a dataflow node intrinsic -
+   * i32 llvm.visc.getNumDims(i8*);
+   */
+  def int_visc_getNumDims : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty], [IntrNoMem]>;
+
+  /* Find the unique indentifier of a dataflow node (with respect to his parent
+   * node) in the specified dimension intrinsic -
+   */
+
+  /* i64 llvm.visc.getNodeInstanceID.[xyz](i8*);
+   */
+  def int_visc_getNodeInstanceID_x : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                               [IntrNoMem]>;
+
+  def int_visc_getNodeInstanceID_y : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                               [IntrNoMem]>;
+
+  def int_visc_getNodeInstanceID_z : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                               [IntrNoMem]>;
+
+  /* Find the number of instances of a dataflow node in the specified dimension
+   * intrinsic -
+   */
+
+  /* i64 llvm.visc.getNumNodeInstances.[xyz](i8*);
+   */
+  def int_visc_getNumNodeInstances_x : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                                 [IntrNoMem]>;
+
+  def int_visc_getNumNodeInstances_y : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                                 [IntrNoMem]>;
+
+  def int_visc_getNumNodeInstances_z : Intrinsic<[llvm_i64_ty], [llvm_ptr_ty],
+                                                 [IntrNoMem]>;
+
+  /* Local Barrier
+   * void llvm.visc.barrier();
+   */
+  def int_visc_barrier : Intrinsic<[], [], []>;
+
+  /* Memory allocation inside the graph
+   * i8* llvm.visc.malloc();
+   */
+  def int_visc_malloc : Intrinsic<[llvm_ptr_ty], [llvm_i64_ty], []>;
+
+  /* Find the vector length supported by target architecture
+   * intrinsic -
+   * i32 llvm.visc.getVectorLength();
+   */
+  def int_visc_getVectorLength : Intrinsic<[llvm_i32_ty], [], []>;
+
+  /* ============ Atomic intrinsics ============= */
+  // Atomic arithmetic operations
+  
+  /* i32 llvm.visc.atomic.cmpxchg(i32*, i32)*/
+  def int_visc_atomic_cmpxchg: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty,
+                                          llvm_i32_ty], []>;
+
+  /* i32 llvm.visc.atomic.add(i32*, i32)*/
+  def int_visc_atomic_add: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.sub(i32*, i32)*/
+  def int_visc_atomic_sub: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.xchg(i32*, i32)*/
+  def int_visc_atomic_xchg: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.inc(i32*, i32)*/
+  def int_visc_atomic_inc: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.dec(i32*, i32)*/
+  def int_visc_atomic_dec: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.min(i32*, i32)*/
+  def int_visc_atomic_min: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.umin(i32*, i32)*/
+  def int_visc_atomic_umin: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.maxi32*, i32)*/
+  def int_visc_atomic_max: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.umaxi32*, i32)*/
+  def int_visc_atomic_umax: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  // Atomic bitwise operations
+
+  /* i32 llvm.visc.atomic.and(i32*, i32)*/
+  def int_visc_atomic_and: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.or(i32*, i32)*/
+  def int_visc_atomic_or: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+
+  /* i32 llvm.visc.atomic.xor(i32*, i32)*/
+  def int_visc_atomic_xor: Intrinsic<[llvm_i32_ty], [llvm_ptr_ty, llvm_i32_ty],
+                                    []>;
+  /***************************************************************************/
+  /*                            ApproxHPVM intrinsics                        */
+  /***************************************************************************/
+
+  /* Tensor add intrinsic
+   * i8* llvm.visc.tensor.add(i8*, i8*);
+   */
+  def int_visc_tensor_add : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                   llvm_ptr_ty], []>;
+
+  /* Tensor mul intrinsic
+   * i8* llvm.visc.tensor.mul(i8*, i8*);
+   */
+  def int_visc_tensor_mul : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                   llvm_ptr_ty], []>;
+
+  /* Tensor relu intrinsic
+   * i8* llvm.visc.tensor.relu(i8*);
+   */
+  def int_visc_tensor_relu : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Tensor clipped relu intrinsic
+   * i8* llvm.visc.tensor.clipped.relu(i8*);
+   */
+  def int_visc_tensor_clipped_relu : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Tensor tanh intrinsic
+   * i8* llvm.visc.tensor.tanh(i8*);
+   */
+  def int_visc_tensor_tanh : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Tensor sigmoid intrinsic
+   * i8* llvm.visc.tensor.sigmoid(i8*);
+   */
+  def int_visc_tensor_sigmoid : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Tensor softmax intrinsic
+   * i8* llvm.visc.tensor.softmax(i8*);
+   */
+  def int_visc_tensor_softmax : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty], []>;
+
+  /* Tensor convolution intrinsic
+   * i8* llvm.visc.tensor.convolution(i8*, i8*, i32, i32, i32, i32);
+   */
+  def int_visc_tensor_convolution : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                                              llvm_ptr_ty,
+                                                              llvm_i32_ty,
+                                                              llvm_i32_ty,
+                                                              llvm_i32_ty,
+                                                              llvm_i32_ty], []>;
+
+  /* Tensor group convolution intrinsic
+   * i8* llvm.visc.tensor.group.convolution(i8*, i8*, i32, i32, i32, i32, i32, i32);
+   */
+  def int_visc_tensor_group_convolution : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                                              llvm_ptr_ty,
+                                                              llvm_i32_ty,
+                                                              llvm_i32_ty,
+                                                              llvm_i32_ty,
+                                                              llvm_i32_ty,
+							      llvm_i32_ty,
+							      llvm_i32_ty], []>;
+
+  /* Tensor BatchNorm intrinsic
+   * i8* llvm.visc.tensor.batchnorm(i8*, i8*, i8*, i8*, i8*, double);
+   */
+  def int_visc_tensor_batchnorm : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                                            llvm_ptr_ty,
+							    llvm_ptr_ty,
+							    llvm_ptr_ty,
+							    llvm_ptr_ty,
+                                                            llvm_double_ty], []>;
+
+
+  /* Tensor pool intrinsics: max, min, average
+   * i8* llvm.visc.tensor.pool.max(i8*, i32, i32, i32, i32, i32, i32);
+   * i8* llvm.visc.tensor.pool.min(i8*, i32, i32, i32, i32, i32, i32);
+   * i8* llvm.visc.tensor.pool.average(i8*, i32, i32, i32, i32, i32, i32);
+   */
+  def int_visc_tensor_pool_max : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty], []>;
+  def int_visc_tensor_pool_min : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty,
+                                                           llvm_i32_ty], []>;
+  def int_visc_tensor_pool_mean : Intrinsic<[llvm_ptr_ty], [llvm_ptr_ty,
+                                                            llvm_i32_ty,
+                                                            llvm_i32_ty,
+                                                            llvm_i32_ty,
+                                                            llvm_i32_ty,
+                                                            llvm_i32_ty,
+                                                            llvm_i32_ty], []>;
+
+}

llvm/tools/hpvm/llvm_patches/include/Support/Debug.h

+//===- llvm/Support/Debug.h - Easy way to add debug output ------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements a handy way of adding debugging information to your
+// code, without it being enabled all of the time, and without having to add
+// command line options to enable it.
+//
+// In particular, just wrap your code with the DEBUG() macro, and it will be
+// enabled automatically if you specify '-debug' on the command-line.
+// DEBUG() requires the DEBUG_TYPE macro to be defined. Set it to "foo" specify
+// that your debug code belongs to class "foo". Be careful that you only do
+// this after including Debug.h and not around any #include of headers. Headers
+// should define and undef the macro acround the code that needs to use the
+// DEBUG() macro. Then, on the command line, you can specify '-debug-only=foo'
+// to enable JUST the debug information for the foo class.
+//
+// When compiling without assertions, the -debug-* options and all code in
+// DEBUG() statements disappears, so it does not affect the runtime of the code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_DEBUG_H
+#define LLVM_SUPPORT_DEBUG_H
+
+namespace llvm {
+
+class raw_ostream;
+
+#ifndef NDEBUG
+/// DebugFlag - This boolean is set to true if the '-debug' command line option
+/// is specified.  This should probably not be referenced directly, instead, use
+/// the DEBUG macro below.
+///
+extern bool DebugFlag;
+
+/// isCurrentDebugType - Return true if the specified string is the debug type
+/// specified on the command line, or if none was specified on the command line
+/// with the -debug-only=X option.
+///
+bool isCurrentDebugType(const char *Type);
+
+/// setCurrentDebugType - Set the current debug type, as if the -debug-only=X
+/// option were specified.  Note that DebugFlag also needs to be set to true for
+/// debug output to be produced.
+///
+void setCurrentDebugType(const char *Type);
+
+/// setCurrentDebugTypes - Set the current debug type, as if the
+/// -debug-only=X,Y,Z option were specified. Note that DebugFlag
+/// also needs to be set to true for debug output to be produced.
+///
+void setCurrentDebugTypes(const char **Types, unsigned Count);
+
+/// DEBUG_WITH_TYPE macro - This macro should be used by passes to emit debug
+/// information.  In the '-debug' option is specified on the commandline, and if
+/// this is a debug build, then the code specified as the option to the macro
+/// will be executed.  Otherwise it will not be.  Example:
+///
+/// DEBUG_WITH_TYPE("bitset", dbgs() << "Bitset contains: " << Bitset << "\n");
+///
+/// This will emit the debug information if -debug is present, and -debug-only
+/// is not specified, or is specified as "bitset".
+#define DEBUG_WITH_TYPE(TYPE, X)                                        \
+  do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType(TYPE)) { X; } \
+  } while (false)
+
+#else
+#define isCurrentDebugType(X) (false)
+#define setCurrentDebugType(X)
+#define setCurrentDebugTypes(X, N)
+#define DEBUG_WITH_TYPE(TYPE, X) do { } while (false)
+#endif
+
+/// EnableDebugBuffering - This defaults to false.  If true, the debug
+/// stream will install signal handlers to dump any buffered debug
+/// output.  It allows clients to selectively allow the debug stream
+/// to install signal handlers if they are certain there will be no
+/// conflict.
+///
+extern bool EnableDebugBuffering;
+
+/// dbgs() - This returns a reference to a raw_ostream for debugging
+/// messages.  If debugging is disabled it returns errs().  Use it
+/// like: dbgs() << "foo" << "bar";
+raw_ostream &dbgs();
+
+// DEBUG macro - This macro should be used by passes to emit debug information.
+// In the '-debug' option is specified on the commandline, and if this is a
+// debug build, then the code specified as the option to the macro will be
+// executed.  Otherwise it will not be.  Example:
+//
+// DEBUG(dbgs() << "Bitset contains: " << Bitset << "\n");
+//
+#define DEBUG(X) DEBUG_WITH_TYPE(DEBUG_TYPE, X)
+
+} // end namespace llvm
+
+#endif // LLVM_SUPPORT_DEBUG_H

llvm/tools/hpvm/llvm_patches/lib/AsmParser/LLLexer.cpp.patch

+--- ../../../lib/AsmParser/LLLexer.cpp	2019-12-29 18:23:35.457918227 -0600
++++ lib/AsmParser/LLLexer.cpp	2019-12-29 18:44:36.376156576 -0600
+@@ -660,6 +660,10 @@
+   KEYWORD(uwtable);
+   KEYWORD(writeonly);
+   KEYWORD(zeroext);
++  // VISC parameter attributes
++  KEYWORD(in);
++  KEYWORD(out);
++  KEYWORD(inout);
+ 
+   KEYWORD(type);
+   KEYWORD(opaque);

llvm/tools/hpvm/llvm_patches/lib/AsmParser/LLLexer.h

+//===- LLLexer.h - Lexer for LLVM Assembly Files ----------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class represents the Lexer for .ll files.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_ASMPARSER_LLLEXER_H
+#define LLVM_LIB_ASMPARSER_LLLEXER_H
+
+#include "LLToken.h"
+#include "llvm/ADT/APFloat.h"
+#include "llvm/ADT/APSInt.h"
+#include "llvm/Support/SourceMgr.h"
+#include <string>
+
+namespace llvm {
+  class MemoryBuffer;
+  class Type;
+  class SMDiagnostic;
+  class LLVMContext;
+
+  class LLLexer {
+    const char *CurPtr;
+    StringRef CurBuf;
+    SMDiagnostic &ErrorInfo;
+    SourceMgr &SM;
+    LLVMContext &Context;
+
+    // Information about the current token.
+    const char *TokStart;
+    lltok::Kind CurKind;
+    std::string StrVal;
+    unsigned UIntVal;
+    Type *TyVal;
+    APFloat APFloatVal;
+    APSInt  APSIntVal;
+
+  public:
+    explicit LLLexer(StringRef StartBuf, SourceMgr &SM, SMDiagnostic &,
+                     LLVMContext &C);
+
+    lltok::Kind Lex() {
+      return CurKind = LexToken();
+    }
+
+    typedef SMLoc LocTy;
+    LocTy getLoc() const { return SMLoc::getFromPointer(TokStart); }
+    lltok::Kind getKind() const { return CurKind; }
+    const std::string &getStrVal() const { return StrVal; }
+    Type *getTyVal() const { return TyVal; }
+    unsigned getUIntVal() const { return UIntVal; }
+    const APSInt &getAPSIntVal() const { return APSIntVal; }
+    const APFloat &getAPFloatVal() const { return APFloatVal; }
+
+
+    bool Error(LocTy L, const Twine &Msg) const;
+    bool Error(const Twine &Msg) const { return Error(getLoc(), Msg); }
+
+    void Warning(LocTy WarningLoc, const Twine &Msg) const;
+    void Warning(const Twine &Msg) const { return Warning(getLoc(), Msg); }
+
+  private:
+    lltok::Kind LexToken();
+
+    int getNextChar();
+    void SkipLineComment();
+    lltok::Kind ReadString(lltok::Kind kind);
+    bool ReadVarName();
+
+    lltok::Kind LexIdentifier();
+    lltok::Kind LexDigitOrNegative();
+    lltok::Kind LexPositive();
+    lltok::Kind LexAt();
+    lltok::Kind LexDollar();
+    lltok::Kind LexExclaim();
+    lltok::Kind LexPercent();
+    lltok::Kind LexVar(lltok::Kind Var, lltok::Kind VarID);
+    lltok::Kind LexQuote();
+    lltok::Kind Lex0x();
+    lltok::Kind LexHash();
+
+    uint64_t atoull(const char *Buffer, const char *End);
+    uint64_t HexIntToVal(const char *Buffer, const char *End);
+    void HexToIntPair(const char *Buffer, const char *End, uint64_t Pair[2]);
+    void FP80HexToIntPair(const char *Buff, const char *End, uint64_t Pair[2]);
+  };
+} // end namespace llvm
+
+#endif

llvm/tools/hpvm/llvm_patches/lib/AsmParser/LLParser.cpp.patch

+--- ../../../lib/AsmParser/LLParser.cpp	2019-12-29 18:23:35.463918719 -0600
++++ lib/AsmParser/LLParser.cpp	2019-12-29 18:44:13.295269292 -0600
+@@ -1138,6 +1138,11 @@
+     case lltok::kw_sret:
+     case lltok::kw_swifterror:
+     case lltok::kw_swiftself:
++    // VISC Parameter only attributes
++    case lltok::kw_in:
++    case lltok::kw_out:
++    case lltok::kw_inout:
++
+       HaveError |=
+         Error(Lex.getLoc(),
+               "invalid use of parameter-only attribute on a function");
+@@ -1413,6 +1418,10 @@
+     case lltok::kw_swiftself:       B.addAttribute(Attribute::SwiftSelf); break;
+     case lltok::kw_writeonly:       B.addAttribute(Attribute::WriteOnly); break;
+     case lltok::kw_zeroext:         B.addAttribute(Attribute::ZExt); break;
++    // VISC parameter attributes
++    case lltok::kw_in:              B.addAttribute(Attribute::In); break;
++    case lltok::kw_out:             B.addAttribute(Attribute::Out); break;
++    case lltok::kw_inout:           B.addAttribute(Attribute::InOut); break;
+ 
+     case lltok::kw_alignstack:
+     case lltok::kw_alwaysinline:
+@@ -1501,6 +1510,10 @@
+     case lltok::kw_sret:
+     case lltok::kw_swifterror:
+     case lltok::kw_swiftself:
++    // VISC Parameter only attributes
++    case lltok::kw_in:
++    case lltok::kw_out:
++    case lltok::kw_inout:
+       HaveError |= Error(Lex.getLoc(), "invalid use of parameter-only attribute");
+       break;
+