Started 2 mo 14 days ago
Took 9 hr 58 min on green-dragon-13

Failed Build #6456 (Jul 9, 2019 1:52:40 AM)

Revisions
  • http://llvm.org/svn/llvm-project/llvm/trunk : 365441
  • http://llvm.org/svn/llvm-project/cfe/trunk : 365438
  • http://llvm.org/svn/llvm-project/compiler-rt/trunk : 365424
  • http://llvm.org/svn/llvm-project/debuginfo-tests/trunk : 364589
  • http://llvm.org/svn/llvm-project/libcxx/trunk : 365359
  • http://llvm.org/svn/llvm-project/clang-tools-extra/trunk : 365380
Changes
  1. [Loop Peeling] Add support for peeling of loops with multiple exits

    This patch modifies the loop peeling transformation so that
    it does not expect that there is only one loop exit from latch.

    It modifies only transformation. Update of branch weights remains
    only for exit from latch.

    The motivation is that in follow-up patch I plan to enable loop peeling for
    loops with multiple exits but only if other exits then from latch one goes to
    block with call to deopt.

    For now this patch is NFC.

    Reviewers: reames, mkuper, iajbar, fhahn
    Reviewed By: reames, fhahn
    Subscribers: zzheng, llvm-commits
    Differential Revision: https://reviews.llvm.org/D63921 (detail)
    by skatkov
  2. Prepare for making SwitchInstProfUpdateWrapper strict

    This patch removes the test part that relates to the non-strict
    behavior of SwitchInstProfUpdateWrapper and changes
    the assertion to llvm_unreachable() to allow the check in
    release builds.
    This patch prepares SwitchInstProfUpdateWrapper to become
    strict with one line change. That is need to revert it easily
    if any failure will arise. (detail)
    by yrouban
  3. [BPF] Preserve debuginfo array/union/struct type/access index

    For background of BPF CO-RE project, please refer to
      http://vger.kernel.org/bpfconf2019.html
    In summary, BPF CO-RE intends to compile bpf programs
    adjustable on struct/union layout change so the same
    program can run on multiple kernels with adjustment
    before loading based on native kernel structures.

    In order to do this, we need keep track of GEP(getelementptr)
    instruction base and result debuginfo types, so we
    can adjust on the host based on kernel BTF info.
    Capturing such information as an IR optimization is hard
    as various optimization may have tweaked GEP and also
    union is replaced by structure it is impossible to track
    fieldindex for union member accesses.

    Three intrinsic functions, preserve_{array,union,struct}_access_index,
    are introducted.
      addr = preserve_array_access_index(base, index, dimension)
      addr = preserve_union_access_index(base, di_index)
      addr = preserve_struct_access_index(base, gep_index, di_index)
    here,
      base: the base pointer for the array/union/struct access.
      index: the last access index for array, the same for IR/DebugInfo layout.
      dimension: the array dimension.
      gep_index: the access index based on IR layout.
      di_index: the access index based on user/debuginfo types.

    If using these intrinsics blindly, i.e., transforming all GEPs
    to these intrinsics and later on reducing them to GEPs, we have
    seen up to 7% more instructions generated. To avoid such an overhead,
    a clang builtin is proposed:
      base = __builtin_preserve_access_index(base)
    such that user wraps to-be-relocated GEPs in this builtin
    and preserve_*_access_index intrinsics only apply to
    those GEPs. Such a buyin will prevent performance degradation
    if people do not use CO-RE, even for programs which use
    bpf_probe_read().

    For example, for the following example,
      $ cat test.c
      struct sk_buff {
         int i;
         int b1:1;
         int b2:2;
         union {
           struct {
             int o1;
             int o2;
           } o;
           struct {
             char flags;
             char dev_id;
           } dev;
           int netid;
         } u[10];
      };

      static int (*bpf_probe_read)(void *dst, int size, const void *unsafe_ptr)
          = (void *) 4;

      #define _(x) (__builtin_preserve_access_index(x))

      int bpf_prog(struct sk_buff *ctx) {
        char dev_id;
        bpf_probe_read(&dev_id, sizeof(char), _(&ctx->u[5].dev.dev_id));
        return dev_id;
      }
      $ clang -target bpf -O2 -g -emit-llvm -S -mllvm -print-before-all \
        test.c >& log

    The generated IR looks like below:
      ...
      define dso_local i32 @bpf_prog(%struct.sk_buff*) #0 !dbg !15 {
        %2 = alloca %struct.sk_buff*, align 8
        %3 = alloca i8, align 1
        store %struct.sk_buff* %0, %struct.sk_buff** %2, align 8, !tbaa !45
        call void @llvm.dbg.declare(metadata %struct.sk_buff** %2, metadata !43, metadata !DIExpression()), !dbg !49
        call void @llvm.lifetime.start.p0i8(i64 1, i8* %3) #4, !dbg !50
        call void @llvm.dbg.declare(metadata i8* %3, metadata !44, metadata !DIExpression()), !dbg !51
        %4 = load i32 (i8*, i32, i8*)*, i32 (i8*, i32, i8*)** @bpf_probe_read, align 8, !dbg !52, !tbaa !45
        %5 = load %struct.sk_buff*, %struct.sk_buff** %2, align 8, !dbg !53, !tbaa !45
        %6 = call [10 x %union.anon]* @llvm.preserve.struct.access.index.p0a10s_union.anons.p0s_struct.sk_buffs(
             %struct.sk_buff* %5, i32 2, i32 3), !dbg !53, !llvm.preserve.access.index !19
        %7 = call %union.anon* @llvm.preserve.array.access.index.p0s_union.anons.p0a10s_union.anons(
             [10 x %union.anon]* %6, i32 1, i32 5), !dbg !53
        %8 = call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(
             %union.anon* %7, i32 1), !dbg !53, !llvm.preserve.access.index !26
        %9 = bitcast %union.anon* %8 to %struct.anon.0*, !dbg !53
        %10 = call i8* @llvm.preserve.struct.access.index.p0i8.p0s_struct.anon.0s(
             %struct.anon.0* %9, i32 1, i32 1), !dbg !53, !llvm.preserve.access.index !34
        %11 = call i32 %4(i8* %3, i32 1, i8* %10), !dbg !52
        %12 = load i8, i8* %3, align 1, !dbg !54, !tbaa !55
        %13 = sext i8 %12 to i32, !dbg !54
        call void @llvm.lifetime.end.p0i8(i64 1, i8* %3) #4, !dbg !56
        ret i32 %13, !dbg !57
      }

      !19 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "sk_buff", file: !3, line: 1, size: 704, elements: !20)
      !26 = distinct !DICompositeType(tag: DW_TAG_union_type, scope: !19, file: !3, line: 5, size: 64, elements: !27)
      !34 = distinct !DICompositeType(tag: DW_TAG_structure_type, scope: !26, file: !3, line: 10, size: 16, elements: !35)

    Note that @llvm.preserve.{struct,union}.access.index calls have metadata llvm.preserve.access.index
    attached to instructions to provide struct/union debuginfo type information.

    For &ctx->u[5].dev.dev_id,
      . The "%6 = ..." represents struct member "u" with index 2 for IR layout and index 3 for DI layout.
      . The "%7 = ..." represents array subscript "5".
      . The "%8 = ..." represents union member "dev" with index 1 for DI layout.
      . The "%10 = ..." represents struct member "dev_id" with index 1 for both IR and DI layout.

    Basically, traversing the use-def chain recursively for the 3rd argument of bpf_probe_read() and
    examining all preserve_*_access_index calls, the debuginfo struct/union/array access index
    can be achieved.

    The intrinsics also contain enough information to regenerate codes for IR layout.
    For array and structure intrinsics, the proper GEP can be constructed.
    For union intrinsics, replacing all uses of "addr" with "base" should be enough.

    Signed-off-by: Yonghong Song <yhs@fb.com>

    Differential Revision: https://reviews.llvm.org/D61809 (detail)
    by yhs
  4. [LoopInfo] Update getExitEdges to accept vector of pairs for non const BasicBlock

    D63921 requires getExitEdges fills a vector of Edge pairs where
    BasicBlocks are not constant.

    The rest Loop API mostly returns non-const BasicBlocks, so to be more consistent with
    other Loop API getExitEdges is modified to return non-const BasicBlocks as well.

    This is an alternative solution to D64060.

    Reviewers: reames, fhahn
    Reviewed By: reames, fhahn
    Subscribers: hiraditya, llvm-commits
    Differential Revision: https://reviews.llvm.org/D64309 (detail)
    by skatkov
  5. Revert "[BPF] Preserve debuginfo array/union/struct type/access index"

    This reverts commit r365435.

    Forgot adding the Differential Revision link. Will add to the
    commit message and resubmit. (detail)
    by yhs
  6. [BPF] Preserve debuginfo array/union/struct type/access index

    For background of BPF CO-RE project, please refer to
      http://vger.kernel.org/bpfconf2019.html
    In summary, BPF CO-RE intends to compile bpf programs
    adjustable on struct/union layout change so the same
    program can run on multiple kernels with adjustment
    before loading based on native kernel structures.

    In order to do this, we need keep track of GEP(getelementptr)
    instruction base and result debuginfo types, so we
    can adjust on the host based on kernel BTF info.
    Capturing such information as an IR optimization is hard
    as various optimization may have tweaked GEP and also
    union is replaced by structure it is impossible to track
    fieldindex for union member accesses.

    Three intrinsic functions, preserve_{array,union,struct}_access_index,
    are introducted.
      addr = preserve_array_access_index(base, index, dimension)
      addr = preserve_union_access_index(base, di_index)
      addr = preserve_struct_access_index(base, gep_index, di_index)
    here,
      base: the base pointer for the array/union/struct access.
      index: the last access index for array, the same for IR/DebugInfo layout.
      dimension: the array dimension.
      gep_index: the access index based on IR layout.
      di_index: the access index based on user/debuginfo types.

    If using these intrinsics blindly, i.e., transforming all GEPs
    to these intrinsics and later on reducing them to GEPs, we have
    seen up to 7% more instructions generated. To avoid such an overhead,
    a clang builtin is proposed:
      base = __builtin_preserve_access_index(base)
    such that user wraps to-be-relocated GEPs in this builtin
    and preserve_*_access_index intrinsics only apply to
    those GEPs. Such a buyin will prevent performance degradation
    if people do not use CO-RE, even for programs which use
    bpf_probe_read().

    For example, for the following example,
      $ cat test.c
      struct sk_buff {
         int i;
         int b1:1;
         int b2:2;
         union {
           struct {
             int o1;
             int o2;
           } o;
           struct {
             char flags;
             char dev_id;
           } dev;
           int netid;
         } u[10];
      };

      static int (*bpf_probe_read)(void *dst, int size, const void *unsafe_ptr)
          = (void *) 4;

      #define _(x) (__builtin_preserve_access_index(x))

      int bpf_prog(struct sk_buff *ctx) {
        char dev_id;
        bpf_probe_read(&dev_id, sizeof(char), _(&ctx->u[5].dev.dev_id));
        return dev_id;
      }
      $ clang -target bpf -O2 -g -emit-llvm -S -mllvm -print-before-all \
        test.c >& log

    The generated IR looks like below:
      ...
      define dso_local i32 @bpf_prog(%struct.sk_buff*) #0 !dbg !15 {
        %2 = alloca %struct.sk_buff*, align 8
        %3 = alloca i8, align 1
        store %struct.sk_buff* %0, %struct.sk_buff** %2, align 8, !tbaa !45
        call void @llvm.dbg.declare(metadata %struct.sk_buff** %2, metadata !43, metadata !DIExpression()), !dbg !49
        call void @llvm.lifetime.start.p0i8(i64 1, i8* %3) #4, !dbg !50
        call void @llvm.dbg.declare(metadata i8* %3, metadata !44, metadata !DIExpression()), !dbg !51
        %4 = load i32 (i8*, i32, i8*)*, i32 (i8*, i32, i8*)** @bpf_probe_read, align 8, !dbg !52, !tbaa !45
        %5 = load %struct.sk_buff*, %struct.sk_buff** %2, align 8, !dbg !53, !tbaa !45
        %6 = call [10 x %union.anon]* @llvm.preserve.struct.access.index.p0a10s_union.anons.p0s_struct.sk_buffs(
             %struct.sk_buff* %5, i32 2, i32 3), !dbg !53, !llvm.preserve.access.index !19
        %7 = call %union.anon* @llvm.preserve.array.access.index.p0s_union.anons.p0a10s_union.anons(
             [10 x %union.anon]* %6, i32 1, i32 5), !dbg !53
        %8 = call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(
             %union.anon* %7, i32 1), !dbg !53, !llvm.preserve.access.index !26
        %9 = bitcast %union.anon* %8 to %struct.anon.0*, !dbg !53
        %10 = call i8* @llvm.preserve.struct.access.index.p0i8.p0s_struct.anon.0s(
             %struct.anon.0* %9, i32 1, i32 1), !dbg !53, !llvm.preserve.access.index !34
        %11 = call i32 %4(i8* %3, i32 1, i8* %10), !dbg !52
        %12 = load i8, i8* %3, align 1, !dbg !54, !tbaa !55
        %13 = sext i8 %12 to i32, !dbg !54
        call void @llvm.lifetime.end.p0i8(i64 1, i8* %3) #4, !dbg !56
        ret i32 %13, !dbg !57
      }

      !19 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "sk_buff", file: !3, line: 1, size: 704, elements: !20)
      !26 = distinct !DICompositeType(tag: DW_TAG_union_type, scope: !19, file: !3, line: 5, size: 64, elements: !27)
      !34 = distinct !DICompositeType(tag: DW_TAG_structure_type, scope: !26, file: !3, line: 10, size: 16, elements: !35)

    Note that @llvm.preserve.{struct,union}.access.index calls have metadata llvm.preserve.access.index
    attached to instructions to provide struct/union debuginfo type information.

    For &ctx->u[5].dev.dev_id,
      . The "%6 = ..." represents struct member "u" with index 2 for IR layout and index 3 for DI layout.
      . The "%7 = ..." represents array subscript "5".
      . The "%8 = ..." represents union member "dev" with index 1 for DI layout.
      . The "%10 = ..." represents struct member "dev_id" with index 1 for both IR and DI layout.

    Basically, traversing the use-def chain recursively for the 3rd argument of bpf_probe_read() and
    examining all preserve_*_access_index calls, the debuginfo struct/union/array access index
    can be achieved.

    The intrinsics also contain enough information to regenerate codes for IR layout.
    For array and structure intrinsics, the proper GEP can be constructed.
    For union intrinsics, replacing all uses of "addr" with "base" should be enough.

    Signed-off-by: Yonghong Song <yhs@fb.com> (detail)
    by yhs
  7. [NFC][PowerPC] Fixed unused variable 'NewInstr'. (detail)
    by lkail
  8. [AMDGPU] Added td definitions for HW regs

    Infrastructure work for future commit. NFC.

    Differential Revision: https://reviews.llvm.org/D64370 (detail)
    by rampitec
  9. [AMDGPU] Always use s_memtime for readcyclecounter

    Differential Revision: https://reviews.llvm.org/D64369 (detail)
    by rampitec
  10. [PowerPC][Peephole] Combine extsw and sldi after instruction selection

    Summary:
    `extsw` and `sldi` are supposed to be combined if they are in the same
    BB in instruction selection phase. This patch handles the case where
    extsw and sldi are not in the same BB.

    Differential Revision: https://reviews.llvm.org/D63806 (detail)
    by lkail
  11. [PowerPC][NFC] remove redundant function isVFReg(). (detail)
    by shchenz
  12. [MachinePipeliner] Fix Phi refers to Phi in same stage in 1st epilogue

    Summary:
    This is exposed by functional testing on PowerPC.
    In some pipelined loops, Phi refer to phi did not get value defined by
    the Phi, hence getting wrong value later.

    As the comment mentioned, we should "use the value defined by the Phi,
    unless we're generating the firstepilog and the Phi refers to a Phi
    in a different stage.", so Phi refering to same stage Phi should use
    the value defined by the Phi here.

    Reviewers: bcahoon, hfinkel

    Reviewed By: hfinkel

    Subscribers: MaskRay, wuzish, nemanjai, hiraditya, llvm-commits

    Tags: #llvm

    Differential Revision: https://reviews.llvm.org/D64035 (detail)
    by jsji
  13. [PowerPC][MachinePipeliner][NFC] Add a testcase for Phi bug. (detail)
    by jsji
  14. [WebAssembly] Make sret parameter work with AddMissingPrototypes

    Summary:
    Even with functions with `no-prototype` attribute, there can be an
    argument `sret` (structure return) attribute, which is an optimization
    when a function return type is a struct. Fixes PR42420.

    Reviewers: sbc100

    Subscribers: dschuff, jgravelle-google, llvm-commits

    Tags: #llvm

    Differential Revision: https://reviews.llvm.org/D64318 (detail)
    by aheejin
  15. [LoopPred] Stylistic improvement to recently added NE/EQ normalization [NFC] (detail)
    by reames
  16. [sanitizers][windows] FIX: Rtl-Heap Interception and tests

       - Adds interceptors for Rtl[Allocate|Free|Size|ReAllocate]Heap
       - Adds unit tests for the new interceptors and expands HeapAlloc
         tests to demonstrate new functionality.
       Reviewed as D62927
       - adds fixes for ~win and x64 tests

    llvm-svn: 365381 (detail)
    by mcgov
  17. [BPF] add new intrinsics preserve_{array,union,struct}_access_index

    For background of BPF CO-RE project, please refer to
      http://vger.kernel.org/bpfconf2019.html
    In summary, BPF CO-RE intends to compile bpf programs
    adjustable on struct/union layout change so the same
    program can run on multiple kernels with adjustment
    before loading based on native kernel structures.

    In order to do this, we need keep track of GEP(getelementptr)
    instruction base and result debuginfo types, so we
    can adjust on the host based on kernel BTF info.
    Capturing such information as an IR optimization is hard
    as various optimization may have tweaked GEP and also
    union is replaced by structure it is impossible to track
    fieldindex for union member accesses.

    Three intrinsic functions, preserve_{array,union,struct}_access_index,
    are introducted.
      addr = preserve_array_access_index(base, index, dimension)
      addr = preserve_union_access_index(base, di_index)
      addr = preserve_struct_access_index(base, gep_index, di_index)
    here,
      base: the base pointer for the array/union/struct access.
      index: the last access index for array, the same for IR/DebugInfo layout.
      dimension: the array dimension.
      gep_index: the access index based on IR layout.
      di_index: the access index based on user/debuginfo types.

    For example, for the following example,
      $ cat test.c
      struct sk_buff {
         int i;
         int b1:1;
         int b2:2;
         union {
           struct {
             int o1;
             int o2;
           } o;
           struct {
             char flags;
             char dev_id;
           } dev;
           int netid;
         } u[10];
      };

      static int (*bpf_probe_read)(void *dst, int size, const void *unsafe_ptr)
          = (void *) 4;

      #define _(x) (__builtin_preserve_access_index(x))

      int bpf_prog(struct sk_buff *ctx) {
        char dev_id;
        bpf_probe_read(&dev_id, sizeof(char), _(&ctx->u[5].dev.dev_id));
        return dev_id;
      }
      $ clang -target bpf -O2 -g -emit-llvm -S -mllvm -print-before-all \
        test.c >& log

    The generated IR looks like below:

      ...
      define dso_local i32 @bpf_prog(%struct.sk_buff*) #0 !dbg !15 {
        %2 = alloca %struct.sk_buff*, align 8
        %3 = alloca i8, align 1
        store %struct.sk_buff* %0, %struct.sk_buff** %2, align 8, !tbaa !45
        call void @llvm.dbg.declare(metadata %struct.sk_buff** %2, metadata !43, metadata !DIExpression()), !dbg !49
        call void @llvm.lifetime.start.p0i8(i64 1, i8* %3) #4, !dbg !50
        call void @llvm.dbg.declare(metadata i8* %3, metadata !44, metadata !DIExpression()), !dbg !51
        %4 = load i32 (i8*, i32, i8*)*, i32 (i8*, i32, i8*)** @bpf_probe_read, align 8, !dbg !52, !tbaa !45
        %5 = load %struct.sk_buff*, %struct.sk_buff** %2, align 8, !dbg !53, !tbaa !45
        %6 = call [10 x %union.anon]* @llvm.preserve.struct.access.index.p0a10s_union.anons.p0s_struct.sk_buffs(
             %struct.sk_buff* %5, i32 2, i32 3), !dbg !53, !llvm.preserve.access.index !19
        %7 = call %union.anon* @llvm.preserve.array.access.index.p0s_union.anons.p0a10s_union.anons(
             [10 x %union.anon]* %6, i32 1, i32 5), !dbg !53
        %8 = call %union.anon* @llvm.preserve.union.access.index.p0s_union.anons.p0s_union.anons(
             %union.anon* %7, i32 1), !dbg !53, !llvm.preserve.access.index !26
        %9 = bitcast %union.anon* %8 to %struct.anon.0*, !dbg !53
        %10 = call i8* @llvm.preserve.struct.access.index.p0i8.p0s_struct.anon.0s(
             %struct.anon.0* %9, i32 1, i32 1), !dbg !53, !llvm.preserve.access.index !34
        %11 = call i32 %4(i8* %3, i32 1, i8* %10), !dbg !52
        %12 = load i8, i8* %3, align 1, !dbg !54, !tbaa !55
        %13 = sext i8 %12 to i32, !dbg !54
        call void @llvm.lifetime.end.p0i8(i64 1, i8* %3) #4, !dbg !56
        ret i32 %13, !dbg !57
      }

      !19 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "sk_buff", file: !3, line: 1, size: 704, elements: !20)
      !26 = distinct !DICompositeType(tag: DW_TAG_union_type, scope: !19, file: !3, line: 5, size: 64, elements: !27)
      !34 = distinct !DICompositeType(tag: DW_TAG_structure_type, scope: !26, file: !3, line: 10, size: 16, elements: !35)

    Note that @llvm.preserve.{struct,union}.access.index calls have metadata llvm.preserve.access.index
    attached to instructions to provide struct/union debuginfo type information.

    For &ctx->u[5].dev.dev_id,
      . The "%6 = ..." represents struct member "u" with index 2 for IR layout and index 3 for DI layout.
      . The "%7 = ..." represents array subscript "5".
      . The "%8 = ..." represents union member "dev" with index 1 for DI layout.
      . The "%10 = ..." represents struct member "dev_id" with index 1 for both IR and DI layout.

    Basically, traversing the use-def chain recursively for the 3rd argument of bpf_probe_read() and
    examining all preserve_*_access_index calls, the debuginfo struct/union/array access index
    can be achieved.

    The intrinsics also contain enough information to regenerate codes for IR layout.
    For array and structure intrinsics, the proper GEP can be constructed.
    For union intrinsics, replacing all uses of "addr" with "base" should be enough.

    The test case ThinLTO/X86/lazyload_metadata.ll is adjusted to reflect the
    new addition of the metadata.

    Signed-off-by: Yonghong Song <yhs@fb.com>

    Differential Revision: https://reviews.llvm.org/D61810 (detail)
    by yhs
  18. [sanitizers][windows] Rtl-Heap Interception and tests
       - Adds interceptors for Rtl[Allocate|Free|Size|ReAllocate]Heap
       - Adds unit tests for the new interceptors and expands HeapAlloc
         tests to demonstrate new functionality.
       Reviewed as D62927 (detail)
    by mcgov
  19. [LoopPred] Extend LFTR normalization to the inverse EQ case

    A while back, I added support for NE latches formed by LFTR.  I didn't think that quite through, as LFTR will also produce the inverse EQ form for some loops and I hadn't handled that.  This change just adds handling for that case as well. (detail)
    by reames
  20. [WebAssembly] Fix a typo in a test file name

    Reviewers: sbc100

    Subscribers: dschuff, jgravelle-google, sunfish, llvm-commits

    Tags: #llvm

    Differential Revision: https://reviews.llvm.org/D64324 (detail)
    by aheejin
  21. Changing CodeView debug info type record representation in assembly files to make it more human-readable & editable & fixing bug introduced in r364987 (detail)
    by nilanjana_basu
  22. [TSan] Fix linker error for Linux/AArch64 (detail)
    by yln
  23. Use `ln -n` to prevent forming a symlink cycle, instead of rm'ing the source

    This is a better fix for the problem fixed in r334972.

    Also remove the rm'ing of the symlink destination that was there to
    clean up the bots -- it's over a year later, bots should be happy now.

    Differential Revision: https://reviews.llvm.org/D64301 (detail)
    by nico
  24. Let unaliased Args track which Alias they were created from, and use that in Arg::getAsString() for diagnostics

    With this, `clang-cl /source-charset:utf-16 test.cc` now prints `invalid
    value 'utf-16' in '/source-charset:utf-16'` instead of `invalid value
    'utf-16' in '-finput-charset=utf-16'` before, and several other clang-cl
    flags produce much less confusing output as well.

    Fixes PR29106.

    Since an arg and its alias can have different arg types (joined vs not)
    and different values (because of AliasArgs<>), I chose to give the Alias
    its own Arg object. For convenience, I just store the alias directly in
    the unaliased arg – there aren't many arg objects at runtime, so that
    seems ok.

    Finally, I changed Arg::getAsString() to use the alias's representation
    if it's present – that function was already documented as being the
    suitable function for diagnostics, and most callers already used it for
    diagnostics.

    Implementation-wise, Arg::accept() previously used to parse things as
    the unaliased option. The core of that switch is now extracted into a
    new function acceptInternal() which parses as the _aliased_ option, and
    the previously-intermingled unaliasing is now done as an explicit step
    afterwards.

    (This also changes one place in lld that didn't use getAsString() for
    diagnostics, so that that one place now also prints the flag as the user
    wrote it, not as it looks after it went through unaliasing.)

    Differential Revision: https://reviews.llvm.org/D64253 (detail)
    by nico
  25. [X86][PPC] Support -mlong-double-64

    -mlong-double-64 is supported on some ports of gcc (i386, x86_64, and ppc{32,64}).
    On many other targets, there will be an error:

        error: unrecognized command line option '-mlong-double-64'

    This patch makes the driver option -mlong-double-64 available for x86
    and ppc. The CC1 option -mlong-double-64 is available on all targets for
    users to test on unsupported targets.

    LongDoubleSize is added as a VALUE_LANGOPT so that the option can be
    shared with -mlong-double-128 when we support it in clang.

    Also, make powerpc*-linux-musl default to use 64-bit long double. It is
    currently the only supported ABI on musl and is also how people
    configure powerpc*-linux-musl-gcc.

    Reviewed By: rnk

    Differential Revision: https://reviews.llvm.org/D64067 (detail)
    by maskray
  26. clang-cl: Port cl.exe's C4659 to clang-cl

    Differential Revision: https://reviews.llvm.org/D64349 (detail)
    by nico
  27. [analyzer] exploded-graph-rewriter: Implement a topology-only mode.

    In this mode the rewriter will only rewrite program points
    and omit program states. Useful for understanding
    the rough topology of the graph.

    Differential Revision: https://reviews.llvm.org/D64264 (detail)
    by dergachev
  28. [analyzer] exploded-graph-rewriter: Implement a single-path mode.

    Instead of rewriting the whole graph, rewrite the leftmost path in the
    graph. Useful for trimmed graphs that are still too large to display due
    to multiple equivalent reports mixed into them.

    Differential Revision: https://reviews.llvm.org/D64263 (detail)
    by dergachev
  29. [ObjC] Add a -Wtautological-compare warning for BOOL

    On macOS, BOOL is a typedef for signed char, but it should never hold a value
    that isn't 1 or 0. Any code that expects a different value in their BOOL should
    be fixed.

    rdar://51954400

    Differential revision: https://reviews.llvm.org/D63856 (detail)
    by epilk
  30. [Attributor] Deduce the "returned" argument attribute

    Deduce the "returned" argument attribute by collecting all potentially
    returned values.

    Not only the unique return value, if any, can be used by subsequent
    attributes but also the set of all potentially returned values as well
    as the mapping from returned values to return instructions that they
    originate from (see AAReturnedValues::checkForallReturnedValues).

    Change in statistics (-stats) for LLVM-TS + Spec2006, totaling ~19% more "returned" arguments.

      ADDED: attributor                   NumAttributesManifested                  n/a ->        637
      ADDED: attributor                   NumAttributesValidFixpoint               n/a ->      25545
      ADDED: attributor                   NumFnArgumentReturned                    n/a ->        637
      ADDED: attributor                   NumFnKnownReturns                        n/a ->      25545
      ADDED: attributor                   NumFnUniqueReturned                      n/a ->      14118
    CHANGED: deadargelim                  NumRetValsEliminated                     470 ->        449 (    -4.468%)
    REMOVED: functionattrs                NumReturned                              535 ->        n/a
    CHANGED: indvars                      NumElimIdentity                          138 ->        164 (   +18.841%)

    Reviewers: homerdin, hfinkel, fedor.sergeev, sanjoy, spatel, nlopes, nicholas, reames, efriedma, chandlerc

    Subscribers: hiraditya, bollu, cfe-commits, llvm-commits

    Tags: #clang, #llvm

    Differential Revision: https://reviews.llvm.org/D59919 (detail)
    by jdoerfert
  31. [cxx2a] P0624R2 fix: only lambdas with no lambda-capture are default-constructible and assignable.

    This is a fix for rG864949 which only disabled default construction and
    assignment for lambdas with capture-defaults, where the C++2a draft
    disables them for lambdas with any lambda-capture at all.

    Patch by Logan Smith!

    Differential Revision: https://reviews.llvm.org/D64058 (detail)
    by dblaikie
  32. [Frontend] Explicitly include Bitstream/BitCodes.h and BitstreamWriter.h

    This fixes a modules issue:

    error: declaration of 'bitc' must be imported from module
    'Clang_Serialization.ASTBitCodes' before it is required
    Stream.EmitRecord(llvm::bitc::BLOCKINFO_CODE_SETBID, Record); (detail)
    by thegameg
  33. [AArch64][GlobalISel] Use TST for comparisons when possible

    Porting over the part of `emitComparison` in AArch64ISelLowering where we use
    TST to represent a compare.

    - Rename `tryOptCMN` to `tryFoldIntegerCompare`, since it now also emits TSTs
      when possible.

    - Add a utility function for emitting a TST with register operands.

    - Rename opt-fold-cmn.mir to opt-fold-compare.mir, since it now also tests the
      TST fold as well.

    Differential Revision: https://reviews.llvm.org/D64371 (detail)
    by paquette
  34. Fix line endings. NFC (detail)
    by probinson
  35. [llvm-profdata] Fix buildbot failure on llvm-clang-x86_64-expensive-checks-win

    This fixes buildbot failure in LLVM on llvm-clang-x86_64-expensive-checks-win
    from r365386. (detail)
    by xur
  36. [Sanitizers] Remove clang_rt.sancov_{begin,end} on Solaris

    There's no point to manually create the __start___sancov_guards and __stop___sancov_guards
    sections and labels on Solaris any longer.  They were originally introduced in
    https://reviews.llvm.org/D40899 and https://reviews.llvm.org/D40903.

    - The Solaris 11.4 ld supports creating them out of the box.
    - We already unconditionally use Solaris 11.4 features like the ld -z gnu-version-script-compat option and fully working .preinit_array support in compiler-rt.
    - The current files don't assemble on SPARC because the assembler syntax may be different between /bin/as and GNU as.

    Tested on amd64-pc-solaris2.11.

    Differential Revision: https://reviews.llvm.org/D63601 (detail)
    by ro
  37. AMDGPU: Split extload/zextload local load patterns

    This will help removing the custom load predicates, allowing the
    global isel emitter to handle them. (detail)
    by arsenm
  38. [Sanitizers] Don't use clang_rt.sancov_{begin,end} on Solaris

    As explained in https://reviews.llvm.org/D63601, there's no point using clang_rt.sancov_{begin,end}
    on Solaris any longer.

    This companion patch to the above removes their use from the driver.

    Tested on amd64-pc-solaris2.11

    Differential Revision: https://reviews.llvm.org/D63602 (detail)
    by ro
  39. Add parentheses to silence warnings. (detail)
    by void
  40. Add parentheses to silence warning. (detail)
    by void
  41. Revert [Sema] Resolve placeholder types before type deduction to silence spurious `-Warc-repeated-use-of-weak` warnings

    This reverts r365382 (git commit 8b1becf2e31d9170ee356a19c7b6ea991d3a520f)

    Appears to regress this semi-reduced fragment of valid code from windows
    SDK headers:

      #define InterlockedIncrement64 _InterlockedIncrement64
      extern "C" __int64 InterlockedIncrement64(__int64 volatile *Addend);
      #pragma intrinsic(_InterlockedIncrement64)
      unsigned __int64 InterlockedIncrement(unsigned __int64 volatile *Addend) {
        return (unsigned __int64)(InterlockedIncrement64)((volatile __int64 *)Addend);
      }

    Found on a buildbot here, but no mail was sent due to it already being
    red:
    http://lab.llvm.org:8011/builders/sanitizer-windows/builds/48067 (detail)
    by rnk

Started by upstream project clang-stage2-cmake-RgSan_relay build number 1172
originally caused by:

This run spent:

  • 1 ms waiting;
  • 9 hr 58 min build duration;
  • 9 hr 58 min total from scheduled to completion.
Test Result (2 failures / ±0)Show all failed tests >>>

Identified problems

Regression test failed

This build failed because a regression test in the test suite FAILed. See the test report for details.
Indication 1

Ninja target failed

Below is a link to the first failed ninja target.
Indication 2