Commit 5a177805 authored by Alex Zinenko's avatar Alex Zinenko
Browse files

[mlir] use unpacked memref descriptors at function boundaries 

The existing (default) calling convention for memrefs in standard-to-LLVM
conversion was motivated by interfacing with LLVM IR produced from C sources.
In particular, it passes a pointer to the memref descriptor structure when
calling the function. Therefore, the descriptor is allocated on stack before
the call. This convention leads to several problems. PR44644 indicates a
problem with stack exhaustion when calling functions with memref-typed
arguments in a loop. Allocating outside of the loop may lead to concurrent
access problems in case the loop is parallel. When targeting GPUs, the contents
of the stack-allocated memory for the descriptor (passed by pointer) needs to
be explicitly copied to the device. Using an aggregate type makes it impossible
to attach pointer-specific argument attributes pertaining to alignment and
aliasing in the LLVM dialect.

Change the default calling convention for memrefs in standard-to-LLVM
conversion to transform a memref into a list of arguments, each of primitive
type, that are comprised in the memref descriptor. This avoids stack allocation
for ranked memrefs (and thus stack exhaustion and potential concurrent access
problems) and simplifies the device function invocation on GPUs.

Provide an option in the standard-to-LLVM conversion to generate auxiliary
wrapper function with the same interface as the previous calling convention,
compatible with LLVM IR porduced from C sources. These auxiliary functions
pack the individual values into a descriptor structure or unpack it. They also
handle descriptor stack allocation if necessary, serving as an allocation
scope: the memory reserved by `alloca` will be freed on exiting the auxiliary
function.

The effect of this change on MLIR-generated only LLVM IR is minimal. When
interfacing MLIR-generated LLVM IR with C-generated LLVM IR, the integration
only needs to require auxiliary functions and change the function name to call
the wrapper function instead of the original function.

This also opens the door to forwarding aliasing and alignment information from
memrefs to LLVM IR pointers in the standrd-to-LLVM conversion.
parent 1dc62d03

mlir/docs/ConversionToLLVMDialect.md

+238 −38
Original line number Diff line number Diff line
@@ -248,58 +248,123 @@ func @bar() { 


### Calling Convention for `memref`



For function _arguments_ of `memref` type, ranked or unranked, the type of the

argument is a _pointer_ to the memref descriptor type defined above. The caller

of such function is required to store the descriptor in memory and guarantee

that the storage remains live until the callee returns. The caller can than pass

the pointer to that memory as function argument. The callee loads from the

pointers it was passed as arguments in the entry block of the function, making

the descriptor passed in as argument available for use similarly to

ocally-defined descriptors.

Function _arguments_ of `memref` type, ranked or unranked, are _expanded_ into a

list of arguments of non-aggregate types that the memref descriptor defined

above comprises. That is, the outer struct type and the inner array types are

replaced with individual arguments.



This convention is implemented in the conversion of `std.func` and `std.call` to

the LLVM dialect. Conversions from other dialects should take it into account.

The motivation for this convention is to simplify the ABI for interfacing with

other LLVM modules, in particular those generated from C sources, while avoiding

platform-specific aspects until MLIR has a proper ABI modeling.

the LLVM dialect, with the former unpacking the descriptor into a set of

individual values and the latter packing those values back into a descriptor so

as to make it transparently usable by other operations. Conversions from other

dialects should take this convention into account.



Example:

This specific convention is motivated by the necessity to specify alignment and

aliasing attributes on the raw pointers underpinning the memref.



```mlir

Examples:



func @foo(memref<?xf32>) -> () {

  %c0 = constant 0 : index

  load %arg0[%c0] : memref<?xf32>

```mlir

func @foo(%arg0: memref<?xf32>) -> () {

  "use"(%arg0) : (memref<?xf32>) -> ()

  return

}



func @bar(%arg0: index) {

  %0 = alloc(%arg0) : memref<?xf32>

// Gets converted to the following.



llvm.func @foo(%arg0: !llvm<"float*">,   // Allocated pointer.

               %arg1: !llvm<"float*">,   // Aligned pointer.

               %arg2: !llvm.i64,         // Offset.

               %arg3: !llvm.i64,         // Size in dim 0.

               %arg4: !llvm.i64) {       // Stride in dim 0.

  // Populate memref descriptor structure.

  %0 = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %1 = llvm.insertvalue %arg0, %0[0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %2 = llvm.insertvalue %arg1, %1[1] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %3 = llvm.insertvalue %arg2, %2[2] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %5 = llvm.insertvalue %arg4, %4[4, 0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">



  // Descriptor is now usable as a single value.

  "use"(%5) : (!llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">) -> ()

  llvm.return

}

```



```mlir

func @bar() {

  %0 = "get"() : () -> (memref<?xf32>)

  call @foo(%0) : (memref<?xf32>) -> ()

  return

}



// Gets converted to the following IR.

// Accepts a pointer to the memref descriptor.

llvm.func @foo(!llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">) {

  // Loads the descriptor so that it can be used similarly to locally

  // created descriptors.

  %0 = llvm.load %arg0 : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">

// Gets converted to the following.



llvm.func @bar() {

  %0 = "get"() : () -> !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">



  // Unpack the memref descriptor.

  %1 = llvm.extractvalue %0[0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %2 = llvm.extractvalue %0[1] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %3 = llvm.extractvalue %0[2] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %4 = llvm.extractvalue %0[3, 0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  %5 = llvm.extractvalue %0[4, 0] : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">



  // Pass individual values to the callee.

  llvm.call @foo(%1, %2, %3, %4, %5) : (!llvm<"float*">, !llvm<"float*">, !llvm.i64, !llvm.i64, !llvm.i64) -> ()

  llvm.return

}



```



For **unranked** memrefs, the list of function arguments always contains two

elements, same as the unranked memref descriptor: an integer rank, and a

type-erased (`!llvm<"i8*">`) pointer to the ranked memref descriptor. Note that

while the _calling convention_ does not require stack allocation, _casting_ to

unranked memref does since one cannot take an address of an SSA value containing

the ranked memref. The caller is in charge of ensuring the thread safety and

eventually removing unnecessary stack allocations in cast operations.



Example



```mlir

llvm.func @foo(%arg0: memref<*xf32>) -> () {

  "use"(%arg0) : (memref<*xf32>) -> ()

  return

}



// Gets converted to the following.



llvm.func @foo(%arg0: !llvm.i64       // Rank.

               %arg1: !llvm<"i8*">) { // Type-erased pointer to descriptor.

  // Pack the unranked memref descriptor.

  %0 = llvm.mlir.undef : !llvm<"{ i64, i8* }">

  %1 = llvm.insertvalue %arg0, %0[0] : !llvm<"{ i64, i8* }">

  %2 = llvm.insertvalue %arg1, %1[1] : !llvm<"{ i64, i8* }">



  "use"(%2) : (!llvm<"{ i64, i8* }">) -> ()

  llvm.return

}

```



```mlir

llvm.func @bar() {

  %0 = "get"() : () -> (memref<*xf32>)

  call @foo(%0): (memref<*xf32>) -> ()

  return

}



llvm.func @bar(%arg0: !llvm.i64) {

  // ... Allocation ...

  // Definition of the descriptor.

  %7 = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

  // ... Filling in the descriptor ...

  %14 = // The final value of the allocated descriptor.

  // Allocate the memory for the descriptor and store it.

  %15 = llvm.mlir.constant(1 : index) : !llvm.i64

  %16 = llvm.alloca %15 x !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }">

      : (!llvm.i64) -> !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">

  llvm.store %14, %16 : !llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">

  // Pass the pointer to the function.

  llvm.call @foo(%16) : (!llvm<"{ float*, float*, i64, [1 x i64], [1 x i64] }*">) -> ()

// Gets converted to the following.



llvm.func @bar() {

  %0 = "get"() : () -> (!llvm<"{ i64, i8* }">)



  // Unpack the memref descriptor.

  %1 = llvm.extractvalue %0[0] : !llvm<"{ i64, i8* }">

  %2 = llvm.extractvalue %0[1] : !llvm<"{ i64, i8* }">



  // Pass individual values to the callee.

  llvm.call @foo(%1, %2) : (!llvm.i64, !llvm<"i8*">)

  llvm.return

}

```
@@ -307,6 +372,141 @@ llvm.func @bar(%arg0: !llvm.i64) { 
*This convention may or may not apply if the conversion of MemRef types is

overridden by the user.*



### C-compatible wrapper emission



In practical cases, it may be desirable to have externally-facing functions

with a single attribute corresponding to a MemRef argument. When interfacing

with LLVM IR produced from C, the code needs to respect the corresponding

calling convention. The conversion to the LLVM dialect provides an option to

generate wrapper functions that take memref descriptors as pointers-to-struct

compatible with data types produced by Clang when compiling C sources.



More specifically, a memref argument is converted into a pointer-to-struct

argument of type `{T*, T*, i64, i64[N], i64[N]}*` in the wrapper function, where

`T` is the converted element type and `N` is the memref rank. This type is

compatible with that produced by Clang for the following C++ structure template

instantiations or their equivalents in C.



```cpp

template<typename T, size_t N>

struct MemRefDescriptor {

  T *allocated;

  T *aligned;

  intptr_t offset;

  intptr_t sizes[N];

  intptr_t stides[N];

};

```



If enabled, the option will do the following. For _external_ functions declared

in the MLIR module.



1. Declare a new function `_mlir_ciface_<original name>` where memref arguments

   are converted to pointer-to-struct and the remaining arguments are converted

   as usual.

1. Add a body to the original function (making it non-external) that

   1. allocates a memref descriptor,

   1. populates it, and

   1. passes the pointer to it into the newly declared interface function

   1. collects the result of the call and returns it to the caller.



For (non-external) functions defined in the MLIR module.



1. Define a new function `_mlir_ciface_<original name>` where memref arguments

   are converted to pointer-to-struct and the remaining arguments are converted

   as usual.

1. Populate the body of the newly defined function with IR that

   1. loads descriptors from pointers;

   1. unpacks descriptor into individual non-aggregate values;

   1. passes these values into the original function;

   1. collects the result of the call and returns it to the caller.



Examples:



```mlir



func @qux(%arg0: memref<?x?xf32>)



// Gets converted into the following.



// Function with unpacked arguments.

llvm.func @qux(%arg0: !llvm<"float*">, %arg1: !llvm<"float*">, %arg2: !llvm.i64,

               %arg3: !llvm.i64, %arg4: !llvm.i64, %arg5: !llvm.i64,

               %arg6: !llvm.i64) {

  // Populate memref descriptor (as per calling convention).

  %0 = llvm.mlir.undef : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %1 = llvm.insertvalue %arg0, %0[0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %2 = llvm.insertvalue %arg1, %1[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %3 = llvm.insertvalue %arg2, %2[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %4 = llvm.insertvalue %arg3, %3[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %5 = llvm.insertvalue %arg5, %4[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %6 = llvm.insertvalue %arg4, %5[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %7 = llvm.insertvalue %arg6, %6[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">



  // Store the descriptor in a stack-allocated space.

  %8 = llvm.mlir.constant(1 : index) : !llvm.i64

  %9 = llvm.alloca %8 x !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

                 : (!llvm.i64) -> !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">

  llvm.store %7, %9 : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">



  // Call the interface function.

  llvm.call @_mlir_ciface_qux(%9) : (!llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">) -> ()



  // The stored descriptor will be freed on return.

  llvm.return

}



// Interface function.

llvm.func @_mlir_ciface_qux(!llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">)

```



```mlir

func @foo(%arg0: memref<?x?xf32>) {

  return

}



// Gets converted into the following.



// Function with unpacked arguments.

llvm.func @foo(%arg0: !llvm<"float*">, %arg1: !llvm<"float*">, %arg2: !llvm.i64,

               %arg3: !llvm.i64, %arg4: !llvm.i64, %arg5: !llvm.i64,

               %arg6: !llvm.i64) {

  llvm.return

}



// Interface function callable from C.

llvm.func @_mlir_ciface_foo(%arg0: !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">) {

  // Load the descriptor.

  %0 = llvm.load %arg0 : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }*">



  // Unpack the descriptor as per calling convention.

  %1 = llvm.extractvalue %0[0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %2 = llvm.extractvalue %0[1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %3 = llvm.extractvalue %0[2] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %4 = llvm.extractvalue %0[3, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %5 = llvm.extractvalue %0[3, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %6 = llvm.extractvalue %0[4, 0] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  %7 = llvm.extractvalue %0[4, 1] : !llvm<"{ float*, float*, i64, [2 x i64], [2 x i64] }">

  llvm.call @foo(%1, %2, %3, %4, %5, %6, %7)

    : (!llvm<"float*">, !llvm<"float*">, !llvm.i64, !llvm.i64, !llvm.i64,

       !llvm.i64, !llvm.i64) -> ()

  llvm.return

}

```



Rationale: Introducing auxiliary functions for C-compatible interfaces is

preferred to modifying the calling convention since it will minimize the effect

of C compatibility on intra-module calls or calls between MLIR-generated

functions. In particular, when calling external functions from an MLIR module in

a (parallel) loop, the fact of storing a memref descriptor on stack can lead to

stack exhaustion and/or concurrent access to the same address. Auxiliary

interface function serves as an allocation scope in this case. Furthermore, when

targeting accelerators with separate memory spaces such as GPUs, stack-allocated

descriptors passed by pointer would have to be transferred to the device memory,

which introduces significant overhead. In such situations, auxiliary interface

functions are executed on host and only pass the values through device function

invocation mechanism.



## Repeated Successor Removal



Since the goal of the LLVM IR dialect is to reflect LLVM IR in MLIR, the dialect

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVM.h

+122 −16
Original line number Diff line number Diff line
@@ -36,8 +36,8 @@ class LLVMType; 


/// Set of callbacks that allows the customization of LLVMTypeConverter.

struct LLVMTypeConverterCustomization {

  using CustomCallback =

      std::function<LLVM::LLVMType(LLVMTypeConverter &, Type)>;

  using CustomCallback = std::function<LogicalResult(LLVMTypeConverter &, Type,

                                                     SmallVectorImpl<Type> &)>;



  /// Customize the type conversion of function arguments.

  CustomCallback funcArgConverter;
@@ -47,19 +47,26 @@ struct LLVMTypeConverterCustomization { 
};



/// Callback to convert function argument types. It converts a MemRef function

/// argument to a struct that contains the descriptor information. Converted

/// types are promoted to a pointer to the converted type.

LLVM::LLVMType structFuncArgTypeConverter(LLVMTypeConverter &converter,

                                          Type type);

/// argument to a list of non-aggregate types containing descriptor

/// information, and an UnrankedmemRef function argument to a list containing

/// the rank and a pointer to a descriptor struct.

LogicalResult structFuncArgTypeConverter(LLVMTypeConverter &converter,

                                         Type type,

                                         SmallVectorImpl<Type> &result);



/// Callback to convert function argument types. It converts MemRef function

/// arguments to bare pointers to the MemRef element type. Converted types are

/// not promoted to pointers.

LLVM::LLVMType barePtrFuncArgTypeConverter(LLVMTypeConverter &converter,

                                           Type type);

/// arguments to bare pointers to the MemRef element type.

LogicalResult barePtrFuncArgTypeConverter(LLVMTypeConverter &converter,

                                          Type type,

                                          SmallVectorImpl<Type> &result);



/// Conversion from types in the Standard dialect to the LLVM IR dialect.

class LLVMTypeConverter : public TypeConverter {

  /// Give structFuncArgTypeConverter access to memref-specific functions.

  friend LogicalResult

  structFuncArgTypeConverter(LLVMTypeConverter &converter, Type type,

                             SmallVectorImpl<Type> &result);



public:

  using TypeConverter::convertType;
@@ -107,6 +114,15 @@ public: 
  Value promoteOneMemRefDescriptor(Location loc, Value operand,

                                   OpBuilder &builder);



  /// Converts the function type to a C-compatible format, in particular using

  /// pointers to memref descriptors for arguments.

  LLVM::LLVMType convertFunctionTypeCWrapper(FunctionType type);



  /// Creates descriptor structs from individual values constituting them.

  Operation *materializeConversion(PatternRewriter &rewriter, Type type,

                                   ArrayRef<Value> values,

                                   Location loc) override;



protected:

  /// LLVM IR module used to parse/create types.

  llvm::Module *module;
@@ -133,14 +149,34 @@ private: 
  // by LLVM.

  Type convertFloatType(FloatType type);



  // Convert a memref type into an LLVM type that captures the relevant data.

  // For statically-shaped memrefs, the resulting type is a pointer to the

  // (converted) memref element type. For dynamically-shaped memrefs, the

  // resulting type is an LLVM structure type that contains:

  //   1. a pointer to the (converted) memref element type

  //   2. as many index types as memref has dynamic dimensions.

  /// Convert a memref type into an LLVM type that captures the relevant data.

  Type convertMemRefType(MemRefType type);



  /// Convert a memref type into a list of non-aggregate LLVM IR types that

  /// contain all the relevant data. In particular, the list will contain:

  /// - two pointers to the memref element type, followed by

  /// - an integer offset, followed by

  /// - one integer size per dimension of the memref, followed by

  /// - one integer stride per dimension of the memref.

  /// For example, memref<?x?xf32> is converted to the following list:

  /// - `!llvm<"float*">` (allocated pointer),

  /// - `!llvm<"float*">` (aligned pointer),

  /// - `!llvm.i64` (offset),

  /// - `!llvm.i64`, `!llvm.i64` (sizes),

  /// - `!llvm.i64`, `!llvm.i64` (strides).

  /// These types can be recomposed to a memref descriptor struct.

  SmallVector<Type, 5> convertMemRefSignature(MemRefType type);



  /// Convert an unranked memref type into a list of non-aggregate LLVM IR types

  /// that contain all the relevant data. In particular, this list contains:

  /// - an integer rank, followed by

  /// - a pointer to the memref descriptor struct.

  /// For example, memref<*xf32> is converted to the following list:

  /// !llvm.i64 (rank)

  /// !llvm<"i8*"> (type-erased pointer).

  /// These types can be recomposed to a unranked memref descriptor struct.

  SmallVector<Type, 2> convertUnrankedMemRefSignature();



  // Convert an unranked memref type to an LLVM type that captures the

  // runtime rank and a pointer to the static ranked memref desc

  Type convertUnrankedMemRefType(UnrankedMemRefType type);
@@ -180,6 +216,7 @@ protected: 
  /// Builds IR to set a value in the struct at position pos

  void setPtr(OpBuilder &builder, Location loc, unsigned pos, Value ptr);

};



/// Helper class to produce LLVM dialect operations extracting or inserting

/// elements of a MemRef descriptor. Wraps a Value pointing to the descriptor.

/// The Value may be null, in which case none of the operations are valid.
@@ -234,11 +271,63 @@ public: 
  /// Returns the (LLVM) type this descriptor points to.

  LLVM::LLVMType getElementType();



  /// Builds IR populating a MemRef descriptor structure from a list of

  /// individual values composing that descriptor, in the following order:

  /// - allocated pointer;

  /// - aligned pointer;

  /// - offset;

  /// - <rank> sizes;

  /// - <rank> shapes;

  /// where <rank> is the MemRef rank as provided in `type`.

  static Value pack(OpBuilder &builder, Location loc,

                    LLVMTypeConverter &converter, MemRefType type,

                    ValueRange values);



  /// Builds IR extracting individual elements of a MemRef descriptor structure

  /// and returning them as `results` list.

  static void unpack(OpBuilder &builder, Location loc, Value packed,

                     MemRefType type, SmallVectorImpl<Value> &results);



  /// Returns the number of non-aggregate values that would be produced by

  /// `unpack`.

  static unsigned getNumUnpackedValues(MemRefType type);



private:

  // Cached index type.

  Type indexType;

};



/// Helper class allowing the user to access a range of Values that correspond

/// to an unpacked memref descriptor using named accessors. This does not own

/// the values.

class MemRefDescriptorView {

public:

  /// Constructs the view from a range of values. Infers the rank from the size

  /// of the range.

  explicit MemRefDescriptorView(ValueRange range);



  /// Returns the allocated pointer Value.

  Value allocatedPtr();



  /// Returns the aligned pointer Value.

  Value alignedPtr();



  /// Returns the offset Value.

  Value offset();



  /// Returns the pos-th size Value.

  Value size(unsigned pos);



  /// Returns the pos-th stride Value.

  Value stride(unsigned pos);



private:

  /// Rank of the memref the descriptor is pointing to.

  int rank;

  /// Underlying range of Values.

  ValueRange elements;

};



class UnrankedMemRefDescriptor : public StructBuilder {

public:

  /// Construct a helper for the given descriptor value.
@@ -255,6 +344,23 @@ public: 
  Value memRefDescPtr(OpBuilder &builder, Location loc);

  /// Builds IR setting ranked memref descriptor ptr

  void setMemRefDescPtr(OpBuilder &builder, Location loc, Value value);



  /// Builds IR populating an unranked MemRef descriptor structure from a list

  /// of individual constituent values in the following order:

  /// - rank of the memref;

  /// - pointer to the memref descriptor.

  static Value pack(OpBuilder &builder, Location loc,

                    LLVMTypeConverter &converter, UnrankedMemRefType type,

                    ValueRange values);



  /// Builds IR extracting individual elements that compose an unranked memref

  /// descriptor and returns them as `results` list.

  static void unpack(OpBuilder &builder, Location loc, Value packed,

                     SmallVectorImpl<Value> &results);



  /// Returns the number of non-aggregate values that would be produced by

  /// `unpack`.

  static unsigned getNumUnpackedValues() { return 2; }

};

/// Base class for operation conversions targeting the LLVM IR dialect. Provides

/// conversion patterns with an access to the containing LLVMLowering for the

mlir/include/mlir/Conversion/StandardToLLVM/ConvertStandardToLLVMPass.h

+9 −4
Original line number Diff line number Diff line
@@ -29,16 +29,21 @@ void populateStdToLLVMMemoryConversionPatters( 
void populateStdToLLVMNonMemoryConversionPatterns(

    LLVMTypeConverter &converter, OwningRewritePatternList &patterns);



/// Collect the default pattern to convert a FuncOp to the LLVM dialect.

/// Collect the default pattern to convert a FuncOp to the LLVM dialect. If

/// `emitCWrappers` is set, the pattern will also produce functions

/// that pass memref descriptors by pointer-to-structure in addition to the

/// default unpacked form.

void populateStdToLLVMDefaultFuncOpConversionPattern(

    LLVMTypeConverter &converter, OwningRewritePatternList &patterns);

    LLVMTypeConverter &converter, OwningRewritePatternList &patterns,

    bool emitCWrappers = false);



/// Collect a set of default patterns to convert from the Standard dialect to

/// LLVM. If `useAlloca` is set, the patterns for AllocOp and DeallocOp will

/// generate `llvm.alloca` instead of calls to "malloc".

void populateStdToLLVMConversionPatterns(LLVMTypeConverter &converter,

                                         OwningRewritePatternList &patterns,

                                         bool useAlloca = false);

                                         bool useAlloca = false,

                                         bool emitCWrappers = false);



/// Collect a set of patterns to convert from the Standard dialect to

/// LLVM using the bare pointer calling convention for MemRef function
@@ -53,7 +58,7 @@ void populateStdToLLVMBarePtrConversionPatterns( 
/// Specifying `useAlloca-true` emits stack allocations instead. In the future

/// this may become an enum when we have concrete uses for other options.

std::unique_ptr<OpPassBase<ModuleOp>>

createLowerToLLVMPass(bool useAlloca = false);

createLowerToLLVMPass(bool useAlloca = false, bool emitCWrappers = false);



namespace LLVM {

/// Make argument-taking successors of each block distinct.  PHI nodes in LLVM

mlir/include/mlir/IR/FunctionSupport.h

+7 −0
Original line number Diff line number Diff line
@@ -30,6 +30,13 @@ inline StringRef getArgAttrName(unsigned arg, SmallVectorImpl<char> &out) { 
  return ("arg" + Twine(arg)).toStringRef(out);

}



/// Returns true if the given name is a valid argument attribute name.

inline bool isArgAttrName(StringRef name) {

  APInt unused;

  return name.startswith("arg") &&

         !name.drop_front(3).getAsInteger(/*Radix=*/10, unused);

}



/// Return the name of the attribute used for function results.

inline StringRef getResultAttrName(unsigned arg, SmallVectorImpl<char> &out) {

  out.clear();

mlir/lib/Conversion/GPUToCUDA/ConvertLaunchFuncToCudaCalls.cpp

+78 −30

File changed.

Preview size limit exceeded, changes collapsed.