1 | //===- Utility.h - Collection of geneirc offloading utilities -------------===// |
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 | #ifndef LLVM_FRONTEND_OFFLOADING_UTILITY_H |
10 | #define LLVM_FRONTEND_OFFLOADING_UTILITY_H |
11 | |
12 | #include "llvm/IR/Module.h" |
13 | #include "llvm/Object/OffloadBinary.h" |
14 | |
15 | namespace llvm { |
16 | namespace offloading { |
17 | |
18 | /// Offloading entry flags for CUDA / HIP. The first three bits indicate the |
19 | /// type of entry while the others are a bit field for additional information. |
20 | enum OffloadEntryKindFlag : uint32_t { |
21 | /// Mark the entry as a global entry. This indicates the presense of a |
22 | /// kernel if the size size field is zero and a variable otherwise. |
23 | OffloadGlobalEntry = 0x0, |
24 | /// Mark the entry as a managed global variable. |
25 | OffloadGlobalManagedEntry = 0x1, |
26 | /// Mark the entry as a surface variable. |
27 | OffloadGlobalSurfaceEntry = 0x2, |
28 | /// Mark the entry as a texture variable. |
29 | OffloadGlobalTextureEntry = 0x3, |
30 | /// Mark the entry as being extern. |
31 | OffloadGlobalExtern = 0x1 << 3, |
32 | /// Mark the entry as being constant. |
33 | OffloadGlobalConstant = 0x1 << 4, |
34 | /// Mark the entry as being a normalized surface. |
35 | OffloadGlobalNormalized = 0x1 << 5, |
36 | }; |
37 | |
38 | /// Returns the type of the offloading entry we use to store kernels and |
39 | /// globals that will be registered with the offloading runtime. |
40 | StructType *getEntryTy(Module &M); |
41 | |
42 | /// Create an offloading section struct used to register this global at |
43 | /// runtime. |
44 | /// |
45 | /// Type struct __tgt_offload_entry { |
46 | /// void *addr; // Pointer to the offload entry info. |
47 | /// // (function or global) |
48 | /// char *name; // Name of the function or global. |
49 | /// size_t size; // Size of the entry info (0 if it a function). |
50 | /// int32_t flags; |
51 | /// int32_t data; |
52 | /// }; |
53 | /// |
54 | /// \param M The module to be used |
55 | /// \param Addr The pointer to the global being registered. |
56 | /// \param Name The symbol name associated with the global. |
57 | /// \param Size The size in bytes of the global (0 for functions). |
58 | /// \param Flags Flags associated with the entry. |
59 | /// \param Data Extra data storage associated with the entry. |
60 | /// \param SectionName The section this entry will be placed at. |
61 | void emitOffloadingEntry(Module &M, Constant *Addr, StringRef Name, |
62 | uint64_t Size, int32_t Flags, int32_t Data, |
63 | StringRef SectionName); |
64 | /// Create a constant struct initializer used to register this global at |
65 | /// runtime. |
66 | /// \return the constant struct and the global variable holding the symbol name. |
67 | std::pair<Constant *, GlobalVariable *> |
68 | getOffloadingEntryInitializer(Module &M, Constant *Addr, StringRef Name, |
69 | uint64_t Size, int32_t Flags, int32_t Data); |
70 | |
71 | /// Creates a pair of globals used to iterate the array of offloading entries by |
72 | /// accessing the section variables provided by the linker. |
73 | std::pair<GlobalVariable *, GlobalVariable *> |
74 | getOffloadEntryArray(Module &M, StringRef SectionName); |
75 | |
76 | } // namespace offloading |
77 | } // namespace llvm |
78 | |
79 | #endif // LLVM_FRONTEND_OFFLOADING_UTILITY_H |
80 | |