bpf: Replace deprecated -target with --target= for Clang

Q: clang flag for target bpf?

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

Q: In some cases clang flag ``-target bpf`` is used but in other cases the

Q: In some cases clang flag ``--target=bpf`` is used but in other cases the

default clang target, which matches the underlying architecture, is used.

What is the difference and when I should use which?

A: Although LLVM IR generation and optimization try to stay architecture

independent, ``-target <arch>`` still has some impact on generated code:

independent, ``--target=<arch>`` still has some impact on generated code:

- BPF program may recursively include header file(s) with file scope

  inline assembly codes. The default target can handle this well,

  The clang option ``-fno-jump-tables`` can be used to disable

  switch table generation.

- For clang ``-target bpf``, it is guaranteed that pointer or long /

- For clang ``--target=bpf``, it is guaranteed that pointer or long /

  unsigned long types will always have a width of 64 bit, no matter

  whether underlying clang binary or default target (or kernel) is

  32 bit. However, when native clang target is used, then it will

  while the BPF LLVM back end still operates in 64 bit. The native

  target is mostly needed in tracing for the case of walking ``pt_regs``

  or other kernel structures where CPU's register width matters.

  Otherwise, ``clang -target bpf`` is generally recommended.

  Otherwise, ``clang --target=bpf`` is generally recommended.

You should use default target when:

  into these structures is verified by the BPF verifier and may result

  in verification failures if the native architecture is not aligned with

  the BPF architecture, e.g. 64-bit. An example of this is

  BPF_PROG_TYPE_SK_MSG require ``-target bpf``

  BPF_PROG_TYPE_SK_MSG require ``--target=bpf``

.. Links

    } g2;

    int main() { return 0; }

    int test() { return 0; }

    -bash-4.4$ clang -c -g -O2 -target bpf t2.c

    -bash-4.4$ clang -c -g -O2 --target=bpf t2.c

    -bash-4.4$ readelf -S t2.o

      ......

      [ 8] .BTF              PROGBITS         0000000000000000  00000247

      [10] .rel.BTF.ext      REL              0000000000000000  000007e0

           0000000000000040  0000000000000010          16     9     8

      ......

    -bash-4.4$ clang -S -g -O2 -target bpf t2.c

    -bash-4.4$ clang -S -g -O2 --target=bpf t2.c

    -bash-4.4$ cat t2.s

      ......

            .section        .BTF,"",@progbits

    return g1 + g2 + l1 + l2;

  }

Compiled with ``clang -target bpf -O2 -c test.c``, the following is

Compiled with ``clang --target=bpf -O2 -c test.c``, the following is

the code with ``llvm-objdump -dr test.o``::

       0:       18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll

    return gfunc(a, b) +  lfunc(a, b) + global;

  }

Compiled with ``clang -target bpf -O2 -c test.c``, we will have

Compiled with ``clang --target=bpf -O2 -c test.c``, we will have

following code with `llvm-objdump -dr test.o``::

  Disassembly of section .text:

  int global() { return 0; }

  struct t { void *g; } gbl = { global };

Compiled with ``clang -target bpf -O2 -g -c test.c``, we will see a

Compiled with ``clang --target=bpf -O2 -g -c test.c``, we will see a

relocation below in ``.data`` section with command

``llvm-readelf -r test.o``::

$(OUTPUT)/entrypoints.bpf.o: entrypoints.bpf.c $(OUTPUT)/vmlinux.h $(BPFOBJ) | $(OUTPUT)

	$(call msg,BPF,$@)

	$(Q)$(CLANG) -g -O2 -target bpf $(INCLUDES)			      \

	$(Q)$(CLANG) -g -O2 --target=bpf $(INCLUDES)			      \

		 -c $(filter %.c,$^) -o $@ &&				      \

	$(LLVM_STRIP) -g $@

$(OUTPUT)/%/iterators.bpf.o: iterators.bpf.c $(BPFOBJ) | $(OUTPUT)

	$(call msg,BPF,$@)

	$(Q)mkdir -p $(@D)

	$(Q)$(CLANG) -g -O2 -target bpf -m$* $(INCLUDES)		      \

	$(Q)$(CLANG) -g -O2 --target=bpf -m$* $(INCLUDES)		      \

		 -c $(filter %.c,$^) -o $@ &&				      \

	$(LLVM_STRIP) -g $@