Intel LLVM

https://github.com/intel/llvm
Admin
Intel LLVM is an open source staging area for LLVM contributions including the oneAPI DPC++ compiler...
Tokens:38,518,419
Snippets:251,117
Trust Score:9.4
Update:2 months ago
Show doc for...
Tokens:
Raw
### Build Example Setup

Source: https://github.com/intel/llvm/blob/sycl/libc/examples/README.md

Basic steps to set up a build directory for an example. Navigate to the example's directory, create a 'build' subdirectory, and change into it.

```bash
cd <example directory>
mkdir build
cd build
```

--------------------------------

### Example Usage: Creating and Installing LLVM Xcode Toolchain

Source: https://github.com/intel/llvm/blob/sycl/llvm/tools/xcode-toolchain/CMakeLists.txt

Demonstrates the command-line usage for configuring, building, and installing an LLVM Xcode toolchain using CMake and Ninja. It also shows how to set environment variables to use the installed toolchain.

```bash
cmake -G Ninja -DLLVM_CREATE_XCODE_TOOLCHAIN=On \
  -DCMAKE_INSTALL_PREFIX=$PWD/install
ninja install-xcode-toolchain
export EXTERNAL_TOOLCHAINS_DIR=$PWD/install/Toolchains
export TOOLCHAINS=org.llvm.3.8.0svn
```

--------------------------------

### Example Command Line Build

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ORCv2.md

Illustrates the command-line steps to build dynamic libraries and a main application, mirroring the ORCv2 JIT setup.

```bash
$ clang++ -shared -o libA.dylib a1.cpp a2.cpp
$ clang++ -shared -o libB.dylib b1.cpp b2.cpp
$ clang++ -o myapp myapp.cpp -L. -lA -lB
$ ./myapp
```

--------------------------------

### Benchmark Setup and Teardown Example

Source: https://github.com/intel/llvm/blob/sycl/third-party/benchmark/docs/user_guide.md

Define and register custom setup and teardown functions for benchmarks. These functions are invoked once per benchmark run, respecting thread counts and argument variations.

```c++
static void DoSetup(const benchmark::State& state) {
}

static void DoTeardown(const benchmark::State& state) {
}

static void BM_func(benchmark::State& state) {...}

BENCHMARK(BM_func)->Arg(1)->Arg(3)->Threads(16)->Threads(32)->Setup(DoSetup)->Teardown(DoTeardown);

```

--------------------------------

### Build and Test (Component Build)

Source: https://github.com/intel/llvm/blob/sycl/mlir/examples/standalone/README.md

Use this command to build the example as a component and run its tests. Ensure LLVM and MLIR are built and installed in the specified directories.

```sh
mkdir build && cd build
cmake -G Ninja .. -DMLIR_DIR=$PREFIX/lib/cmake/mlir -DLLVM_EXTERNAL_LIT=$BUILD_DIR/bin/llvm-lit
cmake --build . --target check-standalone
```

--------------------------------

### ObjectStore Store and Get Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ContentAddressableStorage.md

Demonstrates how to store a new CASObject with data and references, and how to retrieve a loaded CASObject by its reference.

```none
ObjectRef A, B, C;
Expected<ObjectRef> Stored = ObjectStore.store("data", {A, B});
Expected<ObjectProxy> Loaded = ObjectStore.getProxy(C);
```

--------------------------------

### Build Stand-alone Clang Example

Source: https://github.com/intel/llvm/blob/sycl/libc/docs/GettingStarted.md

A complete shell script demonstrating the process of building LLVM, installing it, and then configuring and building Clang as a stand-alone project. Sets build directories and installation prefixes.

```shell
#!/bin/sh

build_llvm=`pwd`/build-llvm
build_clang=`pwd`/build-clang
installprefix=`pwd`/install
llvm=`pwd`/llvm-project
mkdir -p $build_llvm
mkdir -p $installprefix

cmake -G Ninja -S $llvm/llvm -B $build_llvm \
      -DLLVM_INSTALL_UTILS=ON \
      -DCMAKE_INSTALL_PREFIX=$installprefix \
      -DCMAKE_BUILD_TYPE=Release

ninja -C $build_llvm install

cmake -G Ninja -S $llvm/clang -B $build_clang \
      -DLLVM_EXTERNAL_LIT=$build_llvm/utils/lit \
      -DLLVM_ROOT=$installprefix

ninja -C $build_clang
```

--------------------------------

### Command-line Compilation Example

Source: https://github.com/intel/llvm/blob/sycl/lld/docs/ORCv2.md

This bash script demonstrates the command-line compilation steps for creating shared libraries and a main executable, mirroring the setup for the ORCv2 C++ example.

```bash
$ clang++ -shared -o libA.dylib a1.cpp a2.cpp
$ clang++ -shared -o libB.dylib b1.cpp b2.cpp
$ clang++ -o myapp myapp.cpp -L. -lA -lB
$ ./myapp

```

--------------------------------

### Setup Local LNT Instance and Server

Source: https://github.com/intel/llvm/blob/sycl/libcxx/utils/ci/lnt/README.md

Steps to create a local LNT instance, configure authentication, and run the LNT server. This involves creating an instance, setting the API token, and starting the server.

```bash
# Create an instance and run a server
lnt create my-instance
echo "api_auth_token = 'example_token'" >> my-instance/lnt.cfg
lnt runserver my-instance
```

--------------------------------

### ORCv2 JIT Program Model Example

Source: https://github.com/intel/llvm/blob/sycl/libc/docs/ORCv2.md

Illustrates how to set up JITDylibs, add compiled code, and establish linking order in ORCv2, mirroring command-line linking. This setup is for hypothetical CXXCompilingLayer.

```c++
ExecutionSession ES;
RTDyldObjectLinkingLayer ObjLinkingLayer(
    ES, []() { return std::make_unique<SectionMemoryManager>(); });
CXXCompileLayer CXXLayer(ES, ObjLinkingLayer);

// Create JITDylib "A" and add code to it using the CXX layer.
auto &LibA = ES.createJITDylib("A");
CXXLayer.add(LibA, MemoryBuffer::getFile("a1.cpp"));
CXXLayer.add(LibA, MemoryBuffer::getFile("a2.cpp"));

// Create JITDylib "B" and add code to it using the CXX layer.
auto &LibB = ES.createJITDylib("B");
CXXLayer.add(LibB, MemoryBuffer::getFile("b1.cpp"));
CXXLayer.add(LibB, MemoryBuffer::getFile("b2.cpp"));

// Create and specify the search order for the main JITDylib. This is
// equivalent to a "links against" relationship in a command-line link.
auto &MainJD = ES.createJITDylib("main");
MainJD.addToLinkOrder(&LibA);
MainJD.addToLinkOrder(&LibB);
CXXLayer.add(MainJD, MemoryBuffer::getFile("main.cpp"));

// Look up the JIT'd main, cast it to a function pointer, then call it.
auto MainSym = ExitOnErr(ES.lookup({&MainJD}, "main"));
auto *Main = MainSym.getAddress().toPtr<int(*)(int, char *[])>();

int Result = Main(...);

```

--------------------------------

### KeepEmptyLines Configuration Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ClangFormatStyleOptions.md

Illustrates the configuration for keeping empty lines within a file. This example shows how to disable empty lines at the end of the file, start of blocks, and start of the file.

```c++
KeepEmptyLines:
  AtEndOfFile: false
  AtStartOfFile: false
  AtStartOfBlock: false
```

--------------------------------

### Conditional Header Install Target Setup

Source: https://github.com/intel/llvm/blob/sycl/libc/lib/CMakeLists.txt

Sets the header install target variable if a full build of LLVM libc is enabled.

```cmake
set(header_install_target "")
if(LLVM_LIBC_FULL_BUILD)
  set(header_install_target install-libc-headers)
endif()
```

--------------------------------

### Get All Installable Header Targets

Source: https://github.com/intel/llvm/blob/sycl/libc/include/CMakeLists.txt

A recursive function to collect all header targets that are marked for installation. It traverses the dependency tree of header targets.

```cmake
function(get_all_install_header_targets out_var)
  set(all_deps ${ARGN})
  foreach(target IN LISTS ARGN)
    get_target_property(deps ${target} DEPS)
    if(NOT deps)
      continue()
    endif()
    list(APPEND all_deps ${deps})
    get_all_install_header_targets(nested_deps ${deps})
    list(APPEND all_deps ${nested_deps})
  endforeach()
  list(REMOVE_DUPLICATES all_deps)
  set(${out_var} ${all_deps} PARENT_SCOPE)
endfunction(get_all_install_header_targets)
```

--------------------------------

### Create Root Directory and Navigate

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/GettingStarted.md

Sets up the necessary directory structure for the build process. Ensure you are in the desired parent directory before executing.

```bash
mkdir root
cd root
```

--------------------------------

### Example: Partitioning GPU sub-devices

Source: https://github.com/intel/llvm/blob/sycl/lld/docs/EnvironmentVariables.md

Demonstrates selecting all sub-devices of all GPU devices across all backends.

```bash
export ONEAPI_DEVICE_SELECTOR="*.*"
```

--------------------------------

### TableGenBreakingDAGArgOperators Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ClangFormatStyleOptions.md

Limits line breaks within DAGArgs to those starting with specified identifiers when TableGenBreakInsideDAGArg is not DontBreak. This example shows breaking only for 'ins' and 'outs'.

```yaml
TableGenBreakInsideDAGArg: BreakAll
TableGenBreakingDAGArgOperators: [ins, outs]
```

--------------------------------

### Simplify Setup with Helper Script

Source: https://github.com/intel/llvm/blob/sycl/xptifw/samples/sycl_perf_collector/README.md

Use the sycl-perf.sh helper script to automate setup, which requires setting XPTI_PER_DIR to the directory containing the dispatcher and subscriber shared objects.

```bash
export XPTI_PER_DIR=/path/to/lib
```

--------------------------------

### Get Target Triple Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/tutorial/MyFirstLanguageFrontend/LangImpl08.md

Demonstrates how to get the current machine's target triple using clang. This is useful for understanding the target environment.

```shell
$ clang --version | grep Target
Target: x86_64-unknown-linux-gnu
```

--------------------------------

### Example Configuration File Content

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/UsersManual.md

Configuration files contain command-line options, one per line. Long options can be split across lines using a trailing backslash. Lines starting with '#' are comments.

```text
# Several options on line
-c --target=x86_64-unknown-linux-gnu

# Long option split between lines
-I/usr/lib/gcc/x86_64-linux-gnu/5.4.0/../../../../\ 
include/c++/5.4.0
```

--------------------------------

### Compile and Run ESIMD Binary Function Example

Source: https://github.com/intel/llvm/blob/sycl/sycl/doc/extensions/supported/sycl_ext_intel_esimd/examples/bfn.md

Commands to compile and execute the SYCL ESIMD binary function example. Ensure you have the necessary toolchain installed.

```bash
> clang++ -fsycl bfn.cpp

> ONEAPI_DEVICE_SELECTOR=level_zero:gpu ./a.out
```

--------------------------------

### Example: Selecting all sub-devices of partitionable GPUs in Level Zero backend

Source: https://github.com/intel/llvm/blob/sycl/llvm/docs/EnvironmentVariables.md

This example selects all sub-devices of partitionable GPUs specifically within the Level Zero backend.

```bash
export ONEAPI_DEVICE_SELECTOR=level_zero:*.*
```

--------------------------------

### Selecting GPU Devices from Level Zero Backend

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/EnvironmentVariables.md

This example demonstrates how to select only GPU devices available through the Level Zero backend. Ensure the Level Zero backend is installed and configured.

```bash
export ONEAPI_DEVICE_SELECTOR=level_zero:gpu
```

--------------------------------

### Good Error Message Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/CodingStandards.md

An example of a clear and informative error message. It starts with a lowercase letter and avoids a trailing period if the sentence naturally ends with other punctuation.

```none
error: file.o: section header 3 is corrupt. Size is 10 when it should be 20
```

--------------------------------

### Basic Hello World Example

Source: https://github.com/intel/llvm/blob/sycl/clang-tools-extra/docs/JITLink.md

Demonstrates a simple 'hello, world!' program compiled and executed using llvm-jitlink. Requires a C source file and compilation to an object file.

```c
#include <stdio.h>

int main(int argc, char *argv[]) {
  printf("hello, world!\n");
  return 0;
}

```

```sh
% clang -c -o hello-world.o hello-world.c
% llvm-jitlink hello-world.o

```

--------------------------------

### Multithreaded Benchmark Setup

Source: https://github.com/intel/llvm/blob/sycl/third-party/benchmark/docs/user_guide.md

Use `state.thread_index() == 0` to perform setup and teardown only once in multithreaded benchmarks. Ensure all threads reach the start before proceeding and finish before exiting.

```c++
static void BM_MultiThreaded(benchmark::State& state) {
  if (state.thread_index() == 0) {
    // Setup code here.
  }
  for (auto _ : state) {
    // Run the test as normal.
  }
  if (state.thread_index() == 0) {
    // Teardown code here.
  }
}
BENCHMARK(BM_MultiThreaded)->Threads(2);
```

--------------------------------

### Build QEMU and Linux Kernel Images

Source: https://github.com/intel/llvm/blob/sycl/lldb/docs/resources/qemu-testing.rst

Use setup.sh to build QEMU binaries and/or Linux kernel images for Arm or AArch64. This script can also be used to clean up build artifacts.

```bash
bash setup.sh --qemu --kernel arm
bash setup.sh --qemu --kernel arm64
```

```bash
bash setup.sh --kernel arm
bash setup.sh --kernel arm64
```

```bash
bash setup.sh --qemu
```

```bash
bash setup.sh --clean
```

--------------------------------

### Build Command for the Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/tutorial/MyFirstLanguageFrontend/LangImpl04.md

The command to compile the complete example code, including LLVM JIT and optimizer flags.

```bash
# Compile
clang++ -g toy.cpp `llvm-config --cxxflags --ldflags --system-libs --libs core orcjit native` -O3 -o toy
```

--------------------------------

### Git Commands for Monorepo Setup

Source: https://github.com/intel/llvm/blob/sycl/clang-tools-extra/docs/Proposals/GitHubMove.md

Example Git commands to set up a monorepo by adding remote mirrors for local repositories and fetching histories for split projects.

```bash
# Import any non-LLVM repositories the umbrella references.
git -C my-monorepo remote add localrepo \
                              https://my.local.mirror.org/localrepo.git
git fetch localrepo

subprojects=( clang clang-tools-extra compiler-rt debuginfo-tests libclc
              libcxx libcxxabi libunwind lld lldb llgo llvm openmp
              parallel-libs polly pstl )

# Import histories for upstream split projects (this was probably
# already done for the ``migrate-downstream-fork.py`` run).
for project in ${subprojects[@]}; do
  git remote add upstream/split/${project} \
                 https://github.com/llvm-mirror/${subproject}.git
  git fetch umbrella/split/${project}
done

# Import histories for downstream split projects (this was probably
```

--------------------------------

### Default Help Output Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/CommandLine.md

This shows the automatically generated help output for the `cl::ConsumeAfter` example, illustrating how options and positional arguments are presented to the user.

```text
USAGE: spiffysh [options] <input script> <program arguments>...

OPTIONS:
  -help - display available options (-help-hidden for more)
  -x    - Enable trace output
```

--------------------------------

### Tail Call Optimization Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/CodeGenerator.md

Example demonstrating tail call optimization setup using 'llc -tailcallopt'. It shows a tailcallee function and a tailcaller function that utilizes it.

```llvm
declare fastcc i32 @tailcallee(i32 inreg %a1, i32 inreg %a2, i32 %a3, i32 %a4)

define fastcc i32 @tailcaller(i32 %in1, i32 %in2) {
  %l1 = add i32 %in1, %in2
  %tmp = tail call fastcc i32 @tailcallee(i32 inreg %in1, i32 inreg %in2, i32 %in1, i32 %l1)
  ret i32 %tmp
}

```

--------------------------------

### Explicit Hardware Subset Examples

Source: https://github.com/intel/llvm/blob/sycl/llvm/docs/design/Runtimes.md

Illustrates how to define an explicit hardware subset using KMP_HW_SUBSET. These examples specify exact counts and starting points for sockets, cores, and threads.

```bash
KMP_HW_SUBSET=:2s,6t
```

```bash
KMP_HW_SUBSET=:1t@7
```

```bash
KMP_HW_SUBSET=:5c,1t
```

--------------------------------

### Basic Hello World Example

Source: https://github.com/intel/llvm/blob/sycl/flang/docs/JITLink.md

Demonstrates the basic usage of llvm-jitlink by compiling and running a simple C program. This involves creating a C file, compiling it to an object file, and then linking and executing it with llvm-jitlink.

```c
#include <stdio.h>

int main(int argc, char *argv[]) {
  printf("hello, world!\n");
  return 0;
}
```

```sh
clang -c -o hello-world.o hello-world.c
lvvm-jitlink hello-world.o
```

--------------------------------

### Git Commands for Monorepo Setup

Source: https://github.com/intel/llvm/blob/sycl/libc/docs/Proposals/GitHubMove.md

Example Git commands to set up a monorepo by adding remote repositories for subprojects and fetching their histories. This is part of the process for migrating from a multi-repository structure.

```bash
# Import any non-LLVM repositories the umbrella references.
git -C my-monorepo remote add localrepo \
                              https://my.local.mirror.org/localrepo.git
git fetch localrepo

subprojects=( clang clang-tools-extra compiler-rt debuginfo-tests libclc
              libcxx libcxxabi libunwind lld lldb llgo llvm openmp
              parallel-libs polly pstl )

# Import histories for upstream split projects (this was probably
# already done for the ``migrate-downstream-fork.py`` run).
for project in ${subprojects[@]};
  do
  git remote add upstream/split/${project} \
                 https://github.com/llvm-mirror/${subproject}.git
  git fetch umbrella/split/${project}
done

# Import histories for downstream split projects (this was probably
```

--------------------------------

### ORCv2 JIT Setup and Compilation

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ORCv2.md

Demonstrates setting up ORCv2's JIT environment, creating JITDylibs for libraries and the main application, and adding compiled code.

```c++
ExecutionSession ES;
RTDyldObjectLinkingLayer ObjLinkingLayer(
    ES, []() { return std::make_unique<SectionMemoryManager>(); });
CXXCompileLayer CXXLayer(ES, ObjLinkingLayer);

// Create JITDylib "A" and add code to it using the CXX layer.
auto &LibA = ES.createJITDylib("A");
CXXLayer.add(LibA, MemoryBuffer::getFile("a1.cpp"));
CXXLayer.add(LibA, MemoryBuffer::getFile("a2.cpp"));

// Create JITDylib "B" and add code to it using the CXX layer.
auto &LibB = ES.createJITDylib("B");
CXXLayer.add(LibB, MemoryBuffer::getFile("b1.cpp"));
CXXLayer.add(LibB, MemoryBuffer::getFile("b2.cpp"));

// Create and specify the search order for the main JITDylib. This is
// equivalent to a "links against" relationship in a command-line link.
auto &MainJD = ES.createJITDylib("main");
MainJD.addToLinkOrder(&LibA);
MainJD.addToLinkOrder(&LibB);
CXXLayer.add(MainJD, MemoryBuffer::getFile("main.cpp"));

// Look up the JIT'd main, cast it to a function pointer, then call it.
auto MainSym = ExitOnErr(ES.lookup({&MainJD}, "main"));
auto *Main = MainSym.getAddress().toPtr<int(*)(int, char *[])>();

int Result = Main(...);
```

--------------------------------

### Example of llvm.vector.reduce.fadd.v4f32 sequential reduction

Source: https://github.com/intel/llvm/blob/sycl/clang-tools-extra/docs/LangRef.md

Demonstrates a sequential reduction using llvm.vector.reduce.fadd.v4f32 with a start value.

```default
%ord = call float @llvm.vector.reduce.fadd.v4f32(float %start_value, <4 x float> %input) ; sequential reduction
```

--------------------------------

### Example: Selecting All Devices Except CUDA

Source: https://github.com/intel/llvm/blob/sycl/polly/docs/EnvironmentVariables.md

This example shows how to accept all available devices but explicitly discard any devices associated with the CUDA backend. This is useful when you want to use most devices but avoid CUDA.

```bash
export ONEAPI_DEVICE_SELECTOR="*:*;!cuda:*"
```

--------------------------------

### Example of !size

Source: https://github.com/intel/llvm/blob/sycl/llvm/docs/TableGen/ProgRef.md

Demonstrates the !size bang operator for getting the number of elements in a list or string.

```tablegen
def MyClass : MyBase<"MyClass"> {
  string Name = "MyClass";
  // Get the size of the 'Name' string.
  int NameSize = !size(Name);
}
```

--------------------------------

### Create and Navigate to Build Directory

Source: https://github.com/intel/llvm/blob/sycl/libc/config/windows/README.md

Create an empty directory for building LLVM libc and change into it.

```bash
mkdir libc-build
cd libc-build
```

--------------------------------

### Example: Calling a private member function disables the check

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/clang-tidy/checks/readability/make-member-function-const.md

This example demonstrates a scenario where calling a private member function prevents the `readability-make-member-function-const` check from suggesting a `const` qualifier for the `get` method.

```C++
class E1 {
  Pimpl &getPimpl() const;
public:
  int &get() {
    // Calling a private member function disables this check.
    return getPimpl()->i;
  }
  ...
};
```

--------------------------------

### Hello World Example with llvm-jitlink

Source: https://github.com/intel/llvm/blob/sycl/clang/docs/JITLink.md

Demonstrates basic usage of llvm-jitlink by compiling and running a simple C program. Ensure clang and llvm-jitlink are in your PATH.

```c
#include <stdio.h>

int main(int argc, char *argv[]) {
  printf("hello, world!\n");
  return 0;
}

```

```sh
% clang -c -o hello-world.o hello-world.c
% llvm-jitlink hello-world.o
Hello, World!

```

--------------------------------

### Setting OpenMP Header Install Location

Source: https://github.com/intel/llvm/blob/sycl/openmp/CMakeLists.txt

Determines the installation path for OpenMP headers based on whether LLVM_TREE is available. If not, it uses the default include directory; otherwise, it gets the Clang resource directory.

```cmake
if(NOT LLVM_TREE_AVAILABLE)
  set(LIBOMP_HEADERS_INSTALL_PATH "${CMAKE_INSTALL_INCLUDEDIR}")
else()
  include(GetClangResourceDir)
  get_clang_resource_dir(LIBOMP_HEADERS_INSTALL_PATH SUBDIR include)
endif()
```

--------------------------------

### FileCheck Empty Regex Match at Start

Source: https://github.com/intel/llvm/blob/sycl/llvm/test/FileCheck/empty-regex-match-at-start.txt

This example shows FileCheck matching an empty regex at the start of a line. The {{^}} anchor asserts the position at the beginning of the line, and the empty regex matches zero characters there.

```FileCheck
RUN: FileCheck %s --check-prefix=NEXT --input-file=%s
NEXT:      {{^}}
NEXT-NEXT: more text
```

--------------------------------

### Selecting Sub-Sub-Devices

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/EnvironmentVariables.md

This example demonstrates selecting sub-sub-devices from the first device in the Level Zero backend. This allows for a deeper level of partitioning, accessing the smallest available compute units.

```bash
export ONEAPI_DEVICE_SELECTOR=level_zero:0.*.*
```

--------------------------------

### Alias Query Example

Source: https://github.com/intel/llvm/blob/sycl/llvm/docs/AliasAnalysis.md

Demonstrates how memory objects are represented as a starting address and size for alias queries.

```c++
int i;
char C[2];
char A[10];
/* ... */
for (i = 0; i != 10; ++i) {
  C[0] = A[i];          /* One byte store */
  C[1] = A[9-i];        /* One byte store */
}

```

--------------------------------

### Basic Hello World Example with llvm-jitlink

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/JITLink.md

Demonstrates the basic usage of `llvm-jitlink` by compiling and executing a simple C program. Ensure `clang` is available for compilation.

```c
#include <stdio.h>

int main(int argc, char *argv[]) {
  printf("hello, world!\n");
  return 0;
}
```

```sh
% clang -c -o hello-world.o hello-world.c
% llvm-jitlink hello-world.o
```

--------------------------------

### Get Dimensions of RWBuffer<float4>

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/DirectX/DXILResources.md

Example of retrieving the dimension of an RWBuffer<float4> using the .x intrinsic.

```llvm
; RWBuffer<float4>
%dim = call i32 @llvm.dx.resource.getdimensions.x(target("dx.TypedBuffer", <4 x float>, 1, 0, 0) %handle)
```

--------------------------------

### Install lit using setuptools

Source: https://github.com/intel/llvm/blob/sycl/llvm/utils/lit/README.rst

Install the lit tool using setuptools. This command is used to make the 'lit' command available system-wide or in a virtual environment.

```bash
python utils/lit/setup.py install
```

--------------------------------

### YAML Sequence Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/YamlIO.md

Demonstrates a basic YAML sequence, which is a list of items. Each item starts with a leading dash.

```yaml
# a sequence
- x86
- x86_64
- PowerPC
```

--------------------------------

### Main Driver Initialization and Setup

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/tutorial/MyFirstLanguageFrontend/LangImpl09.md

Initializes LLVM native targets, sets up binary operator precedence, primes the first token, and creates the JIT. This code is essential for the compiler's execution environment.

```cpp
int main() {
  InitializeNativeTarget();
  InitializeNativeTargetAsmPrinter();
  InitializeNativeTargetAsmParser();

  // Install standard binary operators.
  // 1 is lowest precedence.
  BinopPrecedence['='] = 2;
  BinopPrecedence['<'] = 10;
  BinopPrecedence['+'] = 20;
  BinopPrecedence['-'] = 20;
  BinopPrecedence['*'] = 40; // highest.

  // Prime the first token.
  getNextToken();

  TheJIT = ExitOnErr(KaleidoscopeJIT::Create());

  InitializeModule();

  // Add the current debug info version into the module.
  TheModule->addModuleFlag(Module::Warning, "Debug Info Version",
                           DEBUG_METADATA_VERSION);

  // Darwin only supports dwarf2.
  if (Triple(sys::getProcessTriple()).isOSDarwin())
    TheModule->addModuleFlag(llvm::Module::Warning, "Dwarf Version", 2);

  // Construct the DIBuilder, we do this here because we need the module.
  DBuilder = std::make_unique<DIBuilder>(*TheModule);

  // Create the compile unit for the module.
  // Currently down as "fib.ks" as a filename since we're redirecting stdin
  // but we'd like actual source locations.
  KSDbgInfo.TheCU = DBuilder->createCompileUnit(
      dwarf::DW_LANG_C, DBuilder->createFile("fib.ks", "."),
      "Kaleidoscope Compiler", false, "", 0);

  // Run the main "interpreter loop" now.
  MainLoop();

  // Finalize the debug info.
  DBuilder->finalize();

  // Print out all of the generated code.
  TheModule->print(errs(), nullptr);

  return 0;
}
```

--------------------------------

### TIMEF Example

Source: https://github.com/intel/llvm/blob/sycl/clang-tools-extra/docs/Intrinsics.md

Shows how to get the current time in a formatted string using the non-standard TIMEF intrinsic procedure.

```Fortran
program timef_example
  character(len=8) :: t
  t = timef()
  print *, 'Current time (formatted): ', t
end program timef_example
```

--------------------------------

### Complete Workflow Example: Memory Access Profiler

Source: https://github.com/intel/llvm/blob/sycl/libcxx/docs/Instrumentor.md

Demonstrates a full workflow for creating a memory access profiler. This includes generating a configuration, implementing a runtime, instrumenting the code, and compiling the final program.

```bash
./llvm/utils/instrumentor-config-wizard.py -o memory_profiler.json

# In the wizard:
# - Enable: load, store
# - Use same config for PRE/POST: yes
# - Base config: keep defaults
# - For load/store: enable pointer, value_size, id
# - Generate stubs: yes (memory_profiler_stubs.c)
```

```c
// memory_runtime.c
#include <stdio.h>
#include <stdint.h>

static uint64_t load_count = 0;
static uint64_t store_count = 0;

void __instrumentor_pre_load(void *pointer, uint64_t value_size,
                               int32_t id) {
  load_count++;
  printf("Load from %p (size: %lu, id: %d)\n",
         pointer, value_size, id);
}

void __instrumentor_pre_store(void *pointer, uint64_t value_size,
                                int32_t id) {
  store_count++;
  printf("Store to %p (size: %lu, id: %d)\n",
         pointer, value_size, id);
}

__attribute__((destructor))
void print_stats(void) {
  printf("Total loads: %lu\n", load_count);
  printf("Total stores: %lu\n", store_count);
}
```

```bash
# Instrument the program
clang -emit-llvm -S -o program.ll program.c
opt -passes=instrumentor \
    -instrumentor-read-config-file=memory_profiler.json \
    program.ll -S -o program_inst.ll

# Compile with runtime
clang program_inst.ll memory_runtime.c -o program
```

```bash
# Run and observe:
./program
# Output includes:
# Load from 0x7ffc12345678 (size: 4, id: 1)
# Store to 0x7ffc12345680 (size: 8, id: 2)
# ...
# Total loads: 42
# Total stores: 27
```

--------------------------------

### Fortran TIME Example

Source: https://github.com/intel/llvm/blob/sycl/clang/docs/Intrinsics.md

Demonstrates the usage of the non-standard TIME intrinsic function to get the current time as a string.

```Fortran
program time_test
  implicit none
  character(len=8) :: current_time

  current_time = time()
  print *, "Current time: ", trim(current_time)
end program time_test
```

--------------------------------

### Create and Build Program

Source: https://github.com/intel/llvm/blob/sycl/unified-runtime/scripts/core/PROG.rst

Demonstrates the creation of a program from Intermediate Language (IL) binary and its subsequent build process.

```c
    ${x}ProgramCreateWithIL(hContext, ILBin, ILBinSize, nullptr, &hProgram);

    // Build the program.
    ${x}ProgramBuild(hContext, hProgram, nullptr);
```

--------------------------------

### FIR Array Amend Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/FIRArrayOperations.md

Demonstrates the usage of `fir.array_access` to get a reference and `fir.array_amend` to mark the array as modified.

```fir
  // fetch the value of one of the array value's elements
  %1 = fir.array_access %v, %i, %j : (!fir.array<?x?xT>, index, index) -> !fir.ref<T>
  // modify the element by storing data using %1 as a reference
  %2 = ... %1 ...
  // mark the array value
  %new_v = fir.array_amend %v, %2 : (!fir.array<?x?xT>, !fir.ref<T>) -> !fir.array<?x?xT>
```

--------------------------------

### Complete Workflow: Memory Access Profiler Setup

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/Instrumentor.md

This section outlines the steps to create a memory access profiler. It includes generating a configuration with the wizard, implementing the runtime, and then instrumenting and compiling the program.

```bash
./llvm/utils/instrumentor-config-wizard.py -o memory_profiler.json

# In the wizard:
# - Enable: load, store
# - Use same config for PRE/POST: yes
# - Base config: keep defaults
# - For load/store: enable pointer, value_size, id
# - Generate stubs: yes (memory_profiler_stubs.c)
```

--------------------------------

### Get Dimensions of Texture2DMS

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/DirectX/DXILResources.md

Example of retrieving width, height, and sample count of a Texture2DMS using the .ms.xy intrinsic.

```llvm
; Texture2DMS
%2 = call {i32, i32, i32} @llvm.dx.resource.getdimensions.ms.xy(
   target("dx.Texture", ...) %tex2dms)
%tex2dms_width = extractvalue {i32, i32, i32} %2, 0
%tex2dms_height = extractvalue {i32, i32, i32} %2, 1
%tex2dms_samples_count = extractvalue {i32, i32, i32} %2, 2
```

--------------------------------

### Example ONEAPI_DEVICE_SELECTOR for Sub-device Partitioning

Source: https://github.com/intel/llvm/blob/sycl/libcxx/docs/EnvironmentVariables.md

Illustrates partitioning a specific device into sub-devices and then sub-sub-devices. This example targets device 0 in the Level Zero backend and exposes its most granular partitions.

```none
ONEAPI_DEVICE_SELECTOR=level_zero:0.*.*
```

--------------------------------

### Get Dimensions of Texture2D

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/DirectX/DXILResources.md

Example of retrieving the width and height of a Texture2D using the .xy intrinsic and extracting values.

```llvm
; Texture2D
%0 = call {i32, i32} @llvm.dx.resource.getdimensions.xy(target("dx.Texture", ...) %tex2d)
%tex2d_width = extractvalue {i32, i32} %0, 0
%tex2d_height = extractvalue {i32, i32} %0, 1
```

--------------------------------

### ActionCache Put and Get Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ContentAddressableStorage.md

Shows how to associate two CASIDs using ActionCache, storing a mapping and then retrieving it.

```none
CASID A, B;
Error E = ActionCache.put(A, B);
Expected<std::optional<CASID>> Result = ActionCache.get(A);
```

--------------------------------

### Configure LLVM Example Build

Source: https://github.com/intel/llvm/blob/sycl/llvm/examples/OrcV2Examples/OrcV2CBindingsIRTransforms/CMakeLists.txt

Sets up the necessary LLVM components for the example and adds the example target to the build.

```cmake
set(LLVM_LINK_COMPONENTS
  Core
  ExecutionEngine
  IRReader
  JITLink
  MC
  OrcJIT
  Passes
  Support
  Target
  nativecodegen
  )

add_llvm_example(OrcV2CBindingsIRTransforms
  OrcV2CBindingsIRTransforms.c
  )
```

--------------------------------

### LLVM Call Preallocated Setup Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/LangRef.md

Demonstrates nested usage of llvm.call.preallocated.setup and operand bundles for preallocated arguments.

```llvm
%t1 = call token @llvm.call.preallocated.setup(i32 0)
%t2 = call token @llvm.call.preallocated.setup(i32 0)
call void foo() [“preallocated”(token %t2)]
call void foo() [“preallocated”(token %t1)]
```

--------------------------------

### Canonicalize Induction Variables Example

Source: https://github.com/intel/llvm/blob/sycl/clang/docs/Passes.md

Illustrates the transformation of loop induction variables and exit conditions. The example shows a loop transformed to use a canonical induction variable starting at zero and stepping by one, with a simplified exit condition.

```c++
for (i = 7; i*i < 1000; ++i)

  into

  for (i = 0; i != 25; ++i)
```

--------------------------------

### Initialize and Checkout Libcxx with Git-SVN

Source: https://github.com/intel/llvm/blob/sycl/flang/docs/Proposals/GitHubMove.md

This example shows how to initialize a git-svn repository for Libcxx, fetch its history, and checkout a specific revision.

```bash
cd ../../projects/libcxx
git svn init https://llvm.org/svn/llvm-project/libcxx/trunk --username=<username>
git config svn-remote.svn.fetch :refs/remotes/origin/main
git svn rebase -l
git checkout `git svn find-rev -B r258109`
```

--------------------------------

### Install Benchmark Dependencies

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/TestingLibcxx.md

Set up a Python virtual environment and install the necessary requirements for using the benchmark comparison tools.

```bash
$ python -m venv .venv && source .venv/bin/activate
$ pip install -r libcxx/utils/requirements.txt
```

--------------------------------

### Module and Import Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/StandardCPlusPlusModules.md

Demonstrates a basic module definition and import. Ensure compiler flags match for consistent language dialect.

```c++
// M.cppm
export module M;

// Use.cpp
import M;

```

--------------------------------

### DPAS Matrix Multiply-Add-and-Accumulate Example

Source: https://github.com/intel/llvm/blob/sycl/sycl/doc/extensions/supported/sycl_ext_intel_esimd/examples/dpas.md

This example demonstrates the core functionality of DPAS for matrix operations. It includes setup for data types, matrix dimensions, and helper functions for packing and unpacking data for matrices A and B. Assumes PVC hardware.

```C++
#include <sycl/ext/intel/esimd.hpp>
#include <sycl/sycl.hpp>

using namespace sycl;
namespace esimd = sycl::ext::intel::esimd;
namespace xmx = sycl::ext::intel::esimd::xmx;

inline auto create_exception_handler() {
  return [](exception_list l) {
    for (auto ep : l) {
      try {
        std::rethrow_exception(ep);
      } catch (sycl::exception &e0) {
        std::cout << "sycl::exception: " << e0.what() << std::endl;
      } catch (std::exception &e) {
        std::cout << "std::exception: " << e.what() << std::endl;
      } catch (...) {
        std::cout << "generic exception\n";
      }
    }
  };
}

struct usm_deleter {
  queue q;
  void operator()(void *ptr) {
    if (ptr)
      sycl::free(ptr, q);
  }
};

// Res = A * B.
// Assume the HW is PVC.

constexpr int SystolicDepth = 8;
constexpr int RepeatCount = 4;
constexpr int ExecSize = 16; // 16 for PVC, 8 for DG2.

// Let A and B be matrices of unsigned 4-bit integers.
constexpr xmx::dpas_argument_type BPrec = xmx::dpas_argument_type::u4;
constexpr xmx::dpas_argument_type APrec = xmx::dpas_argument_type::u4;

constexpr int AElemBitSize = 4; // 4-bit integers.
constexpr int BElemBitSize = 4; // 4-bit integers.

// Elements of A and B will are packed into uint8_t, 
// meaning that one uint8_t holds two 4-bit unsigned integers.
// Packaging for A and res is horizontal, for B is vertical.
using PackedType = unsigned char;
using APackedType = PackedType;
using BPackedType = PackedType;

// Result type, according to documentation is either int or uint.
using ResType = unsigned int; // as both A and B are unsigned.

constexpr int OpsPerChannel = 
    std::min(32 / std::max(AElemBitSize, BElemBitSize), 8);

// A(M x K) * B(K x N) + C(M x N).
// where:
constexpr int M = RepeatCount;
constexpr int K = SystolicDepth * OpsPerChannel;
constexpr int N = ExecSize;

void write_to_horizontally_packed_matrix_a(APackedType *vec, int row, int col,
                                           APackedType value) {
  constexpr int NumRows = M;
  constexpr int NumCols = K;

  constexpr int elems_in_elem_t = sizeof(APackedType) * 8 / AElemBitSize;
  int unpacked_linear_index = row * NumCols + col;
  int packed_linear_index = unpacked_linear_index / elems_in_elem_t;

  // Assume that we deal only with 2 or 4-bit integers.
  static_assert((AElemBitSize == 2 || AElemBitSize == 4), 
                "Unexpected element type");

  // Update the corresponding bits of the target element.
  APackedType target_elem = vec[packed_linear_index];
  // target_elem has 2 or more elements in it. Need to extract one.
  unsigned int offset = 
      (unpacked_linear_index % elems_in_elem_t) * AElemBitSize;
  unsigned int mask = (1 << AElemBitSize) - 1;
  value = (value & mask) << offset;
  mask = mask << offset;
  target_elem = (target_elem & ~mask) | value;
  vec[packed_linear_index] = target_elem;
}

APackedType read_from_horizontally_packed_matrix_a(APackedType *vec, int row,
                                                   int col) {
  constexpr int NumRows = M;
  constexpr int NumCols = K;

  // Assume that we deal only with 2 or 4-bit integers.
  static_assert((AElemBitSize == 2 || AElemBitSize == 4), 
                "Unexpected element type");
  // Assume the packed type is unsigned.
  static_assert(std::is_unsigned_v<APackedType>, "Expect unsigned packed type");

  // 1. Find and read the target 'unsigned int' element.
  // The unpacked matrix has dimensions: NumRows*NumCols
  constexpr int elems_in_elem_t = sizeof(APackedType) * 8 / AElemBitSize;
  int unpacked_linear_index = row * NumCols + col;
  int packed_linear_index = unpacked_linear_index / elems_in_elem_t;
  APackedType target_elem = vec[packed_linear_index];

  // 2. Extract, add sign and return the value.
  // target_elem has 2 or more elements in it. Need to extract one.
  unsigned int offset = 
      (unpacked_linear_index % elems_in_elem_t) * AElemBitSize;
  unsigned int mask = (static_cast<uint64_t>(1) << AElemBitSize) - 1;
  APackedType value = (target_elem >> offset) & mask;
  return value;
}

void write_to_vertically_packed_matrix_b(BPackedType *vec, int row, int col,
                                         BPackedType value) {
  constexpr int NumRows = K;
  constexpr int NumCols = N;

  // 1. Find and read the target 'int' element.
  // The unpacked matrix has dimensions: NumRows*NumCols.
  constexpr int ElemsInInt = 32 / BElemBitSize;
  int packed_row = row / ElemsInInt;
  int packed_linear_index = packed_row * NumCols + col;
  int target_elem = vec[packed_linear_index];

  // 2. Insert sub-element 'value' into 32-bit int and write back to matrix.
  int elem_bit_offset = (row % ElemsInInt) * BElemBitSize;

```

--------------------------------

### Profile Guided Optimization Setup

Source: https://github.com/intel/llvm/blob/sycl/lld/docs/TestSuiteGuide.md

Configure the build for Profile Guided Optimization (PGO) using LLVM IR. This involves enabling profile generation, setting the run type to 'train', and then using the generated profile data for a second compilation.

```bash
# Profile generation run using LLVM IR PGO:
% cmake -DTEST_SUITE_PROFILE_GENERATE=ON \
        -DTEST_SUITE_USE_IR_PGO=ON \
        -DTEST_SUITE_RUN_TYPE=train \
        ../llvm-test-suite
% make
% llvm-lit . \
# Use the profile data for compilation and actual benchmark run:
% cmake -DTEST_SUITE_PROFILE_GENERATE=OFF \
        -DTEST_SUITE_PROFILE_USE=ON \
        -DTEST_SUITE_RUN_TYPE=ref \
        .
% make
% llvm-lit -o result.json .

```

--------------------------------

### Setup IO redirection for a launched process

Source: https://github.com/intel/llvm/blob/sycl/lldb/tools/lldb-dap/README.md

Configure to launch a program and redirect its standard input, output, and error streams to specified files.

```javascript
{
  "type": "lldb-dap",
  "request": "launch",
  "name": "Debug",
  "program": "/tmp/a.out",
  "stdio": ["in.txt", "out.txt"]
}
```

--------------------------------

### SourceRange Example

Source: https://github.com/intel/llvm/blob/sycl/clang/docs/InternalsManual.md

Illustrates how SourceRange represents a range between the start of two tokens. The end of the range needs adjustment for character-level precision.

```text
x = foo + bar;
^first    ^last
```

--------------------------------

### Create Build Directory and Navigate

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/CMake.md

Before configuring the build, create a separate directory for build artifacts and change into it. Building LLVM in the source directory is not supported.

```bash
$ mkdir mybuilddir
$ cd mybuilddir
```

--------------------------------

### Start GDB on opt process

Source: https://github.com/intel/llvm/blob/sycl/clang/docs/WritingAnLLVMPass.md

Begin by attaching GDB to the opt process. Be patient as opt has a lot of debugging information and takes time to load.

```console
$ gdb opt
GNU gdb 5.0
Copyright 2000 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public License, and you are
welcome to change it and/or distribute copies of it under certain conditions.
Type "show copying" to see the conditions.
There is absolutely no warranty for GDB.  Type "show warranty" for details.
This GDB was configured as "sparc-sun-solaris2.6"...
(gdb)
```

--------------------------------

### Example of TIME intrinsic

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/Intrinsics.md

Shows how to use the TIME intrinsic function to get the current time as a character string. The format is HHMMSS.

```fortran
program time_example
  character(len=8) :: current_time

  current_time = time()
  print *, "Current time (HHMMSS): ", current_time
end program time_example
```

--------------------------------

### Get start of unsafe stack (deprecated)

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/SafeStack.md

This builtin function is an alias for `__builtin___get_unsafe_stack_bottom()` and is deprecated. Use `__builtin___get_unsafe_stack_bottom()` instead for clarity and future compatibility.

```c
__builtin___get_unsafe_stack_start()
```

--------------------------------

### Create and Use LLJIT Instance

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/ORCv2.md

Demonstrates creating an LLJIT instance, adding an IR module, looking up a symbol, and calling JIT'd code. Ensure a ThreadSafeContext is available.

```c++
// Try to detect the host arch and construct an LLJIT instance.
auto JIT = LLJITBuilder().create();

// If we could not construct an instance, return an error.
if (!JIT)
  return JIT.takeError();

// Add the module.
if (auto Err = JIT->addIRModule(TheadSafeModule(std::move(M), Ctx)))
  return Err;

// Look up the JIT'd code entry point.
auto EntrySym = JIT->lookup("entry");
if (!EntrySym)
  return EntrySym.takeError();

// Cast the entry point address to a function pointer.
auto *Entry = EntrySym.getAddress().toPtr<void(*)()>();

// Call into JIT'd code.
Entry();
```

--------------------------------

### Setup and Diff Command

Source: https://github.com/intel/llvm/blob/sycl/llvm/utils/lit/tests/Inputs/shtest-shell/diff-r-error-5.txt

This snippet sets up two directories, adds content to one, and then attempts to compare them using `diff -r`. The presence of extra files in the source directory is expected to cause `diff -r` to fail, demonstrating error handling.

```shell
# Create two directories for further comparison.
# RUN: rm -rf %t/dir1 %t/dir2
# RUN: mkdir -p %t/dir1 %t/dir2

# Non-empty extra directory, "diff -r" should fail.
# RUN: mkdir -p %t/dir1/extra_subdir
# RUN: echo ZYX > %t/dir1/extra_subdir/extra_file
# RUN: diff -r %t/dir1 %t/dir2
```

--------------------------------

### Get Dimensions for Multisampled Texture2D

Source: https://github.com/intel/llvm/blob/sycl/lld/docs/DirectX/DXILResources.md

Example of calling getDimensions for a multisampled Texture2D (Texture2DMS). The intrinsic returns width, height, and sample count.

```llvm
; Texture2DMS
%2 = call {i32, i32, i32} @llvm.dx.resource.getdimensions.ms.xy(
   target("dx.Texture", ...) %tex2dms)
%tex2dms_width = extractvalue {i32, i32, i32} %2, 0
%tex2dms_height = extractvalue {i32, i32, i32} %2, 1
%tex2dms_samples_count = extractvalue {i32, i32, i33} %2, 2
```

--------------------------------

### Hello World C++ Module Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/StandardCPlusPlusModules.md

A basic 'hello world' example demonstrating a simple module 'Hello' with a primary module interface unit. It shows how to precompile the module and then use it in another file.

```c++
// Hello.cppm
module;
#include <iostream>
export module Hello;
export void hello() {
  std::cout << "Hello World!\n";
}
```

```c++
// use.cpp
import Hello;
int main() {
  hello();
  return 0;
}
```

--------------------------------

### CHECK-SAME Annotation Setup

Source: https://github.com/intel/llvm/blob/sycl/llvm/test/FileCheck/dump-input/annotations.txt

Sets up input files and expected output for the CHECK-SAME annotation.

```bash
; RUN: echo 'pre' >  %t.in
; RUN: echo 'var' >> %t.in

; RUN: echo 'CHECK: pre'          >  %t.chk
; RUN: echo 'CHECK-SAME: [[VAR]]' >> %t.chk
```

--------------------------------

### C Source Files Example

Source: https://github.com/intel/llvm/blob/sycl/bolt/docs/LibASTImporter.md

Example C source files including header, implementation, and main function for demonstration.

```c
// bar.h
#ifndef BAR_H
#define BAR_H
int bar();
#endif /* BAR_H */

// bar.c
#include "bar.h"
int bar() {
  return 41;
}

// main.c
#include "bar.h"
int main() {
    return bar();
}
```

--------------------------------

### Example: Combined discard and implicit accept all

Source: https://github.com/intel/llvm/blob/sycl/orc-rt/docs/EnvironmentVariables.md

This example explicitly accepts all OpenCL devices and implicitly accepts all other devices except those of the CPU type.

```bash
export ONEAPI_DEVICE_SELECTOR=opencl:*;!*:cpu
```
Tokens:
Raw