blob: 82b39ce61d5df578ad627db46c754c66cdb41795 [file] [log] [blame]
alan-bakerfec0a472018-11-08 18:09:40 -05001// Copyright 2018 The Clspv Authors. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15#include "clang/Basic/TargetInfo.h"
16#include "clang/CodeGen/CodeGenAction.h"
17#include "clang/Frontend/CompilerInstance.h"
18#include "clang/Frontend/FrontendPluginRegistry.h"
19#include "clang/Frontend/TextDiagnosticPrinter.h"
20#include "clang/Lex/PreprocessorOptions.h"
21#include "llvm/IR/LLVMContext.h"
22#include "llvm/IR/LegacyPassManager.h"
23#include "llvm/IR/Module.h"
24#include "llvm/IR/Verifier.h"
alan-baker0e64a592019-11-18 13:36:25 -050025#include "llvm/InitializePasses.h"
alan-bakerfec0a472018-11-08 18:09:40 -050026#include "llvm/LinkAllPasses.h"
alan-bakerf5e5f692018-11-27 08:33:24 -050027#include "llvm/Support/Allocator.h"
alan-bakerfec0a472018-11-08 18:09:40 -050028#include "llvm/Support/CommandLine.h"
alan-bakerf5e5f692018-11-27 08:33:24 -050029#include "llvm/Support/ErrorOr.h"
alan-bakerfec0a472018-11-08 18:09:40 -050030#include "llvm/Support/MathExtras.h"
alan-bakerf5e5f692018-11-27 08:33:24 -050031#include "llvm/Support/StringSaver.h"
Diego Novillo89500852019-04-15 08:45:10 -040032#include "llvm/Support/ToolOutputFile.h"
alan-bakerfec0a472018-11-08 18:09:40 -050033#include "llvm/Support/raw_ostream.h"
34#include "llvm/Transforms/IPO/PassManagerBuilder.h"
35
Kévin Petit38c52482019-05-07 20:28:00 +080036#include "clspv/AddressSpace.h"
alan-bakerf5e5f692018-11-27 08:33:24 -050037#include "clspv/DescriptorMap.h"
alan-bakerfec0a472018-11-08 18:09:40 -050038#include "clspv/Option.h"
39#include "clspv/Passes.h"
40#include "clspv/opencl_builtins_header.h"
41
42#include "FrontendPlugin.h"
Diego Novilloa4c44fa2019-04-11 10:56:15 -040043#include "Passes.h"
alan-bakerfec0a472018-11-08 18:09:40 -050044
alan-bakerf5e5f692018-11-27 08:33:24 -050045#include <cassert>
alan-bakerfec0a472018-11-08 18:09:40 -050046#include <numeric>
alan-bakerf5e5f692018-11-27 08:33:24 -050047#include <sstream>
Diego Novillo3cc8d7a2019-04-10 13:30:34 -040048#include <string>
alan-bakerfec0a472018-11-08 18:09:40 -050049
50using namespace clang;
51
52namespace {
53// This registration must be located in the same file as the execution of the
54// action.
55static FrontendPluginRegistry::Add<clspv::ExtraValidationASTAction>
56 X("extra-validation",
57 "Perform extra validation on OpenCL C when targeting Vulkan");
58
59static llvm::cl::opt<bool> cl_single_precision_constants(
60 "cl-single-precision-constant", llvm::cl::init(false),
61 llvm::cl::desc("Treat double precision floating-point constant as single "
62 "precision constant."));
63
64static llvm::cl::opt<bool> cl_denorms_are_zero(
65 "cl-denorms-are-zero", llvm::cl::init(false),
66 llvm::cl::desc("If specified, denormalized floating point numbers may be "
67 "flushed to zero."));
68
69static llvm::cl::opt<bool> cl_fp32_correctly_rounded_divide_sqrt(
70 "cl-fp32-correctly-rounded-divide-sqrt", llvm::cl::init(false),
71 llvm::cl::desc("Single precision floating-point divide (x/y and 1/x) and "
72 "sqrt used are correctly rounded."));
73
74static llvm::cl::opt<bool>
75 cl_opt_disable("cl-opt-disable", llvm::cl::init(false),
76 llvm::cl::desc("This option disables all optimizations. The "
77 "default is optimizations are enabled."));
78
79static llvm::cl::opt<bool> cl_mad_enable(
80 "cl-mad-enable", llvm::cl::init(false),
81 llvm::cl::desc("Allow a * b + c to be replaced by a mad. The mad computes "
82 "a * b + c with reduced accuracy."));
83
84static llvm::cl::opt<bool> cl_no_signed_zeros(
85 "cl-no-signed-zeros", llvm::cl::init(false),
86 llvm::cl::desc("Allow optimizations for floating-point arithmetic that "
87 "ignore the signedness of zero."));
88
89static llvm::cl::opt<bool> cl_unsafe_math_optimizations(
90 "cl-unsafe-math-optimizations", llvm::cl::init(false),
91 llvm::cl::desc("Allow optimizations for floating-point arithmetic that (a) "
92 "assume that arguments and results are valid, (b) may "
93 "violate IEEE 754 standard and (c) may violate the OpenCL "
94 "numerical compliance requirements. This option includes "
95 "the -cl-no-signed-zeros and -cl-mad-enable options."));
96
97static llvm::cl::opt<bool> cl_finite_math_only(
98 "cl-finite-math-only", llvm::cl::init(false),
99 llvm::cl::desc("Allow optimizations for floating-point arithmetic that "
100 "assume that arguments and results are not NaNs or INFs."));
101
102static llvm::cl::opt<bool> cl_fast_relaxed_math(
103 "cl-fast-relaxed-math", llvm::cl::init(false),
104 llvm::cl::desc("This option causes the preprocessor macro "
105 "__FAST_RELAXED_MATH__ to be defined. Sets the optimization "
106 "options -cl-finite-math-only and "
107 "-cl-unsafe-math-optimizations."));
108
109static llvm::cl::list<std::string>
110 Includes(llvm::cl::Prefix, "I",
111 llvm::cl::desc("Add a directory to the list of directories "
112 "to be searched for header files."),
113 llvm::cl::ZeroOrMore, llvm::cl::value_desc("include path"));
114
115static llvm::cl::list<std::string>
116 Defines(llvm::cl::Prefix, "D",
117 llvm::cl::desc("Define a #define directive."), llvm::cl::ZeroOrMore,
118 llvm::cl::value_desc("define"));
119
120static llvm::cl::opt<std::string>
121 InputFilename(llvm::cl::Positional, llvm::cl::desc("<input .cl file>"),
122 llvm::cl::init("-"));
123
Kévin Petitddad8f42019-09-30 15:12:08 +0100124static llvm::cl::opt<clang::Language> InputLanguage(
125 "x", llvm::cl::desc("Select input type"),
126 llvm::cl::init(clang::Language::OpenCL),
127 llvm::cl::values(clEnumValN(clang::Language::OpenCL, "cl", "OpenCL source"),
128 clEnumValN(clang::Language::LLVM_IR, "ir", "LLVM IR")));
129
alan-bakerfec0a472018-11-08 18:09:40 -0500130static llvm::cl::opt<std::string>
131 OutputFilename("o", llvm::cl::desc("Override output filename"),
132 llvm::cl::value_desc("filename"));
133
134static llvm::cl::opt<std::string>
135 DescriptorMapFilename("descriptormap",
136 llvm::cl::desc("Output file for descriptor map"),
137 llvm::cl::value_desc("filename"));
138
139static llvm::cl::opt<char>
140 OptimizationLevel(llvm::cl::Prefix, "O", llvm::cl::init('2'),
141 llvm::cl::desc("Optimization level to use"),
142 llvm::cl::value_desc("level"));
143
alan-bakerfec0a472018-11-08 18:09:40 -0500144static llvm::cl::opt<std::string> OutputFormat(
145 "mfmt", llvm::cl::init(""),
146 llvm::cl::desc(
147 "Specify special output format. 'c' is as a C initializer list"),
148 llvm::cl::value_desc("format"));
149
150static llvm::cl::opt<std::string>
alan-baker09cb9802019-12-10 13:16:27 -0500151 SamplerMap("samplermap", llvm::cl::desc("DEPRECATED - Literal sampler map"),
alan-bakerfec0a472018-11-08 18:09:40 -0500152 llvm::cl::value_desc("filename"));
153
154static llvm::cl::opt<bool> cluster_non_pointer_kernel_args(
155 "cluster-pod-kernel-args", llvm::cl::init(false),
156 llvm::cl::desc("Collect plain-old-data kernel arguments into a struct in "
157 "a single storage buffer, using a binding number after "
158 "other arguments. Use this to reduce storage buffer "
159 "descriptors."));
160
161static llvm::cl::opt<bool> verify("verify", llvm::cl::init(false),
162 llvm::cl::desc("Verify diagnostic outputs"));
163
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100164static llvm::cl::opt<bool>
165 IgnoreWarnings("w", llvm::cl::init(false),
166 llvm::cl::desc("Disable all warnings"));
167
168static llvm::cl::opt<bool>
169 WarningsAsErrors("Werror", llvm::cl::init(false),
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400170 llvm::cl::desc("Turn warnings into errors"));
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100171
Diego Novillo89500852019-04-15 08:45:10 -0400172static llvm::cl::opt<std::string> IROutputFile(
173 "emit-ir",
174 llvm::cl::desc(
175 "Emit LLVM IR to the given file after parsing and stop compilation."),
176 llvm::cl::value_desc("filename"));
177
alan-bakerfec0a472018-11-08 18:09:40 -0500178// Populates |SamplerMapEntries| with data from the input sampler map. Returns 0
179// if successful.
alan-bakerf5e5f692018-11-27 08:33:24 -0500180int ParseSamplerMap(const std::string &sampler_map,
181 llvm::SmallVectorImpl<std::pair<unsigned, std::string>>
182 *SamplerMapEntries) {
183 std::unique_ptr<llvm::MemoryBuffer> samplerMapBuffer(nullptr);
184 if (!sampler_map.empty()) {
185 // Parse the sampler map from the provided string.
186 samplerMapBuffer = llvm::MemoryBuffer::getMemBuffer(sampler_map);
187
alan-baker09cb9802019-12-10 13:16:27 -0500188 clspv::Option::SetUseSamplerMap(true);
alan-bakerf5e5f692018-11-27 08:33:24 -0500189 if (!SamplerMap.empty()) {
190 llvm::outs() << "Warning: -samplermap is ignored when the sampler map is "
191 "provided through a string.\n";
192 }
193 } else if (!SamplerMap.empty()) {
194 // Parse the sampler map from the option provided file.
alan-bakerfec0a472018-11-08 18:09:40 -0500195 auto errorOrSamplerMapFile =
196 llvm::MemoryBuffer::getFile(SamplerMap.getValue());
197
198 // If there was an error in getting the sampler map file.
199 if (!errorOrSamplerMapFile) {
200 llvm::errs() << "Error: " << errorOrSamplerMapFile.getError().message()
201 << " '" << SamplerMap.getValue() << "'\n";
202 return -1;
203 }
204
alan-baker09cb9802019-12-10 13:16:27 -0500205 clspv::Option::SetUseSamplerMap(true);
alan-bakerf5e5f692018-11-27 08:33:24 -0500206 samplerMapBuffer = std::move(errorOrSamplerMapFile.get());
alan-bakerfec0a472018-11-08 18:09:40 -0500207 if (0 == samplerMapBuffer->getBufferSize()) {
208 llvm::errs() << "Error: Sampler map was an empty file!\n";
209 return -1;
210 }
alan-bakerf5e5f692018-11-27 08:33:24 -0500211 }
alan-bakerfec0a472018-11-08 18:09:40 -0500212
alan-baker09cb9802019-12-10 13:16:27 -0500213 if (clspv::Option::UseSamplerMap()) {
214 llvm::outs()
215 << "Warning: use of the sampler map is deprecated and unnecessary\n";
216 }
217
alan-bakerf5e5f692018-11-27 08:33:24 -0500218 // No sampler map to parse.
219 if (!samplerMapBuffer || 0 == samplerMapBuffer->getBufferSize())
220 return 0;
alan-bakerfec0a472018-11-08 18:09:40 -0500221
alan-bakerf5e5f692018-11-27 08:33:24 -0500222 llvm::SmallVector<llvm::StringRef, 3> samplerStrings;
alan-bakerfec0a472018-11-08 18:09:40 -0500223
alan-bakerf5e5f692018-11-27 08:33:24 -0500224 // We need to keep track of the beginning of the current entry.
225 const char *b = samplerMapBuffer->getBufferStart();
226 for (const char *i = b, *e = samplerMapBuffer->getBufferEnd();; i++) {
227 // If we have a separator between declarations.
228 if ((*i == '|') || (*i == ',') || (i == e)) {
229 if (i == b) {
230 llvm::errs() << "Error: Sampler map contained an empty entry!\n";
231 return -1;
alan-bakerfec0a472018-11-08 18:09:40 -0500232 }
233
alan-bakerf5e5f692018-11-27 08:33:24 -0500234 samplerStrings.push_back(llvm::StringRef(b, i - b).trim());
alan-bakerfec0a472018-11-08 18:09:40 -0500235
alan-bakerf5e5f692018-11-27 08:33:24 -0500236 // And set b the next character after i.
237 b = i + 1;
238 }
alan-bakerfec0a472018-11-08 18:09:40 -0500239
alan-bakerf5e5f692018-11-27 08:33:24 -0500240 // If we have a separator between declarations within a single sampler.
241 if ((*i == ',') || (i == e)) {
242 enum NormalizedCoords {
243 CLK_NORMALIZED_COORDS_FALSE = 0x00,
244 CLK_NORMALIZED_COORDS_TRUE = 0x01,
245 CLK_NORMALIZED_COORDS_NOT_SET
246 } NormalizedCoord = CLK_NORMALIZED_COORDS_NOT_SET;
alan-bakerfec0a472018-11-08 18:09:40 -0500247
alan-bakerf5e5f692018-11-27 08:33:24 -0500248 enum AddressingModes {
249 CLK_ADDRESS_NONE = 0x00,
250 CLK_ADDRESS_CLAMP_TO_EDGE = 0x02,
251 CLK_ADDRESS_CLAMP = 0x04,
252 CLK_ADDRESS_MIRRORED_REPEAT = 0x08,
253 CLK_ADDRESS_REPEAT = 0x06,
254 CLK_ADDRESS_NOT_SET
255 } AddressingMode = CLK_ADDRESS_NOT_SET;
256
257 enum FilterModes {
258 CLK_FILTER_NEAREST = 0x10,
259 CLK_FILTER_LINEAR = 0x20,
260 CLK_FILTER_NOT_SET
261 } FilterMode = CLK_FILTER_NOT_SET;
262
263 for (auto str : samplerStrings) {
264 if ("CLK_NORMALIZED_COORDS_FALSE" == str) {
265 if (CLK_NORMALIZED_COORDS_NOT_SET != NormalizedCoord) {
266 llvm::errs() << "Error: Sampler map normalized coordinates was "
267 "previously set!\n";
alan-bakerfec0a472018-11-08 18:09:40 -0500268 return -1;
269 }
alan-bakerf5e5f692018-11-27 08:33:24 -0500270 NormalizedCoord = CLK_NORMALIZED_COORDS_FALSE;
271 } else if ("CLK_NORMALIZED_COORDS_TRUE" == str) {
272 if (CLK_NORMALIZED_COORDS_NOT_SET != NormalizedCoord) {
273 llvm::errs() << "Error: Sampler map normalized coordinates was "
274 "previously set!\n";
275 return -1;
276 }
277 NormalizedCoord = CLK_NORMALIZED_COORDS_TRUE;
278 } else if ("CLK_ADDRESS_NONE" == str) {
279 if (CLK_ADDRESS_NOT_SET != AddressingMode) {
280 llvm::errs()
281 << "Error: Sampler map addressing mode was previously set!\n";
282 return -1;
283 }
284 AddressingMode = CLK_ADDRESS_NONE;
285 } else if ("CLK_ADDRESS_CLAMP_TO_EDGE" == str) {
286 if (CLK_ADDRESS_NOT_SET != AddressingMode) {
287 llvm::errs()
288 << "Error: Sampler map addressing mode was previously set!\n";
289 return -1;
290 }
291 AddressingMode = CLK_ADDRESS_CLAMP_TO_EDGE;
292 } else if ("CLK_ADDRESS_CLAMP" == str) {
293 if (CLK_ADDRESS_NOT_SET != AddressingMode) {
294 llvm::errs()
295 << "Error: Sampler map addressing mode was previously set!\n";
296 return -1;
297 }
298 AddressingMode = CLK_ADDRESS_CLAMP;
299 } else if ("CLK_ADDRESS_MIRRORED_REPEAT" == str) {
300 if (CLK_ADDRESS_NOT_SET != AddressingMode) {
301 llvm::errs()
302 << "Error: Sampler map addressing mode was previously set!\n";
303 return -1;
304 }
305 AddressingMode = CLK_ADDRESS_MIRRORED_REPEAT;
306 } else if ("CLK_ADDRESS_REPEAT" == str) {
307 if (CLK_ADDRESS_NOT_SET != AddressingMode) {
308 llvm::errs()
309 << "Error: Sampler map addressing mode was previously set!\n";
310 return -1;
311 }
312 AddressingMode = CLK_ADDRESS_REPEAT;
313 } else if ("CLK_FILTER_NEAREST" == str) {
314 if (CLK_FILTER_NOT_SET != FilterMode) {
315 llvm::errs()
316 << "Error: Sampler map filtering mode was previously set!\n";
317 return -1;
318 }
319 FilterMode = CLK_FILTER_NEAREST;
320 } else if ("CLK_FILTER_LINEAR" == str) {
321 if (CLK_FILTER_NOT_SET != FilterMode) {
322 llvm::errs()
323 << "Error: Sampler map filtering mode was previously set!\n";
324 return -1;
325 }
326 FilterMode = CLK_FILTER_LINEAR;
327 } else {
328 llvm::errs() << "Error: Unknown sampler string '" << str
329 << "' found!\n";
alan-bakerfec0a472018-11-08 18:09:40 -0500330 return -1;
331 }
alan-bakerfec0a472018-11-08 18:09:40 -0500332 }
333
alan-bakerf5e5f692018-11-27 08:33:24 -0500334 if (CLK_NORMALIZED_COORDS_NOT_SET == NormalizedCoord) {
335 llvm::errs() << "Error: Sampler map entry did not contain normalized "
336 "coordinates entry!\n";
337 return -1;
alan-bakerfec0a472018-11-08 18:09:40 -0500338 }
alan-bakerf5e5f692018-11-27 08:33:24 -0500339
340 if (CLK_ADDRESS_NOT_SET == AddressingMode) {
341 llvm::errs() << "Error: Sampler map entry did not contain addressing "
342 "mode entry!\n";
343 return -1;
344 }
345
346 if (CLK_FILTER_NOT_SET == FilterMode) {
347 llvm::errs()
348 << "Error: Sampler map entry did not contain filer mode entry!\n";
349 return -1;
350 }
351
352 // Generate an equivalent expression in string form. Sort the
353 // strings to get a canonical ordering.
354 std::sort(samplerStrings.begin(), samplerStrings.end(),
355 std::less<StringRef>());
356 const auto samplerExpr = std::accumulate(
357 samplerStrings.begin(), samplerStrings.end(), std::string(),
358 [](std::string left, std::string right) {
359 return left + std::string(left.empty() ? "" : "|") + right;
360 });
361
362 // SamplerMapEntries->push_back(std::make_pair(
363 // NormalizedCoord | AddressingMode | FilterMode, samplerExpr));
364 SamplerMapEntries->emplace_back(
365 NormalizedCoord | AddressingMode | FilterMode, samplerExpr);
366
367 // And reset the sampler strings for the next sampler in the map.
368 samplerStrings.clear();
369 }
370
371 // And lastly, if we are at the end of the file
372 if (i == e) {
373 break;
alan-bakerfec0a472018-11-08 18:09:40 -0500374 }
375 }
376
377 return 0;
378}
379
380// Sets |instance|'s options for compiling. Returns 0 if successful.
381int SetCompilerInstanceOptions(CompilerInstance &instance,
382 const llvm::StringRef &overiddenInputFilename,
383 const clang::FrontendInputFile &kernelFile,
alan-bakerf5e5f692018-11-27 08:33:24 -0500384 const std::string &program,
alan-bakerfec0a472018-11-08 18:09:40 -0500385 llvm::raw_string_ostream *diagnosticsStream) {
alan-bakerf5e5f692018-11-27 08:33:24 -0500386 std::unique_ptr<llvm::MemoryBuffer> memory_buffer(nullptr);
387 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> errorOrInputFile(nullptr);
388 if (program.empty()) {
389 auto errorOrInputFile =
390 llvm::MemoryBuffer::getFileOrSTDIN(InputFilename.getValue());
alan-bakerfec0a472018-11-08 18:09:40 -0500391
alan-bakerf5e5f692018-11-27 08:33:24 -0500392 // If there was an error in getting the input file.
393 if (!errorOrInputFile) {
394 llvm::errs() << "Error: " << errorOrInputFile.getError().message() << " '"
395 << InputFilename.getValue() << "'\n";
396 return -1;
397 }
398 memory_buffer.reset(errorOrInputFile.get().release());
399 } else {
400 memory_buffer = llvm::MemoryBuffer::getMemBuffer(program.c_str(),
401 overiddenInputFilename);
alan-bakerfec0a472018-11-08 18:09:40 -0500402 }
alan-bakerf5e5f692018-11-27 08:33:24 -0500403
alan-bakerfec0a472018-11-08 18:09:40 -0500404 if (verify) {
405 instance.getDiagnosticOpts().VerifyDiagnostics = true;
alan-bakerbccf62c2019-03-29 10:32:41 -0400406 instance.getDiagnosticOpts().VerifyPrefixes.push_back("expected");
alan-bakerfec0a472018-11-08 18:09:40 -0500407 }
408
Kévin Petit0fc88042019-04-09 23:25:02 +0100409 clang::LangStandard::Kind standard;
410 if (clspv::Option::CPlusPlus()) {
411 standard = clang::LangStandard::lang_openclcpp;
412 } else {
413 standard = clang::LangStandard::lang_opencl12;
414 }
alan-bakerfec0a472018-11-08 18:09:40 -0500415
416 // We are targeting OpenCL 1.2 only
417 instance.getLangOpts().OpenCLVersion = 120;
418
419 instance.getLangOpts().C99 = true;
420 instance.getLangOpts().RTTI = false;
421 instance.getLangOpts().RTTIData = false;
422 instance.getLangOpts().MathErrno = false;
423 instance.getLangOpts().Optimize = false;
424 instance.getLangOpts().NoBuiltin = true;
425 instance.getLangOpts().ModulesSearchAll = false;
426 instance.getLangOpts().SinglePrecisionConstants = true;
427 instance.getCodeGenOpts().StackRealignment = true;
428 instance.getCodeGenOpts().SimplifyLibCalls = false;
429 instance.getCodeGenOpts().EmitOpenCLArgMetadata = false;
430 instance.getCodeGenOpts().DisableO0ImplyOptNone = true;
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100431 instance.getDiagnosticOpts().IgnoreWarnings = IgnoreWarnings;
alan-bakerfec0a472018-11-08 18:09:40 -0500432
433 instance.getLangOpts().SinglePrecisionConstants =
434 cl_single_precision_constants;
435 // cl_denorms_are_zero ignored for now!
436 // cl_fp32_correctly_rounded_divide_sqrt ignored for now!
437 instance.getCodeGenOpts().LessPreciseFPMAD =
438 cl_mad_enable || cl_unsafe_math_optimizations;
439 // cl_no_signed_zeros ignored for now!
440 instance.getCodeGenOpts().UnsafeFPMath =
441 cl_unsafe_math_optimizations || cl_fast_relaxed_math;
442 instance.getLangOpts().FiniteMathOnly =
443 cl_finite_math_only || cl_fast_relaxed_math;
444 instance.getLangOpts().FastRelaxedMath = cl_fast_relaxed_math;
445
446 // Preprocessor options
Kévin Petita624c0c2019-05-07 20:27:43 +0800447 if (!clspv::Option::ImageSupport()) {
448 instance.getPreprocessorOpts().addMacroUndef("__IMAGE_SUPPORT__");
449 }
alan-bakerfec0a472018-11-08 18:09:40 -0500450 if (cl_fast_relaxed_math) {
451 instance.getPreprocessorOpts().addMacroDef("__FAST_RELAXED_MATH__");
452 }
453
454 for (auto define : Defines) {
455 instance.getPreprocessorOpts().addMacroDef(define);
456 }
457
458 // Header search options
459 for (auto include : Includes) {
460 instance.getHeaderSearchOpts().AddPath(include, clang::frontend::After,
461 false, false);
462 }
463
464 // We always compile on opt 0 so we preserve as much debug information about
465 // the source as possible. We'll run optimization later, once we've had a
466 // chance to view the unoptimal code first
467 instance.getCodeGenOpts().OptimizationLevel = 0;
468
469// Debug information is disabled temporarily to call instruction.
470#if 0
471 instance.getCodeGenOpts().setDebugInfo(clang::codegenoptions::FullDebugInfo);
472#endif
473
474 // We use the 32-bit pointer-width SPIR triple
475 llvm::Triple triple("spir-unknown-unknown");
476
477 instance.getInvocation().setLangDefaults(
alan-bakerd354f1a2019-08-06 15:41:55 -0400478 instance.getLangOpts(), clang::InputKind(clang::Language::OpenCL), triple,
alan-bakerfec0a472018-11-08 18:09:40 -0500479 instance.getPreprocessorOpts(), standard);
480
481 // Override the C99 inline semantics to accommodate for more OpenCL C
482 // programs in the wild.
483 instance.getLangOpts().GNUInline = true;
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100484
485 // Set up diagnostics
alan-bakerfec0a472018-11-08 18:09:40 -0500486 instance.createDiagnostics(
487 new clang::TextDiagnosticPrinter(*diagnosticsStream,
488 &instance.getDiagnosticOpts()),
489 true);
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100490 instance.getDiagnostics().setWarningsAsErrors(WarningsAsErrors);
491 instance.getDiagnostics().setEnableAllWarnings(true);
alan-bakerfec0a472018-11-08 18:09:40 -0500492
493 instance.getTargetOpts().Triple = triple.str();
494
495 instance.getCodeGenOpts().MainFileName = overiddenInputFilename;
496 instance.getCodeGenOpts().PreserveVec3Type = true;
497 // Disable generation of lifetime intrinsic.
498 instance.getCodeGenOpts().DisableLifetimeMarkers = true;
499 instance.getFrontendOpts().Inputs.push_back(kernelFile);
alan-bakerf5e5f692018-11-27 08:33:24 -0500500 instance.getPreprocessorOpts().addRemappedFile(overiddenInputFilename,
501 memory_buffer.release());
alan-bakerfec0a472018-11-08 18:09:40 -0500502
503 struct OpenCLBuiltinMemoryBuffer final : public llvm::MemoryBuffer {
504 OpenCLBuiltinMemoryBuffer(const void *data, uint64_t data_length) {
505 const char *dataCasted = reinterpret_cast<const char *>(data);
506 init(dataCasted, dataCasted + data_length, true);
507 }
508
509 virtual llvm::MemoryBuffer::BufferKind getBufferKind() const override {
510 return llvm::MemoryBuffer::MemoryBuffer_Malloc;
511 }
512
513 virtual ~OpenCLBuiltinMemoryBuffer() override {}
514 };
515
516 std::unique_ptr<llvm::MemoryBuffer> openCLBuiltinMemoryBuffer(
517 new OpenCLBuiltinMemoryBuffer(opencl_builtins_header_data,
518 opencl_builtins_header_size - 1));
519
520 instance.getPreprocessorOpts().Includes.push_back("openclc.h");
521
alan-bakerf3bce4a2019-06-28 16:01:15 -0400522 std::unique_ptr<llvm::MemoryBuffer> openCLBaseBuiltinMemoryBuffer(
523 new OpenCLBuiltinMemoryBuffer(opencl_base_builtins_header_data,
524 opencl_base_builtins_header_size - 1));
525
526 instance.getPreprocessorOpts().Includes.push_back("opencl-c-base.h");
527
alan-bakerfec0a472018-11-08 18:09:40 -0500528 // Add the VULKAN macro.
529 instance.getPreprocessorOpts().addMacroDef("VULKAN=100");
530
531 // Add the __OPENCL_VERSION__ macro.
532 instance.getPreprocessorOpts().addMacroDef("__OPENCL_VERSION__=120");
533
534 instance.setTarget(clang::TargetInfo::CreateTargetInfo(
535 instance.getDiagnostics(),
536 std::make_shared<clang::TargetOptions>(instance.getTargetOpts())));
537
538 instance.createFileManager();
539 instance.createSourceManager(instance.getFileManager());
540
541#ifdef _MSC_VER
542 std::string includePrefix("include\\");
543#else
544 std::string includePrefix("include/");
545#endif
546
547 auto entry = instance.getFileManager().getVirtualFile(
548 includePrefix + "openclc.h", openCLBuiltinMemoryBuffer->getBufferSize(),
549 0);
550
551 instance.getSourceManager().overrideFileContents(
552 entry, std::move(openCLBuiltinMemoryBuffer));
553
alan-bakerf3bce4a2019-06-28 16:01:15 -0400554 auto base_entry = instance.getFileManager().getVirtualFile(
555 includePrefix + "opencl-c-base.h",
556 openCLBaseBuiltinMemoryBuffer->getBufferSize(), 0);
557
558 instance.getSourceManager().overrideFileContents(
559 base_entry, std::move(openCLBaseBuiltinMemoryBuffer));
560
alan-bakerfec0a472018-11-08 18:09:40 -0500561 return 0;
562}
563
alan-bakerf5e5f692018-11-27 08:33:24 -0500564// Populates |pm| with necessary passes to optimize and legalize the IR.
565int PopulatePassManager(
566 llvm::legacy::PassManager *pm, llvm::raw_svector_ostream *binaryStream,
567 std::vector<clspv::version0::DescriptorMapEntry> *descriptor_map_entries,
568 llvm::SmallVectorImpl<std::pair<unsigned, std::string>>
569 *SamplerMapEntries) {
alan-bakerfec0a472018-11-08 18:09:40 -0500570 llvm::PassManagerBuilder pmBuilder;
571
572 switch (OptimizationLevel) {
573 case '0':
alan-bakerf5e5f692018-11-27 08:33:24 -0500574 case '1':
575 case '2':
576 case '3':
577 case 's':
578 case 'z':
579 break;
580 default:
581 llvm::errs() << "Unknown optimization level -O" << OptimizationLevel
582 << " specified!\n";
583 return -1;
584 }
585
586 switch (OptimizationLevel) {
587 case '0':
alan-bakerfec0a472018-11-08 18:09:40 -0500588 pmBuilder.OptLevel = 0;
589 break;
590 case '1':
591 pmBuilder.OptLevel = 1;
592 break;
593 case '2':
594 pmBuilder.OptLevel = 2;
595 break;
596 case '3':
597 pmBuilder.OptLevel = 3;
598 break;
599 case 's':
600 pmBuilder.SizeLevel = 1;
601 break;
602 case 'z':
603 pmBuilder.SizeLevel = 2;
604 break;
605 default:
606 break;
607 }
608
609 pm->add(clspv::createZeroInitializeAllocasPass());
610 pm->add(clspv::createDefineOpenCLWorkItemBuiltinsPass());
611
612 if (0 < pmBuilder.OptLevel) {
613 pm->add(clspv::createOpenCLInlinerPass());
614 }
615
616 pm->add(clspv::createUndoByvalPass());
617 pm->add(clspv::createUndoSRetPass());
618 if (cluster_non_pointer_kernel_args) {
619 pm->add(clspv::createClusterPodKernelArgumentsPass());
620 }
621 pm->add(clspv::createReplaceOpenCLBuiltinPass());
622
623 // We need to run mem2reg and inst combine early because our
624 // createInlineFuncWithPointerBitCastArgPass pass cannot handle the pattern
625 // %1 = alloca i32 1
626 // store <something> %1
627 // %2 = bitcast float* %1
628 // %3 = load float %2
629 pm->add(llvm::createPromoteMemoryToRegisterPass());
630
alan-baker1b13e8f2019-08-08 17:56:51 -0400631 // Try to deal with pointer bitcasts early. This can prevent problems like
632 // issue #409 where LLVM is looser about access chain addressing than SPIR-V.
633 // This needs to happen before instcombine and after replacing OpenCL
634 // builtins. This run of the pass will not handle all pointer bitcasts that
635 // could be handled. It should be run again after other optimizations (e.g
636 // InlineFuncWithPointerBitCastArgPass).
637 pm->add(clspv::createSimplifyPointerBitcastPass());
638 pm->add(clspv::createReplacePointerBitcastPass());
639 pm->add(llvm::createDeadCodeEliminationPass());
640
alan-bakerfec0a472018-11-08 18:09:40 -0500641 // Hide loads from __constant address space away from instcombine.
642 // This prevents us from generating select between pointers-to-__constant.
643 // See https://github.com/google/clspv/issues/71
644 pm->add(clspv::createHideConstantLoadsPass());
645
646 pm->add(llvm::createInstructionCombiningPass());
647
648 if (clspv::Option::InlineEntryPoints()) {
649 pm->add(clspv::createInlineEntryPointsPass());
650 } else {
651 pm->add(clspv::createInlineFuncWithPointerBitCastArgPass());
652 pm->add(clspv::createInlineFuncWithPointerToFunctionArgPass());
653 pm->add(clspv::createInlineFuncWithSingleCallSitePass());
654 }
655
Kévin Petit0fc88042019-04-09 23:25:02 +0100656 if (clspv::Option::CPlusPlus()) {
Kévin Petit38c52482019-05-07 20:28:00 +0800657 pm->add(llvm::createInferAddressSpacesPass(clspv::AddressSpace::Generic));
Kévin Petit0fc88042019-04-09 23:25:02 +0100658 }
659
alan-bakerfec0a472018-11-08 18:09:40 -0500660 if (0 == pmBuilder.OptLevel) {
661 // Mem2Reg pass should be run early because O0 level optimization leaves
662 // redundant alloca, load and store instructions from function arguments.
663 // clspv needs to remove them ahead of transformation.
664 pm->add(llvm::createPromoteMemoryToRegisterPass());
665
666 // SROA pass is run because it will fold structs/unions that are problematic
667 // on Vulkan SPIR-V away.
668 pm->add(llvm::createSROAPass());
669
670 // InstructionCombining pass folds bitcast and gep instructions which are
671 // not supported by Vulkan SPIR-V.
672 pm->add(llvm::createInstructionCombiningPass());
673 }
674
675 // Now we add any of the LLVM optimizations we wanted
676 pmBuilder.populateModulePassManager(*pm);
677
678 // Unhide loads from __constant address space. Undoes the action of
679 // HideConstantLoadsPass.
680 pm->add(clspv::createUnhideConstantLoadsPass());
681
682 pm->add(clspv::createFunctionInternalizerPass());
683 pm->add(clspv::createReplaceLLVMIntrinsicsPass());
684 pm->add(clspv::createUndoBoolPass());
685 pm->add(clspv::createUndoTruncatedSwitchConditionPass());
686 pm->add(llvm::createStructurizeCFGPass(false));
alan-baker3fa76d92018-11-12 14:54:40 -0500687 // Must be run after structurize cfg.
alan-bakerfec0a472018-11-08 18:09:40 -0500688 pm->add(clspv::createReorderBasicBlocksPass());
689 pm->add(clspv::createUndoGetElementPtrConstantExprPass());
690 pm->add(clspv::createSplatArgPass());
691 pm->add(clspv::createSimplifyPointerBitcastPass());
692 pm->add(clspv::createReplacePointerBitcastPass());
693
694 pm->add(clspv::createUndoTranslateSamplerFoldPass());
695
696 if (clspv::Option::ModuleConstantsInStorageBuffer()) {
697 pm->add(clspv::createClusterModuleScopeConstantVars());
698 }
699
700 pm->add(clspv::createShareModuleScopeVariablesPass());
alan-bakerf67468c2019-11-25 15:51:49 -0500701 // Specialize images before assigning descriptors to disambiguate the various
702 // types.
703 pm->add(clspv::createSpecializeImageTypesPass());
alan-bakere9308012019-03-15 10:25:13 -0400704 // This should be run after LLVM and OpenCL intrinsics are replaced.
alan-bakerfec0a472018-11-08 18:09:40 -0500705 pm->add(clspv::createAllocateDescriptorsPass(*SamplerMapEntries));
706 pm->add(llvm::createVerifierPass());
707 pm->add(clspv::createDirectResourceAccessPass());
708 // Replacing pointer bitcasts can leave some trivial GEPs
709 // that are easy to remove. Also replace GEPs of GEPS
710 // left by replacing indirect buffer accesses.
711 pm->add(clspv::createSimplifyPointerBitcastPass());
alan-baker4217b322019-03-06 08:56:12 -0500712 // Run after DRA to clean up parameters and help reduce the need for variable
713 // pointers.
714 pm->add(clspv::createRemoveUnusedArgumentsPass());
alan-bakerfec0a472018-11-08 18:09:40 -0500715
716 pm->add(clspv::createSplatSelectConditionPass());
717 pm->add(clspv::createSignedCompareFixupPass());
718 // This pass generates insertions that need to be rewritten.
719 pm->add(clspv::createScalarizePass());
720 pm->add(clspv::createRewriteInsertsPass());
alan-bakera71f1932019-04-11 11:04:34 -0400721 // UBO Transformations
722 if (clspv::Option::ConstantArgsInUniformBuffer() &&
723 !clspv::Option::InlineEntryPoints()) {
724 // MultiVersionUBOFunctionsPass will examine non-kernel functions with UBO
725 // arguments and either multi-version them as necessary or inline them if
726 // multi-versioning cannot be accomplished.
727 pm->add(clspv::createMultiVersionUBOFunctionsPass());
728 // Cleanup passes.
729 // Specialization can blindly generate GEP chains that are easily cleaned up
730 // by SimplifyPointerBitcastPass.
731 pm->add(clspv::createSimplifyPointerBitcastPass());
732 // RemoveUnusedArgumentsPass removes the actual UBO arguments that were
733 // problematic to begin with now that they have no uses.
734 pm->add(clspv::createRemoveUnusedArgumentsPass());
735 // DCE cleans up callers of the specialized functions.
736 pm->add(llvm::createDeadCodeEliminationPass());
737 }
alan-bakerfec0a472018-11-08 18:09:40 -0500738 // This pass mucks with types to point where you shouldn't rely on DataLayout
739 // anymore so leave this right before SPIR-V generation.
740 pm->add(clspv::createUBOTypeTransformPass());
alan-baker00e7a582019-06-07 12:54:21 -0400741 pm->add(clspv::createSPIRVProducerPass(*binaryStream, descriptor_map_entries,
742 *SamplerMapEntries,
743 OutputFormat == "c"));
alan-bakerf5e5f692018-11-27 08:33:24 -0500744
745 return 0;
alan-bakerfec0a472018-11-08 18:09:40 -0500746}
alan-bakerfec0a472018-11-08 18:09:40 -0500747
Kévin Petitd5db2d22019-04-04 13:55:14 +0100748int ParseOptions(const int argc, const char *const argv[]) {
alan-bakerfec0a472018-11-08 18:09:40 -0500749 // We need to change how one of the called passes works by spoofing
750 // ParseCommandLineOptions with the specific option.
751 const int llvmArgc = 2;
752 const char *llvmArgv[llvmArgc] = {
alan-bakerf5e5f692018-11-27 08:33:24 -0500753 argv[0],
754 "-simplifycfg-sink-common=false",
alan-bakerfec0a472018-11-08 18:09:40 -0500755 };
756
Kévin Petitd5db2d22019-04-04 13:55:14 +0100757 llvm::cl::ResetAllOptionOccurrences();
alan-bakerfec0a472018-11-08 18:09:40 -0500758 llvm::cl::ParseCommandLineOptions(llvmArgc, llvmArgv);
alan-bakerfec0a472018-11-08 18:09:40 -0500759 llvm::cl::ParseCommandLineOptions(argc, argv);
760
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400761 if (clspv::Option::CPlusPlus() && !clspv::Option::InlineEntryPoints()) {
Kévin Petit0fc88042019-04-09 23:25:02 +0100762 llvm::errs() << "cannot use -c++ without -inline-entry-points\n";
763 return -1;
764 }
765
Kévin Petitd5db2d22019-04-04 13:55:14 +0100766 return 0;
767}
Diego Novillo89500852019-04-15 08:45:10 -0400768
769int GenerateIRFile(llvm::legacy::PassManager *pm, llvm::Module &module,
770 std::string output) {
771 std::error_code ec;
772 std::unique_ptr<llvm::ToolOutputFile> out(
773 new llvm::ToolOutputFile(output, ec, llvm::sys::fs::F_None));
774 if (ec) {
775 llvm::errs() << output << ": " << ec.message() << '\n';
776 return -1;
777 }
778 pm->add(llvm::createPrintModulePass(out->os(), "", false));
779 pm->run(module);
780 out->keep();
781 return 0;
782}
783
Kévin Petitd5db2d22019-04-04 13:55:14 +0100784} // namespace
785
786namespace clspv {
787int Compile(const int argc, const char *const argv[]) {
788
789 if (auto error = ParseOptions(argc, argv))
790 return error;
791
alan-bakerfec0a472018-11-08 18:09:40 -0500792 llvm::SmallVector<std::pair<unsigned, std::string>, 8> SamplerMapEntries;
alan-bakerf5e5f692018-11-27 08:33:24 -0500793 if (auto error = ParseSamplerMap("", &SamplerMapEntries))
alan-bakerfec0a472018-11-08 18:09:40 -0500794 return error;
795
796 // if no output file was provided, use a default
797 llvm::StringRef overiddenInputFilename = InputFilename.getValue();
798
799 // If we are reading our input file from stdin.
800 if ("-" == InputFilename) {
801 // We need to overwrite the file name we use.
Kévin Petitddad8f42019-09-30 15:12:08 +0100802 switch (InputLanguage) {
803 case clang::Language::OpenCL:
804 overiddenInputFilename = "stdin.cl";
805 break;
806 case clang::Language::LLVM_IR:
807 overiddenInputFilename = "stdin.ll";
808 break;
alan-baker31298a62019-10-07 13:24:30 -0400809 default:
810 // Default to fix compiler warnings/errors. Option parsing will reject a
811 // bad enum value for the option so there is no need for a message.
812 return -1;
Kévin Petitddad8f42019-09-30 15:12:08 +0100813 }
alan-bakerfec0a472018-11-08 18:09:40 -0500814 }
815
816 clang::CompilerInstance instance;
Kévin Petitddad8f42019-09-30 15:12:08 +0100817 clang::FrontendInputFile kernelFile(overiddenInputFilename,
818 clang::InputKind(InputLanguage));
alan-bakerfec0a472018-11-08 18:09:40 -0500819 std::string log;
820 llvm::raw_string_ostream diagnosticsStream(log);
alan-bakerf5e5f692018-11-27 08:33:24 -0500821 if (auto error = SetCompilerInstanceOptions(
822 instance, overiddenInputFilename, kernelFile, "", &diagnosticsStream))
alan-bakerfec0a472018-11-08 18:09:40 -0500823 return error;
824
825 // Parse.
826 llvm::LLVMContext context;
827 clang::EmitLLVMOnlyAction action(&context);
828
829 // Prepare the action for processing kernelFile
830 const bool success = action.BeginSourceFile(instance, kernelFile);
831 if (!success) {
832 return -1;
833 }
834
alan-bakerf3bce4a2019-06-28 16:01:15 -0400835 auto result = action.Execute();
alan-bakerfec0a472018-11-08 18:09:40 -0500836 action.EndSourceFile();
837
838 clang::DiagnosticConsumer *const consumer =
839 instance.getDiagnostics().getClient();
840 consumer->finish();
841
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100842 auto num_warnings = consumer->getNumWarnings();
alan-bakerfec0a472018-11-08 18:09:40 -0500843 auto num_errors = consumer->getNumErrors();
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100844 if ((num_errors > 0) || (num_warnings > 0)) {
845 llvm::errs() << log;
846 }
alan-bakerf3bce4a2019-06-28 16:01:15 -0400847 if (result || num_errors > 0) {
alan-bakerfec0a472018-11-08 18:09:40 -0500848 return -1;
849 }
850
Kévin Petit6b07cbe2019-04-02 21:52:16 +0100851 // Don't run the passes or produce any output in verify mode.
852 // Clang doesn't always produce a valid module.
853 if (verify) {
854 return 0;
855 }
856
alan-bakerfec0a472018-11-08 18:09:40 -0500857 llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
858 llvm::initializeCore(Registry);
859 llvm::initializeScalarOpts(Registry);
Diego Novillo1fcff722019-05-07 13:45:53 -0400860 llvm::initializeClspvPasses(Registry);
alan-bakerfec0a472018-11-08 18:09:40 -0500861
862 std::unique_ptr<llvm::Module> module(action.takeModule());
863
864 // Optimize.
865 // Create a memory buffer for temporarily writing the result.
866 SmallVector<char, 10000> binary;
867 llvm::raw_svector_ostream binaryStream(binary);
868 std::string descriptor_map;
alan-bakerfec0a472018-11-08 18:09:40 -0500869 llvm::legacy::PassManager pm;
alan-bakerf5e5f692018-11-27 08:33:24 -0500870 std::vector<version0::DescriptorMapEntry> descriptor_map_entries;
Diego Novillo89500852019-04-15 08:45:10 -0400871
872 // If --emit-ir was requested, emit the initial LLVM IR and stop compilation.
873 if (!IROutputFile.empty()) {
874 return GenerateIRFile(&pm, *module, IROutputFile);
875 }
876
877 // Otherwise, populate the pass manager and run the regular passes.
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400878 if (auto error = PopulatePassManager(
879 &pm, &binaryStream, &descriptor_map_entries, &SamplerMapEntries))
alan-bakerf5e5f692018-11-27 08:33:24 -0500880 return error;
alan-bakerfec0a472018-11-08 18:09:40 -0500881 pm.run(*module);
882
883 // Write outputs
884
885 // Write the descriptor map, if requested.
886 std::error_code error;
887 if (!DescriptorMapFilename.empty()) {
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400888 llvm::raw_fd_ostream descriptor_map_out_fd(
889 DescriptorMapFilename, error, llvm::sys::fs::CD_CreateAlways,
890 llvm::sys::fs::FA_Write, llvm::sys::fs::F_Text);
alan-bakerfec0a472018-11-08 18:09:40 -0500891 if (error) {
892 llvm::errs() << "Unable to open descriptor map file '"
893 << DescriptorMapFilename << "': " << error.message() << '\n';
894 return -1;
895 }
alan-bakerf5e5f692018-11-27 08:33:24 -0500896 std::string descriptor_map_string;
897 std::ostringstream str(descriptor_map_string);
898 for (const auto &entry : descriptor_map_entries) {
899 str << entry << "\n";
900 }
901 descriptor_map_out_fd << str.str();
alan-bakerfec0a472018-11-08 18:09:40 -0500902 descriptor_map_out_fd.close();
903 }
904
905 // Write the resulting binary.
906 // Wait until now to try writing the file so that we only write it on
907 // successful compilation.
908 if (OutputFilename.empty()) {
Kévin Petite4786902019-04-02 21:51:47 +0100909 if (OutputFormat == "c") {
alan-bakerfec0a472018-11-08 18:09:40 -0500910 OutputFilename = "a.spvinc";
911 } else {
912 OutputFilename = "a.spv";
913 }
914 }
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400915 llvm::raw_fd_ostream outStream(OutputFilename, error,
916 llvm::sys::fs::FA_Write);
alan-bakerfec0a472018-11-08 18:09:40 -0500917
918 if (error) {
919 llvm::errs() << "Unable to open output file '" << OutputFilename
920 << "': " << error.message() << '\n';
921 return -1;
922 }
923 outStream << binaryStream.str();
924
925 return 0;
926}
alan-bakerf5e5f692018-11-27 08:33:24 -0500927
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400928int CompileFromSourceString(
929 const std::string &program, const std::string &sampler_map,
930 const std::string &options, std::vector<uint32_t> *output_binary,
931 std::vector<clspv::version0::DescriptorMapEntry> *descriptor_map_entries) {
alan-bakerf5e5f692018-11-27 08:33:24 -0500932
933 llvm::SmallVector<const char *, 20> argv;
934 llvm::BumpPtrAllocator A;
935 llvm::StringSaver Saver(A);
936 argv.push_back(Saver.save("clspv").data());
937 llvm::cl::TokenizeGNUCommandLine(options, Saver, argv);
938 int argc = static_cast<int>(argv.size());
Kévin Petitd5db2d22019-04-04 13:55:14 +0100939
940 if (auto error = ParseOptions(argc, &argv[0]))
941 return error;
alan-bakerf5e5f692018-11-27 08:33:24 -0500942
943 llvm::SmallVector<std::pair<unsigned, std::string>, 8> SamplerMapEntries;
944 if (auto error = ParseSamplerMap(sampler_map, &SamplerMapEntries))
945 return error;
946
947 InputFilename = "source.cl";
948 llvm::StringRef overiddenInputFilename = InputFilename.getValue();
949
950 clang::CompilerInstance instance;
alan-bakerd354f1a2019-08-06 15:41:55 -0400951 clang::FrontendInputFile kernelFile(
952 overiddenInputFilename, clang::InputKind(clang::Language::OpenCL));
alan-bakerf5e5f692018-11-27 08:33:24 -0500953 std::string log;
954 llvm::raw_string_ostream diagnosticsStream(log);
955 if (auto error =
956 SetCompilerInstanceOptions(instance, overiddenInputFilename,
957 kernelFile, program, &diagnosticsStream))
958 return error;
959
960 // Parse.
961 llvm::LLVMContext context;
962 clang::EmitLLVMOnlyAction action(&context);
963
964 // Prepare the action for processing kernelFile
965 const bool success = action.BeginSourceFile(instance, kernelFile);
966 if (!success) {
967 return -1;
968 }
969
alan-bakerf3bce4a2019-06-28 16:01:15 -0400970 auto result = action.Execute();
alan-bakerf5e5f692018-11-27 08:33:24 -0500971 action.EndSourceFile();
972
973 clang::DiagnosticConsumer *const consumer =
974 instance.getDiagnostics().getClient();
975 consumer->finish();
976
977 auto num_errors = consumer->getNumErrors();
alan-bakerf3bce4a2019-06-28 16:01:15 -0400978 if (result || num_errors > 0) {
alan-bakerf5e5f692018-11-27 08:33:24 -0500979 llvm::errs() << log << "\n";
980 return -1;
981 }
982
alan-bakerf5e5f692018-11-27 08:33:24 -0500983 llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry();
984 llvm::initializeCore(Registry);
985 llvm::initializeScalarOpts(Registry);
Diego Novillo1fcff722019-05-07 13:45:53 -0400986 llvm::initializeClspvPasses(Registry);
alan-bakerf5e5f692018-11-27 08:33:24 -0500987
988 std::unique_ptr<llvm::Module> module(action.takeModule());
989
990 // Optimize.
991 // Create a memory buffer for temporarily writing the result.
992 SmallVector<char, 10000> binary;
993 llvm::raw_svector_ostream binaryStream(binary);
994 std::string descriptor_map;
995 llvm::legacy::PassManager pm;
Diego Novillo3cc8d7a2019-04-10 13:30:34 -0400996 if (auto error = PopulatePassManager(
997 &pm, &binaryStream, descriptor_map_entries, &SamplerMapEntries))
alan-bakerf5e5f692018-11-27 08:33:24 -0500998 return error;
999 pm.run(*module);
1000
1001 // Write outputs
1002
1003 // Write the descriptor map. This is required.
Diego Novillo3cc8d7a2019-04-10 13:30:34 -04001004 assert(descriptor_map_entries &&
1005 "Valid descriptor map container is required.");
alan-bakerf5e5f692018-11-27 08:33:24 -05001006 if (!DescriptorMapFilename.empty()) {
Diego Novillo3cc8d7a2019-04-10 13:30:34 -04001007 llvm::errs() << "Warning: -descriptormap is ignored descriptor map "
1008 "container is provided.\n";
alan-bakerf5e5f692018-11-27 08:33:24 -05001009 }
1010
1011 // Write the resulting binary.
1012 // Wait until now to try writing the file so that we only write it on
1013 // successful compilation.
1014 assert(output_binary && "Valid binary container is required.");
1015 if (!OutputFilename.empty()) {
1016 llvm::outs()
1017 << "Warning: -o is ignored when binary container is provided.\n";
1018 }
1019 output_binary->resize(binary.size() / 4);
1020 memcpy(output_binary->data(), binary.data(), binary.size());
1021
1022 return 0;
1023}
alan-bakerfec0a472018-11-08 18:09:40 -05001024} // namespace clspv