Coverage Report

Created: 2017-06-06 22:25

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/lib/Target/AMDGPU/MCTargetDesc/AMDGPUCodeObjectMetadata.h
Line
Count
Source (jump to first uncovered line)
1
//===--- AMDGPUCodeObjectMetadata.h -----------------------------*- C++ -*-===//
2
//
3
//                     The LLVM Compiler Infrastructure
4
//
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
7
//
8
//===----------------------------------------------------------------------===//
9
//
10
/// \file
11
/// \brief AMDGPU Code Object Metadata definitions and in-memory
12
/// representations.
13
///
14
//
15
//===----------------------------------------------------------------------===//
16
17
#ifndef LLVM_LIB_TARGET_AMDGPU_MCTARGETDESC_AMDGPUCODEOBJECTMETADATA_H
18
#define LLVM_LIB_TARGET_AMDGPU_MCTARGETDESC_AMDGPUCODEOBJECTMETADATA_H
19
20
#include <cstdint>
21
#include <string>
22
#include <system_error>
23
#include <vector>
24
25
namespace llvm {
26
namespace AMDGPU {
27
28
//===----------------------------------------------------------------------===//
29
// Code Object Metadata.
30
//===----------------------------------------------------------------------===//
31
namespace CodeObject {
32
33
/// \brief Code object metadata major version.
34
constexpr uint32_t MetadataVersionMajor = 1;
35
/// \brief Code object metadata minor version.
36
constexpr uint32_t MetadataVersionMinor = 0;
37
38
/// \brief Code object metadata beginning assembler directive.
39
constexpr char MetadataAssemblerDirectiveBegin[] =
40
    ".amdgpu_code_object_metadata";
41
/// \brief Code object metadata ending assembler directive.
42
constexpr char MetadataAssemblerDirectiveEnd[] =
43
    ".end_amdgpu_code_object_metadata";
44
45
/// \brief Access qualifiers.
46
enum class AccessQualifier : uint8_t {
47
  Default   = 0,
48
  ReadOnly  = 1,
49
  WriteOnly = 2,
50
  ReadWrite = 3,
51
  Unknown   = 0xff
52
};
53
54
/// \brief Address space qualifiers.
55
enum class AddressSpaceQualifier : uint8_t {
56
  Private  = 0,
57
  Global   = 1,
58
  Constant = 2,
59
  Local    = 3,
60
  Generic  = 4,
61
  Region   = 5,
62
  Unknown  = 0xff
63
};
64
65
/// \brief Value kinds.
66
enum class ValueKind : uint8_t {
67
  ByValue                = 0,
68
  GlobalBuffer           = 1,
69
  DynamicSharedPointer   = 2,
70
  Sampler                = 3,
71
  Image                  = 4,
72
  Pipe                   = 5,
73
  Queue                  = 6,
74
  HiddenGlobalOffsetX    = 7,
75
  HiddenGlobalOffsetY    = 8,
76
  HiddenGlobalOffsetZ    = 9,
77
  HiddenNone             = 10,
78
  HiddenPrintfBuffer     = 11,
79
  HiddenDefaultQueue     = 12,
80
  HiddenCompletionAction = 13,
81
  Unknown                = 0xff
82
};
83
84
/// \brief Value types.
85
enum class ValueType : uint8_t {
86
  Struct  = 0,
87
  I8      = 1,
88
  U8      = 2,
89
  I16     = 3,
90
  U16     = 4,
91
  F16     = 5,
92
  I32     = 6,
93
  U32     = 7,
94
  F32     = 8,
95
  I64     = 9,
96
  U64     = 10,
97
  F64     = 11,
98
  Unknown = 0xff
99
};
100
101
//===----------------------------------------------------------------------===//
102
// Kernel Metadata.
103
//===----------------------------------------------------------------------===//
104
namespace Kernel {
105
106
//===----------------------------------------------------------------------===//
107
// Kernel Attributes Metadata.
108
//===----------------------------------------------------------------------===//
109
namespace Attrs {
110
111
namespace Key {
112
/// \brief Key for Kernel::Attr::Metadata::mReqdWorkGroupSize.
113
constexpr char ReqdWorkGroupSize[] = "ReqdWorkGroupSize";
114
/// \brief Key for Kernel::Attr::Metadata::mWorkGroupSizeHint.
115
constexpr char WorkGroupSizeHint[] = "WorkGroupSizeHint";
116
/// \brief Key for Kernel::Attr::Metadata::mVecTypeHint.
117
constexpr char VecTypeHint[] = "VecTypeHint";
118
} // end namespace Key
119
120
/// \brief In-memory representation of kernel attributes metadata.
121
struct Metadata final {
122
  /// \brief 'reqd_work_group_size' attribute. Optional.
123
  std::vector<uint32_t> mReqdWorkGroupSize = std::vector<uint32_t>();
124
  /// \brief 'work_group_size_hint' attribute. Optional.
125
  std::vector<uint32_t> mWorkGroupSizeHint = std::vector<uint32_t>();
126
  /// \brief 'vec_type_hint' attribute. Optional.
127
  std::string mVecTypeHint = std::string();
128
129
  /// \brief Default constructor.
130
1.42k
  Metadata() = default;
131
132
  /// \returns True if kernel attributes metadata is empty, false otherwise.
133
4.04k
  bool empty() const {
134
4.04k
    return mReqdWorkGroupSize.empty() &&
135
4.02k
           mWorkGroupSizeHint.empty() &&
136
3.99k
           mVecTypeHint.empty();
137
4.04k
  }
138
139
  /// \returns True if kernel attributes metadata is not empty, false otherwise.
140
0
  bool notEmpty() const {
141
0
    return !empty();
142
0
  }
143
};
144
145
} // end namespace Attrs
146
147
//===----------------------------------------------------------------------===//
148
// Kernel Argument Metadata.
149
//===----------------------------------------------------------------------===//
150
namespace Arg {
151
152
namespace Key {
153
/// \brief Key for Kernel::Arg::Metadata::mSize.
154
constexpr char Size[] = "Size";
155
/// \brief Key for Kernel::Arg::Metadata::mAlign.
156
constexpr char Align[] = "Align";
157
/// \brief Key for Kernel::Arg::Metadata::mValueKind.
158
constexpr char ValueKind[] = "ValueKind";
159
/// \brief Key for Kernel::Arg::Metadata::mValueType.
160
constexpr char ValueType[] = "ValueType";
161
/// \brief Key for Kernel::Arg::Metadata::mPointeeAlign.
162
constexpr char PointeeAlign[] = "PointeeAlign";
163
/// \brief Key for Kernel::Arg::Metadata::mAccQual.
164
constexpr char AccQual[] = "AccQual";
165
/// \brief Key for Kernel::Arg::Metadata::mAddrSpaceQual.
166
constexpr char AddrSpaceQual[] = "AddrSpaceQual";
167
/// \brief Key for Kernel::Arg::Metadata::mIsConst.
168
constexpr char IsConst[] = "IsConst";
169
/// \brief Key for Kernel::Arg::Metadata::mIsPipe.
170
constexpr char IsPipe[] = "IsPipe";
171
/// \brief Key for Kernel::Arg::Metadata::mIsRestrict.
172
constexpr char IsRestrict[] = "IsRestrict";
173
/// \brief Key for Kernel::Arg::Metadata::mIsVolatile.
174
constexpr char IsVolatile[] = "IsVolatile";
175
/// \brief Key for Kernel::Arg::Metadata::mName.
176
constexpr char Name[] = "Name";
177
/// \brief Key for Kernel::Arg::Metadata::mTypeName.
178
constexpr char TypeName[] = "TypeName";
179
} // end namespace Key
180
181
/// \brief In-memory representation of kernel argument metadata.
182
struct Metadata final {
183
  /// \brief Size in bytes. Required.
184
  uint32_t mSize = 0;
185
  /// \brief Alignment in bytes. Required.
186
  uint32_t mAlign = 0;
187
  /// \brief Value kind. Required.
188
  ValueKind mValueKind = ValueKind::Unknown;
189
  /// \brief Value type. Required.
190
  ValueType mValueType = ValueType::Unknown;
191
  /// \brief Pointee alignment in bytes. Optional.
192
  uint32_t mPointeeAlign = 0;
193
  /// \brief Access qualifier. Optional.
194
  AccessQualifier mAccQual = AccessQualifier::Unknown;
195
  /// \brief Address space qualifier. Optional.
196
  AddressSpaceQualifier mAddrSpaceQual = AddressSpaceQualifier::Unknown;
197
  /// \brief True if 'const' qualifier is specified. Optional.
198
  bool mIsConst = false;
199
  /// \brief True if 'pipe' qualifier is specified. Optional.
200
  bool mIsPipe = false;
201
  /// \brief True if 'restrict' qualifier is specified. Optional.
202
  bool mIsRestrict = false;
203
  /// \brief True if 'volatile' qualifier is specified. Optional.
204
  bool mIsVolatile = false;
205
  /// \brief Name. Optional.
206
  std::string mName = std::string();
207
  /// \brief Type name. Optional.
208
  std::string mTypeName = std::string();
209
210
  /// \brief Default constructor.
211
3.86k
  Metadata() = default;
212
};
213
214
} // end namespace Arg
215
216
//===----------------------------------------------------------------------===//
217
// Kernel Code Properties Metadata.
218
//===----------------------------------------------------------------------===//
219
namespace CodeProps {
220
221
namespace Key {
222
/// \brief Key for Kernel::CodeProps::Metadata::mKernargSegmentSize.
223
constexpr char KernargSegmentSize[] = "KernargSegmentSize";
224
/// \brief Key for Kernel::CodeProps::Metadata::mWorkgroupGroupSegmentSize.
225
constexpr char WorkgroupGroupSegmentSize[] = "WorkgroupGroupSegmentSize";
226
/// \brief Key for Kernel::CodeProps::Metadata::mWorkitemPrivateSegmentSize.
227
constexpr char WorkitemPrivateSegmentSize[] = "WorkitemPrivateSegmentSize";
228
/// \brief Key for Kernel::CodeProps::Metadata::mWavefrontNumSGPRs.
229
constexpr char WavefrontNumSGPRs[] = "WavefrontNumSGPRs";
230
/// \brief Key for Kernel::CodeProps::Metadata::mWorkitemNumVGPRs.
231
constexpr char WorkitemNumVGPRs[] = "WorkitemNumVGPRs";
232
/// \brief Key for Kernel::CodeProps::Metadata::mKernargSegmentAlign.
233
constexpr char KernargSegmentAlign[] = "KernargSegmentAlign";
234
/// \brief Key for Kernel::CodeProps::Metadata::mGroupSegmentAlign.
235
constexpr char GroupSegmentAlign[] = "GroupSegmentAlign";
236
/// \brief Key for Kernel::CodeProps::Metadata::mPrivateSegmentAlign.
237
constexpr char PrivateSegmentAlign[] = "PrivateSegmentAlign";
238
/// \brief Key for Kernel::CodeProps::Metadata::mWavefrontSize.
239
constexpr char WavefrontSize[] = "WavefrontSize";
240
} // end namespace Key
241
242
/// \brief In-memory representation of kernel code properties metadata.
243
struct Metadata final {
244
  /// \brief Size in bytes of the kernarg segment memory. Kernarg segment memory
245
  /// holds the values of the arguments to the kernel. Optional.
246
  uint64_t mKernargSegmentSize = 0;
247
  /// \brief Size in bytes of the group segment memory required by a workgroup.
248
  /// This value does not include any dynamically allocated group segment memory
249
  /// that may be added when the kernel is dispatched. Optional.
250
  uint32_t mWorkgroupGroupSegmentSize = 0;
251
  /// \brief Size in bytes of the private segment memory required by a workitem.
252
  /// Private segment memory includes arg, spill and private segments. Optional.
253
  uint32_t mWorkitemPrivateSegmentSize = 0;
254
  /// \brief Total number of SGPRs used by a wavefront. Optional.
255
  uint16_t mWavefrontNumSGPRs = 0;
256
  /// \brief Total number of VGPRs used by a workitem. Optional.
257
  uint16_t mWorkitemNumVGPRs = 0;
258
  /// \brief Maximum byte alignment of variables used by the kernel in the
259
  /// kernarg memory segment. Expressed as a power of two. Optional.
260
  uint8_t mKernargSegmentAlign = 0;
261
  /// \brief Maximum byte alignment of variables used by the kernel in the
262
  /// group memory segment. Expressed as a power of two. Optional.
263
  uint8_t mGroupSegmentAlign = 0;
264
  /// \brief Maximum byte alignment of variables used by the kernel in the
265
  /// private memory segment. Expressed as a power of two. Optional.
266
  uint8_t mPrivateSegmentAlign = 0;
267
  /// \brief Wavefront size. Expressed as a power of two. Optional.
268
  uint8_t mWavefrontSize = 0;
269
270
  /// \brief Default constructor.
271
1.42k
  Metadata() = default;
272
273
  /// \returns True if kernel code properties metadata is empty, false
274
  /// otherwise.
275
4.04k
  bool empty() const {
276
4.04k
    return !notEmpty();
277
4.04k
  }
278
279
  /// \returns True if kernel code properties metadata is not empty, false
280
  /// otherwise.
281
4.04k
  bool notEmpty() const {
282
510
    return mKernargSegmentSize || mWorkgroupGroupSegmentSize ||
283
504
           
mWorkitemPrivateSegmentSize504
||
mWavefrontNumSGPRs480
||
284
333
           
mWorkitemNumVGPRs333
||
mKernargSegmentAlign309
||
mGroupSegmentAlign222
||
285
222
           
mPrivateSegmentAlign222
||
mWavefrontSize222
;
286
4.04k
  }
287
};
288
289
} // end namespace CodeProps
290
291
//===----------------------------------------------------------------------===//
292
// Kernel Debug Properties Metadata.
293
//===----------------------------------------------------------------------===//
294
namespace DebugProps {
295
296
namespace Key {
297
/// \brief Key for Kernel::DebugProps::Metadata::mDebuggerABIVersion.
298
constexpr char DebuggerABIVersion[] = "DebuggerABIVersion";
299
/// \brief Key for Kernel::DebugProps::Metadata::mReservedNumVGPRs.
300
constexpr char ReservedNumVGPRs[] = "ReservedNumVGPRs";
301
/// \brief Key for Kernel::DebugProps::Metadata::mReservedFirstVGPR.
302
constexpr char ReservedFirstVGPR[] = "ReservedFirstVGPR";
303
/// \brief Key for Kernel::DebugProps::Metadata::mPrivateSegmentBufferSGPR.
304
constexpr char PrivateSegmentBufferSGPR[] = "PrivateSegmentBufferSGPR";
305
/// \brief Key for
306
///     Kernel::DebugProps::Metadata::mWavefrontPrivateSegmentOffsetSGPR.
307
constexpr char WavefrontPrivateSegmentOffsetSGPR[] =
308
    "WavefrontPrivateSegmentOffsetSGPR";
309
} // end namespace Key
310
311
/// \brief In-memory representation of kernel debug properties metadata.
312
struct Metadata final {
313
  /// \brief Debugger ABI version. Optional.
314
  std::vector<uint32_t> mDebuggerABIVersion = std::vector<uint32_t>();
315
  /// \brief Consecutive number of VGPRs reserved for debugger use. Must be 0 if
316
  /// mDebuggerABIVersion is not set. Optional.
317
  uint16_t mReservedNumVGPRs = 0;
318
  /// \brief First fixed VGPR reserved. Must be uint16_t(-1) if
319
  /// mDebuggerABIVersion is not set or mReservedFirstVGPR is 0. Optional.
320
  uint16_t mReservedFirstVGPR = uint16_t(-1);
321
  /// \brief Fixed SGPR of the first of 4 SGPRs used to hold the scratch V# used
322
  /// for the entire kernel execution. Must be uint16_t(-1) if
323
  /// mDebuggerABIVersion is not set or SGPR not used or not known. Optional.
324
  uint16_t mPrivateSegmentBufferSGPR = uint16_t(-1);
325
  /// \brief Fixed SGPR used to hold the wave scratch offset for the entire
326
  /// kernel execution. Must be uint16_t(-1) if mDebuggerABIVersion is not set
327
  /// or SGPR is not used or not known. Optional.
328
  uint16_t mWavefrontPrivateSegmentOffsetSGPR = uint16_t(-1);
329
330
  /// \brief Default constructor.
331
1.42k
  Metadata() = default;
332
333
  /// \returns True if kernel debug properties metadata is empty, false
334
  /// otherwise.
335
4.04k
  bool empty() const {
336
4.04k
    return !notEmpty();
337
4.04k
  }
338
339
  /// \returns True if kernel debug properties metadata is not empty, false
340
  /// otherwise.
341
4.04k
  bool notEmpty() const {
342
4.04k
    return !mDebuggerABIVersion.empty();
343
4.04k
  }
344
};
345
346
} // end namespace DebugProps
347
348
namespace Key {
349
/// \brief Key for Kernel::Metadata::mName.
350
constexpr char Name[] = "Name";
351
/// \brief Key for Kernel::Metadata::mLanguage.
352
constexpr char Language[] = "Language";
353
/// \brief Key for Kernel::Metadata::mLanguageVersion.
354
constexpr char LanguageVersion[] = "LanguageVersion";
355
/// \brief Key for Kernel::Metadata::mAttrs.
356
constexpr char Attrs[] = "Attrs";
357
/// \brief Key for Kernel::Metadata::mArgs.
358
constexpr char Args[] = "Args";
359
/// \brief Key for Kernel::Metadata::mCodeProps.
360
constexpr char CodeProps[] = "CodeProps";
361
/// \brief Key for Kernel::Metadata::mDebugProps.
362
constexpr char DebugProps[] = "DebugProps";
363
} // end namespace Key
364
365
/// \brief In-memory representation of kernel metadata.
366
struct Metadata final {
367
  /// \brief Name. Required.
368
  std::string mName = std::string();
369
  /// \brief Language. Optional.
370
  std::string mLanguage = std::string();
371
  /// \brief Language version. Optional.
372
  std::vector<uint32_t> mLanguageVersion = std::vector<uint32_t>();
373
  /// \brief Attributes metadata. Optional.
374
  Attrs::Metadata mAttrs = Attrs::Metadata();
375
  /// \brief Arguments metadata. Optional.
376
  std::vector<Arg::Metadata> mArgs = std::vector<Arg::Metadata>();
377
  /// \brief Code properties metadata. Optional.
378
  CodeProps::Metadata mCodeProps = CodeProps::Metadata();
379
  /// \brief Debug properties metadata. Optional.
380
  DebugProps::Metadata mDebugProps = DebugProps::Metadata();
381
382
  /// \brief Default constructor.
383
1.42k
  Metadata() = default;
384
};
385
386
} // end namespace Kernel
387
388
namespace Key {
389
/// \brief Key for CodeObject::Metadata::mVersion.
390
constexpr char Version[] = "Version";
391
/// \brief Key for CodeObject::Metadata::mPrintf.
392
constexpr char Printf[] = "Printf";
393
/// \brief Key for CodeObject::Metadata::mKernels.
394
constexpr char Kernels[] = "Kernels";
395
} // end namespace Key
396
397
/// \brief In-memory representation of code object metadata.
398
struct Metadata final {
399
  /// \brief Code object metadata version. Required.
400
  std::vector<uint32_t> mVersion = std::vector<uint32_t>();
401
  /// \brief Printf metadata. Optional.
402
  std::vector<std::string> mPrintf = std::vector<std::string>();
403
  /// \brief Kernels metadata. Optional.
404
  std::vector<Kernel::Metadata> mKernels = std::vector<Kernel::Metadata>();
405
406
  /// \brief Default constructor.
407
1.64k
  Metadata() = default;
408
409
  /// \brief Converts \p YamlString to \p CodeObjectMetadata.
410
  static std::error_code fromYamlString(std::string YamlString,
411
                                        Metadata &CodeObjectMetadata);
412
413
  /// \brief Converts \p CodeObjectMetadata to \p YamlString.
414
  static std::error_code toYamlString(Metadata CodeObjectMetadata,
415
                                      std::string &YamlString);
416
};
417
418
} // end namespace CodeObject
419
} // end namespace AMDGPU
420
} // end namespace llvm
421
422
#endif // LLVM_LIB_TARGET_AMDGPU_MCTARGETDESC_AMDGPUCODEOBJECTMETADATA_H