MLIR  14.0.0git
OpenACCToLLVMIRTranslation.cpp
Go to the documentation of this file.
1 //===- OpenACCToLLVMIRTranslation.cpp -------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements a translation between the MLIR OpenACC dialect and LLVM
10 // IR.
11 //
12 //===----------------------------------------------------------------------===//
13 
18 #include "mlir/IR/BuiltinOps.h"
19 #include "mlir/IR/Operation.h"
20 #include "mlir/Support/LLVM.h"
22 
23 #include "llvm/ADT/TypeSwitch.h"
24 #include "llvm/Frontend/OpenMP/OMPConstants.h"
25 #include "llvm/Support/FormatVariadic.h"
26 
27 using namespace mlir;
28 
29 using OpenACCIRBuilder = llvm::OpenMPIRBuilder;
30 
31 //===----------------------------------------------------------------------===//
32 // Utility functions
33 //===----------------------------------------------------------------------===//
34 
35 /// Flag values are extracted from openmp/libomptarget/include/omptarget.h and
36 /// mapped to corresponding OpenACC flags.
37 static constexpr uint64_t kCreateFlag = 0x000;
38 static constexpr uint64_t kDeviceCopyinFlag = 0x001;
39 static constexpr uint64_t kHostCopyoutFlag = 0x002;
40 static constexpr uint64_t kCopyFlag = kDeviceCopyinFlag | kHostCopyoutFlag;
41 static constexpr uint64_t kPresentFlag = 0x1000;
42 static constexpr uint64_t kDeleteFlag = 0x008;
43 // Runtime extension to implement the OpenACC second reference counter.
44 static constexpr uint64_t kHoldFlag = 0x2000;
45 
46 /// Default value for the device id
47 static constexpr int64_t kDefaultDevice = -1;
48 
49 /// Create a constant string location from the MLIR Location information.
51  OpenACCIRBuilder &builder,
52  StringRef name) {
53  if (auto fileLoc = loc.dyn_cast<FileLineColLoc>()) {
54  StringRef fileName = fileLoc.getFilename();
55  unsigned lineNo = fileLoc.getLine();
56  unsigned colNo = fileLoc.getColumn();
57  return builder.getOrCreateSrcLocStr(name, fileName, lineNo, colNo);
58  } else {
59  std::string locStr;
60  llvm::raw_string_ostream locOS(locStr);
61  locOS << loc;
62  return builder.getOrCreateSrcLocStr(locOS.str());
63  }
64 }
65 
66 /// Create the location struct from the operation location information.
67 static llvm::Value *createSourceLocationInfo(OpenACCIRBuilder &builder,
68  Operation *op) {
69  auto loc = op->getLoc();
70  auto funcOp = op->getParentOfType<LLVM::LLVMFuncOp>();
71  StringRef funcName = funcOp ? funcOp.getName() : "unknown";
72  llvm::Constant *locStr =
73  createSourceLocStrFromLocation(loc, builder, funcName);
74  return builder.getOrCreateIdent(locStr);
75 }
76 
77 /// Create a constant string representing the mapping information extracted from
78 /// the MLIR location information.
80  OpenACCIRBuilder &builder) {
81  if (auto nameLoc = loc.dyn_cast<NameLoc>()) {
82  StringRef name = nameLoc.getName();
83  return createSourceLocStrFromLocation(nameLoc.getChildLoc(), builder, name);
84  } else {
85  return createSourceLocStrFromLocation(loc, builder, "unknown");
86  }
87 }
88 
89 /// Return the runtime function used to lower the given operation.
90 static llvm::Function *getAssociatedFunction(OpenACCIRBuilder &builder,
91  Operation *op) {
93  .Case([&](acc::EnterDataOp) {
94  return builder.getOrCreateRuntimeFunctionPtr(
95  llvm::omp::OMPRTL___tgt_target_data_begin_mapper);
96  })
97  .Case([&](acc::ExitDataOp) {
98  return builder.getOrCreateRuntimeFunctionPtr(
99  llvm::omp::OMPRTL___tgt_target_data_end_mapper);
100  })
101  .Case([&](acc::UpdateOp) {
102  return builder.getOrCreateRuntimeFunctionPtr(
103  llvm::omp::OMPRTL___tgt_target_data_update_mapper);
104  });
105  llvm_unreachable("Unknown OpenACC operation");
106 }
107 
108 /// Computes the size of type in bytes.
109 static llvm::Value *getSizeInBytes(llvm::IRBuilderBase &builder,
110  llvm::Value *basePtr) {
111  llvm::LLVMContext &ctx = builder.getContext();
112  llvm::Value *null =
113  llvm::Constant::getNullValue(basePtr->getType()->getPointerTo());
114  llvm::Value *sizeGep =
115  builder.CreateGEP(basePtr->getType(), null, builder.getInt32(1));
116  llvm::Value *sizePtrToInt =
117  builder.CreatePtrToInt(sizeGep, llvm::Type::getInt64Ty(ctx));
118  return sizePtrToInt;
119 }
120 
121 /// Extract pointer, size and mapping information from operands
122 /// to populate the future functions arguments.
123 static LogicalResult
124 processOperands(llvm::IRBuilderBase &builder,
125  LLVM::ModuleTranslation &moduleTranslation, Operation *op,
126  ValueRange operands, unsigned totalNbOperand,
127  uint64_t operandFlag, SmallVector<uint64_t> &flags,
128  SmallVectorImpl<llvm::Constant *> &names, unsigned &index,
129  struct OpenACCIRBuilder::MapperAllocas &mapperAllocas) {
130  OpenACCIRBuilder *accBuilder = moduleTranslation.getOpenMPBuilder();
131  llvm::LLVMContext &ctx = builder.getContext();
132  auto *i8PtrTy = llvm::Type::getInt8PtrTy(ctx);
133  auto *arrI8PtrTy = llvm::ArrayType::get(i8PtrTy, totalNbOperand);
134  auto *i64Ty = llvm::Type::getInt64Ty(ctx);
135  auto *arrI64Ty = llvm::ArrayType::get(i64Ty, totalNbOperand);
136 
137  for (Value data : operands) {
138  llvm::Value *dataValue = moduleTranslation.lookupValue(data);
139 
140  llvm::Value *dataPtrBase;
141  llvm::Value *dataPtr;
142  llvm::Value *dataSize;
143 
144  // Handle operands that were converted to DataDescriptor.
145  if (DataDescriptor::isValid(data)) {
146  dataPtrBase =
147  builder.CreateExtractValue(dataValue, kPtrBasePosInDataDescriptor);
148  dataPtr = builder.CreateExtractValue(dataValue, kPtrPosInDataDescriptor);
149  dataSize =
150  builder.CreateExtractValue(dataValue, kSizePosInDataDescriptor);
151  } else if (data.getType().isa<LLVM::LLVMPointerType>()) {
152  dataPtrBase = dataValue;
153  dataPtr = dataValue;
154  dataSize = getSizeInBytes(builder, dataValue);
155  } else {
156  return op->emitOpError()
157  << "Data operand must be legalized before translation."
158  << "Unsupported type: " << data.getType();
159  }
160 
161  // Store base pointer extracted from operand into the i-th position of
162  // argBase.
163  llvm::Value *ptrBaseGEP = builder.CreateInBoundsGEP(
164  arrI8PtrTy, mapperAllocas.ArgsBase,
165  {builder.getInt32(0), builder.getInt32(index)});
166  llvm::Value *ptrBaseCast = builder.CreateBitCast(
167  ptrBaseGEP, dataPtrBase->getType()->getPointerTo());
168  builder.CreateStore(dataPtrBase, ptrBaseCast);
169 
170  // Store pointer extracted from operand into the i-th position of args.
171  llvm::Value *ptrGEP = builder.CreateInBoundsGEP(
172  arrI8PtrTy, mapperAllocas.Args,
173  {builder.getInt32(0), builder.getInt32(index)});
174  llvm::Value *ptrCast =
175  builder.CreateBitCast(ptrGEP, dataPtr->getType()->getPointerTo());
176  builder.CreateStore(dataPtr, ptrCast);
177 
178  // Store size extracted from operand into the i-th position of argSizes.
179  llvm::Value *sizeGEP = builder.CreateInBoundsGEP(
180  arrI64Ty, mapperAllocas.ArgSizes,
181  {builder.getInt32(0), builder.getInt32(index)});
182  builder.CreateStore(dataSize, sizeGEP);
183 
184  flags.push_back(operandFlag);
185  llvm::Constant *mapName =
186  createMappingInformation(data.getLoc(), *accBuilder);
187  names.push_back(mapName);
188  ++index;
189  }
190  return success();
191 }
192 
193 /// Process data operands from acc::EnterDataOp
194 static LogicalResult
195 processDataOperands(llvm::IRBuilderBase &builder,
196  LLVM::ModuleTranslation &moduleTranslation,
197  acc::EnterDataOp op, SmallVector<uint64_t> &flags,
199  struct OpenACCIRBuilder::MapperAllocas &mapperAllocas) {
200  // TODO add `create_zero` and `attach` operands
201 
202  unsigned index = 0;
203 
204  // Create operands are handled as `alloc` call.
205  if (failed(processOperands(builder, moduleTranslation, op,
206  op.createOperands(), op.getNumDataOperands(),
207  kCreateFlag, flags, names, index, mapperAllocas)))
208  return failure();
209 
210  // Copyin operands are handled as `to` call.
211  if (failed(processOperands(builder, moduleTranslation, op,
212  op.copyinOperands(), op.getNumDataOperands(),
213  kDeviceCopyinFlag, flags, names, index,
214  mapperAllocas)))
215  return failure();
216 
217  return success();
218 }
219 
220 /// Process data operands from acc::ExitDataOp
221 static LogicalResult
222 processDataOperands(llvm::IRBuilderBase &builder,
223  LLVM::ModuleTranslation &moduleTranslation,
224  acc::ExitDataOp op, SmallVector<uint64_t> &flags,
226  struct OpenACCIRBuilder::MapperAllocas &mapperAllocas) {
227  // TODO add `detach` operands
228 
229  unsigned index = 0;
230 
231  // Delete operands are handled as `delete` call.
232  if (failed(processOperands(builder, moduleTranslation, op,
233  op.deleteOperands(), op.getNumDataOperands(),
234  kDeleteFlag, flags, names, index, mapperAllocas)))
235  return failure();
236 
237  // Copyout operands are handled as `from` call.
238  if (failed(processOperands(builder, moduleTranslation, op,
239  op.copyoutOperands(), op.getNumDataOperands(),
240  kHostCopyoutFlag, flags, names, index,
241  mapperAllocas)))
242  return failure();
243 
244  return success();
245 }
246 
247 /// Process data operands from acc::UpdateOp
248 static LogicalResult
249 processDataOperands(llvm::IRBuilderBase &builder,
250  LLVM::ModuleTranslation &moduleTranslation,
251  acc::UpdateOp op, SmallVector<uint64_t> &flags,
253  struct OpenACCIRBuilder::MapperAllocas &mapperAllocas) {
254  unsigned index = 0;
255 
256  // Host operands are handled as `from` call.
257  if (failed(processOperands(builder, moduleTranslation, op, op.hostOperands(),
258  op.getNumDataOperands(), kHostCopyoutFlag, flags,
259  names, index, mapperAllocas)))
260  return failure();
261 
262  // Device operands are handled as `to` call.
263  if (failed(processOperands(builder, moduleTranslation, op,
264  op.deviceOperands(), op.getNumDataOperands(),
265  kDeviceCopyinFlag, flags, names, index,
266  mapperAllocas)))
267  return failure();
268 
269  return success();
270 }
271 
272 //===----------------------------------------------------------------------===//
273 // Conversion functions
274 //===----------------------------------------------------------------------===//
275 
276 /// Converts an OpenACC data operation into LLVM IR.
277 static LogicalResult convertDataOp(acc::DataOp &op,
278  llvm::IRBuilderBase &builder,
279  LLVM::ModuleTranslation &moduleTranslation) {
280  llvm::LLVMContext &ctx = builder.getContext();
281  auto enclosingFuncOp = op.getOperation()->getParentOfType<LLVM::LLVMFuncOp>();
282  llvm::Function *enclosingFunction =
283  moduleTranslation.lookupFunction(enclosingFuncOp.getName());
284 
285  OpenACCIRBuilder *accBuilder = moduleTranslation.getOpenMPBuilder();
286 
287  llvm::Value *srcLocInfo = createSourceLocationInfo(*accBuilder, op);
288 
289  llvm::Function *beginMapperFunc = accBuilder->getOrCreateRuntimeFunctionPtr(
290  llvm::omp::OMPRTL___tgt_target_data_begin_mapper);
291 
292  llvm::Function *endMapperFunc = accBuilder->getOrCreateRuntimeFunctionPtr(
293  llvm::omp::OMPRTL___tgt_target_data_end_mapper);
294 
295  // Number of arguments in the data operation.
296  unsigned totalNbOperand = op.getNumDataOperands();
297 
298  struct OpenACCIRBuilder::MapperAllocas mapperAllocas;
299  OpenACCIRBuilder::InsertPointTy allocaIP(
300  &enclosingFunction->getEntryBlock(),
301  enclosingFunction->getEntryBlock().getFirstInsertionPt());
302  accBuilder->createMapperAllocas(builder.saveIP(), allocaIP, totalNbOperand,
303  mapperAllocas);
304 
305  SmallVector<uint64_t> flags;
307  unsigned index = 0;
308 
309  // TODO handle no_create, deviceptr and attach operands.
310 
311  if (failed(processOperands(builder, moduleTranslation, op, op.copyOperands(),
312  totalNbOperand, kCopyFlag | kHoldFlag, flags,
313  names, index, mapperAllocas)))
314  return failure();
315 
317  builder, moduleTranslation, op, op.copyinOperands(), totalNbOperand,
318  kDeviceCopyinFlag | kHoldFlag, flags, names, index, mapperAllocas)))
319  return failure();
320 
321  // TODO copyin readonly currenlty handled as copyin. Update when extension
322  // available.
323  if (failed(processOperands(builder, moduleTranslation, op,
324  op.copyinReadonlyOperands(), totalNbOperand,
325  kDeviceCopyinFlag | kHoldFlag, flags, names, index,
326  mapperAllocas)))
327  return failure();
328 
330  builder, moduleTranslation, op, op.copyoutOperands(), totalNbOperand,
331  kHostCopyoutFlag | kHoldFlag, flags, names, index, mapperAllocas)))
332  return failure();
333 
334  // TODO copyout zero currenlty handled as copyout. Update when extension
335  // available.
336  if (failed(processOperands(builder, moduleTranslation, op,
337  op.copyoutZeroOperands(), totalNbOperand,
338  kHostCopyoutFlag | kHoldFlag, flags, names, index,
339  mapperAllocas)))
340  return failure();
341 
342  if (failed(processOperands(builder, moduleTranslation, op,
343  op.createOperands(), totalNbOperand,
344  kCreateFlag | kHoldFlag, flags, names, index,
345  mapperAllocas)))
346  return failure();
347 
348  // TODO create zero currenlty handled as create. Update when extension
349  // available.
350  if (failed(processOperands(builder, moduleTranslation, op,
351  op.createZeroOperands(), totalNbOperand,
352  kCreateFlag | kHoldFlag, flags, names, index,
353  mapperAllocas)))
354  return failure();
355 
356  if (failed(processOperands(builder, moduleTranslation, op,
357  op.presentOperands(), totalNbOperand,
358  kPresentFlag | kHoldFlag, flags, names, index,
359  mapperAllocas)))
360  return failure();
361 
362  llvm::GlobalVariable *maptypes =
363  accBuilder->createOffloadMaptypes(flags, ".offload_maptypes");
364  llvm::Value *maptypesArg = builder.CreateConstInBoundsGEP2_32(
365  llvm::ArrayType::get(llvm::Type::getInt64Ty(ctx), totalNbOperand),
366  maptypes, /*Idx0=*/0, /*Idx1=*/0);
367 
368  llvm::GlobalVariable *mapnames =
369  accBuilder->createOffloadMapnames(names, ".offload_mapnames");
370  llvm::Value *mapnamesArg = builder.CreateConstInBoundsGEP2_32(
371  llvm::ArrayType::get(llvm::Type::getInt8PtrTy(ctx), totalNbOperand),
372  mapnames, /*Idx0=*/0, /*Idx1=*/0);
373 
374  // Create call to start the data region.
375  accBuilder->emitMapperCall(builder.saveIP(), beginMapperFunc, srcLocInfo,
376  maptypesArg, mapnamesArg, mapperAllocas,
377  kDefaultDevice, totalNbOperand);
378 
379  // Convert the region.
380  llvm::BasicBlock *entryBlock = nullptr;
381 
382  for (Block &bb : op.region()) {
383  llvm::BasicBlock *llvmBB = llvm::BasicBlock::Create(
384  ctx, "acc.data", builder.GetInsertBlock()->getParent());
385  if (entryBlock == nullptr)
386  entryBlock = llvmBB;
387  moduleTranslation.mapBlock(&bb, llvmBB);
388  }
389 
390  auto afterDataRegion = builder.saveIP();
391 
392  llvm::BranchInst *sourceTerminator = builder.CreateBr(entryBlock);
393 
394  builder.restoreIP(afterDataRegion);
395  llvm::BasicBlock *endDataBlock = llvm::BasicBlock::Create(
396  ctx, "acc.end_data", builder.GetInsertBlock()->getParent());
397 
398  SetVector<Block *> blocks =
400  for (Block *bb : blocks) {
401  llvm::BasicBlock *llvmBB = moduleTranslation.lookupBlock(bb);
402  if (bb->isEntryBlock()) {
403  assert(sourceTerminator->getNumSuccessors() == 1 &&
404  "provided entry block has multiple successors");
405  sourceTerminator->setSuccessor(0, llvmBB);
406  }
407 
408  if (failed(
409  moduleTranslation.convertBlock(*bb, bb->isEntryBlock(), builder))) {
410  return failure();
411  }
412 
413  if (isa<acc::TerminatorOp, acc::YieldOp>(bb->getTerminator()))
414  builder.CreateBr(endDataBlock);
415  }
416 
417  // Create call to end the data region.
418  builder.SetInsertPoint(endDataBlock);
419  accBuilder->emitMapperCall(builder.saveIP(), endMapperFunc, srcLocInfo,
420  maptypesArg, mapnamesArg, mapperAllocas,
421  kDefaultDevice, totalNbOperand);
422 
423  return success();
424 }
425 
426 /// Converts an OpenACC standalone data operation into LLVM IR.
427 template <typename OpTy>
428 static LogicalResult
429 convertStandaloneDataOp(OpTy &op, llvm::IRBuilderBase &builder,
430  LLVM::ModuleTranslation &moduleTranslation) {
431  auto enclosingFuncOp =
432  op.getOperation()->template getParentOfType<LLVM::LLVMFuncOp>();
433  llvm::Function *enclosingFunction =
434  moduleTranslation.lookupFunction(enclosingFuncOp.getName());
435 
436  OpenACCIRBuilder *accBuilder = moduleTranslation.getOpenMPBuilder();
437 
438  auto *srcLocInfo = createSourceLocationInfo(*accBuilder, op);
439  auto *mapperFunc = getAssociatedFunction(*accBuilder, op);
440 
441  // Number of arguments in the enter_data operation.
442  unsigned totalNbOperand = op.getNumDataOperands();
443 
444  llvm::LLVMContext &ctx = builder.getContext();
445 
446  struct OpenACCIRBuilder::MapperAllocas mapperAllocas;
447  OpenACCIRBuilder::InsertPointTy allocaIP(
448  &enclosingFunction->getEntryBlock(),
449  enclosingFunction->getEntryBlock().getFirstInsertionPt());
450  accBuilder->createMapperAllocas(builder.saveIP(), allocaIP, totalNbOperand,
451  mapperAllocas);
452 
453  SmallVector<uint64_t> flags;
455 
456  if (failed(processDataOperands(builder, moduleTranslation, op, flags, names,
457  mapperAllocas)))
458  return failure();
459 
460  llvm::GlobalVariable *maptypes =
461  accBuilder->createOffloadMaptypes(flags, ".offload_maptypes");
462  llvm::Value *maptypesArg = builder.CreateConstInBoundsGEP2_32(
463  llvm::ArrayType::get(llvm::Type::getInt64Ty(ctx), totalNbOperand),
464  maptypes, /*Idx0=*/0, /*Idx1=*/0);
465 
466  llvm::GlobalVariable *mapnames =
467  accBuilder->createOffloadMapnames(names, ".offload_mapnames");
468  llvm::Value *mapnamesArg = builder.CreateConstInBoundsGEP2_32(
469  llvm::ArrayType::get(llvm::Type::getInt8PtrTy(ctx), totalNbOperand),
470  mapnames, /*Idx0=*/0, /*Idx1=*/0);
471 
472  accBuilder->emitMapperCall(builder.saveIP(), mapperFunc, srcLocInfo,
473  maptypesArg, mapnamesArg, mapperAllocas,
474  kDefaultDevice, totalNbOperand);
475 
476  return success();
477 }
478 
479 namespace {
480 
481 /// Implementation of the dialect interface that converts operations belonging
482 /// to the OpenACC dialect to LLVM IR.
483 class OpenACCDialectLLVMIRTranslationInterface
485 public:
487 
488  /// Translates the given operation to LLVM IR using the provided IR builder
489  /// and saving the state in `moduleTranslation`.
491  convertOperation(Operation *op, llvm::IRBuilderBase &builder,
492  LLVM::ModuleTranslation &moduleTranslation) const final;
493 };
494 
495 } // end namespace
496 
497 /// Given an OpenACC MLIR operation, create the corresponding LLVM IR
498 /// (including OpenACC runtime calls).
499 LogicalResult OpenACCDialectLLVMIRTranslationInterface::convertOperation(
500  Operation *op, llvm::IRBuilderBase &builder,
501  LLVM::ModuleTranslation &moduleTranslation) const {
502 
504  .Case([&](acc::DataOp dataOp) {
505  return convertDataOp(dataOp, builder, moduleTranslation);
506  })
507  .Case([&](acc::EnterDataOp enterDataOp) {
508  return convertStandaloneDataOp<acc::EnterDataOp>(enterDataOp, builder,
509  moduleTranslation);
510  })
511  .Case([&](acc::ExitDataOp exitDataOp) {
512  return convertStandaloneDataOp<acc::ExitDataOp>(exitDataOp, builder,
513  moduleTranslation);
514  })
515  .Case([&](acc::UpdateOp updateOp) {
516  return convertStandaloneDataOp<acc::UpdateOp>(updateOp, builder,
517  moduleTranslation);
518  })
519  .Case<acc::TerminatorOp, acc::YieldOp>([](auto op) {
520  // `yield` and `terminator` can be just omitted. The block structure was
521  // created in the function that handles their parent operation.
522  assert(op->getNumOperands() == 0 &&
523  "unexpected OpenACC terminator with operands");
524  return success();
525  })
526  .Default([&](Operation *op) {
527  return op->emitError("unsupported OpenACC operation: ")
528  << op->getName();
529  });
530 }
531 
533  registry.insert<acc::OpenACCDialect>();
534  registry.addDialectInterface<acc::OpenACCDialect,
535  OpenACCDialectLLVMIRTranslationInterface>();
536 }
537 
539  DialectRegistry registry;
541  context.appendDialectRegistry(registry);
542 }
Include the generated interface declarations.
Operation is a basic unit of execution within MLIR.
Definition: Operation.h:28
static LogicalResult processDataOperands(llvm::IRBuilderBase &builder, LLVM::ModuleTranslation &moduleTranslation, acc::EnterDataOp op, SmallVector< uint64_t > &flags, SmallVectorImpl< llvm::Constant *> &names, struct OpenACCIRBuilder::MapperAllocas &mapperAllocas)
Process data operands from acc::EnterDataOp.
Block represents an ordered list of Operations.
Definition: Block.h:29
static constexpr unsigned kPtrBasePosInDataDescriptor
bool failed(LogicalResult result)
Utility function that returns true if the provided LogicalResult corresponds to a failure value...
Definition: LogicalResult.h:72
unsigned getNumOperands()
Definition: Operation.h:215
void appendDialectRegistry(const DialectRegistry &registry)
Append the contents of the given dialect registry to the registry associated with this context...
static LogicalResult convertStandaloneDataOp(OpTy &op, llvm::IRBuilderBase &builder, LLVM::ModuleTranslation &moduleTranslation)
Converts an OpenACC standalone data operation into LLVM IR.
LogicalResult convertBlock(Block &bb, bool ignoreArguments, llvm::IRBuilderBase &builder)
Translates the contents of the given block to LLVM IR using this translator.
llvm::BasicBlock * lookupBlock(Block *block) const
Finds an LLVM IR basic block that corresponds to the given MLIR block.
OpTy getParentOfType()
Return the closest surrounding parent operation that is of type &#39;OpTy&#39;.
Definition: Operation.h:120
void addDialectInterface(TypeID interfaceTypeID, DialectInterfaceAllocatorFunction allocator)
Add an interface constructed with the given allocation function to the dialect provided as template p...
Definition: Dialect.h:347
void mapBlock(Block *mlir, llvm::BasicBlock *llvm)
Stores the mapping between an MLIR block and LLVM IR basic block.
This class defines the main interface for locations in MLIR and acts as a non-nullable wrapper around...
Definition: Location.h:48
Implementation class for module translation.
llvm::OpenMPIRBuilder * getOpenMPBuilder()
Returns the OpenMP IR builder associated with the LLVM IR module being constructed.
LogicalResult success(bool isSuccess=true)
Utility function to generate a LogicalResult.
Definition: LogicalResult.h:56
static constexpr unsigned kPtrPosInDataDescriptor
This class represents an efficient way to signal success or failure.
Definition: LogicalResult.h:26
LogicalResult failure(bool isFailure=true)
Utility function to generate a LogicalResult.
Definition: LogicalResult.h:62
static llvm::Function * getAssociatedFunction(OpenACCIRBuilder &builder, Operation *op)
Return the runtime function used to lower the given operation.
Base class for dialect interfaces providing translation to LLVM IR.
static LogicalResult processOperands(llvm::IRBuilderBase &builder, LLVM::ModuleTranslation &moduleTranslation, Operation *op, ValueRange operands, unsigned totalNbOperand, uint64_t operandFlag, SmallVector< uint64_t > &flags, SmallVectorImpl< llvm::Constant *> &names, unsigned &index, struct OpenACCIRBuilder::MapperAllocas &mapperAllocas)
Extract pointer, size and mapping information from operands to populate the future functions argument...
static constexpr uint64_t kDeviceCopyinFlag
static llvm::Value * getSizeInBytes(llvm::IRBuilderBase &builder, llvm::Value *basePtr)
Computes the size of type in bytes.
static llvm::Constant * createSourceLocStrFromLocation(Location loc, OpenACCIRBuilder &builder, StringRef name)
Create a constant string location from the MLIR Location information.
Location getLoc()
The source location the operation was defined or derived from.
Definition: Operation.h:106
static constexpr uint64_t kPresentFlag
llvm::Value * lookupValue(Value value) const
Finds an LLVM IR value corresponding to the given MLIR value.
static llvm::Constant * createMappingInformation(Location loc, OpenACCIRBuilder &builder)
Create a constant string representing the mapping information extracted from the MLIR location inform...
This class represents an instance of an SSA value in the MLIR system, representing a computable value...
Definition: Value.h:84
static LogicalResult convertDataOp(acc::DataOp &op, llvm::IRBuilderBase &builder, LLVM::ModuleTranslation &moduleTranslation)
Converts an OpenACC data operation into LLVM IR.
U dyn_cast() const
Definition: Location.h:66
static constexpr unsigned kSizePosInDataDescriptor
llvm::Function * lookupFunction(StringRef name) const
Finds an LLVM IR function by its name.
static bool isValid(Value descriptor)
Check whether the type is a valid data descriptor.
SetVector< Block * > getTopologicallySortedBlocks(Region &region)
Get a topologically sorted list of blocks of the given region.
The DialectRegistry maps a dialect namespace to a constructor for the matching dialect.
Definition: Dialect.h:282
static constexpr uint64_t kCopyFlag
MLIRContext is the top-level object for a collection of MLIR operations.
Definition: MLIRContext.h:55
llvm::OpenMPIRBuilder OpenACCIRBuilder
LLVM dialect pointer type.
Definition: LLVMTypes.h:158
static constexpr uint64_t kCreateFlag
Flag values are extracted from openmp/libomptarget/include/omptarget.h and mapped to corresponding Op...
InFlightDiagnostic emitOpError(const Twine &message={})
Emit an error with the op name prefixed, like "&#39;dim&#39; op " which is convenient for verifiers...
Definition: Operation.cpp:518
void registerOpenACCDialectTranslation(DialectRegistry &registry)
Register the OpenACC dialect and the translation to the LLVM IR in the given registry;.
static llvm::Value * createSourceLocationInfo(OpenACCIRBuilder &builder, Operation *op)
Create the location struct from the operation location information.
OperationName getName()
The name of an operation is the key identifier for it.
Definition: Operation.h:57
InFlightDiagnostic emitError(const Twine &message={})
Emit an error about fatal conditions with this operation, reporting up to any diagnostic handlers tha...
Definition: Operation.cpp:231
This class provides an abstraction over the different types of ranges over Values.
static constexpr int64_t kDefaultDevice
Default value for the device id.
static constexpr uint64_t kHoldFlag
static constexpr uint64_t kHostCopyoutFlag
static constexpr uint64_t kDeleteFlag