[all-commits] [llvm/llvm-project] 64e464: [BPF] introduce __attribute__((bpf_fastcall)) (#10...

[eddyz87 via All-commits]

  Branch: refs/heads/main
  Home:   https://github.com/llvm/llvm-project
  Commit: 64e464349bfca0d90e07f6db2f710d4d53cdacd4
      https://github.com/llvm/llvm-project/commit/64e464349bfca0d90e07f6db2f710d4d53cdacd4
  Author: eddyz87 <eddyz87 at gmail.com>
  Date:   2024-08-22 (Thu, 22 Aug 2024)

  Changed paths:
    M clang/include/clang/Basic/Attr.td
    M clang/include/clang/Basic/AttrDocs.td
    M clang/lib/CodeGen/CGCall.cpp
    A clang/test/CodeGen/bpf-attr-bpf-fastcall-1.c
    M clang/test/Misc/pragma-attribute-supported-attributes-list.test
    A clang/test/Sema/bpf-attr-bpf-fastcall.c
    M llvm/lib/Target/BPF/BPFCallingConv.td
    M llvm/lib/Target/BPF/BPFISelLowering.cpp
    M llvm/lib/Target/BPF/BPFInstrInfo.td
    M llvm/lib/Target/BPF/BPFMIPeephole.cpp
    M llvm/lib/Target/BPF/BPFRegisterInfo.cpp
    M llvm/lib/Target/BPF/BPFRegisterInfo.h
    A llvm/test/CodeGen/BPF/bpf-fastcall-1.ll
    A llvm/test/CodeGen/BPF/bpf-fastcall-2.ll
    A llvm/test/CodeGen/BPF/bpf-fastcall-3.ll
    A llvm/test/CodeGen/BPF/bpf-fastcall-regmask-1.ll

  Log Message:
  -----------
  [BPF] introduce __attribute__((bpf_fastcall)) (#105417)

This commit introduces attribute bpf_fastcall to declare BPF functions
that do not clobber some of the caller saved registers (R0-R5).

The idea is to generate the code complying with generic BPF ABI,
but allow compatible Linux Kernel to remove unnecessary spills and
fills of non-scratched registers (given some compiler assistance).

For such functions do register allocation as-if caller saved registers
are not clobbered, but later wrap the calls with spill and fill
patterns that are simple to recognize in kernel.

For example for the following C code:

    #define __bpf_fastcall __attribute__((bpf_fastcall))

    void bar(void) __bpf_fastcall;
    void buz(long i, long j, long k);

    void foo(long i, long j, long k) {
      bar();
      buz(i, j, k);
    }

First allocate registers as if:

    foo:
      call bar    # note: no spills for i,j,k (r1,r2,r3)
      call buz
      exit

And later insert spills fills on the peephole phase:

    foo:
      *(u64 *)(r10 - 8) = r1;  # Such call pattern is
      *(u64 *)(r10 - 16) = r2; # correct when used with
      *(u64 *)(r10 - 24) = r3; # old kernels.
      call bar
      r3 = *(u64 *)(r10 - 24); # But also allows new
      r2 = *(u64 *)(r10 - 16); # kernels to recognize the
      r1 = *(u64 *)(r10 - 8);  # pattern and remove spills/fills.
      call buz
      exit

The offsets for generated spills/fills are picked as minimal stack
offsets for the function. Allocated stack slots are not used for any
other purposes, in order to simplify in-kernel analysis.



To unsubscribe from these emails, change your notification settings at https://github.com/llvm/llvm-project/settings/notifications