Skip to content
Snippets Groups Projects
  1. Sep 01, 2016
  2. Aug 20, 2016
  3. Aug 19, 2016
  4. Aug 15, 2016
  5. Jul 28, 2016
  6. Jul 27, 2016
  7. Jul 14, 2016
  8. Jun 28, 2016
    • Richard Smith's avatar
    • Richard Smith's avatar
      cxx_status: fix footnote for p0136. · 430507b7
      Richard Smith authored
      git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@274059 91177308-0d34-0410-b5e6-96231b3b80d8
      430507b7
    • Richard Smith's avatar
      Update cxx_dr_status from test/CXX/drs. · 838ecaae
      Richard Smith authored
      git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@274058 91177308-0d34-0410-b5e6-96231b3b80d8
      838ecaae
    • Richard Smith's avatar
      P0136R1, DR1573, DR1645, DR1715, DR1736, DR1903, DR1941, DR1959, DR1991: · 5be817d9
      Richard Smith authored
      Replace inheriting constructors implementation with new approach, voted into
      C++ last year as a DR against C++11.
      
      Instead of synthesizing a set of derived class constructors for each inherited
      base class constructor, we make the constructors of the base class visible to
      constructor lookup in the derived class, using the normal rules for
      using-declarations.
      
      For constructors, UsingShadowDecl now has a ConstructorUsingShadowDecl derived
      class that tracks the requisite additional information. We create shadow
      constructors (not found by name lookup) in the derived class to model the
      actual initialization, and have a new expression node,
      CXXInheritedCtorInitExpr, to model the initialization of a base class from such
      a constructor. (This initialization is special because it performs real perfect
      forwarding of arguments.)
      
      In cases where argument forwarding is not possible (for inalloca calls,
      variadic calls, and calls with callee parameter cleanup), the shadow inheriting
      constructor is not emitted and instead we directly emit the initialization code
      into the caller of the inherited constructor.
      
      Note that this new model is not perfectly compatible with the old model in some
      corner cases. In particular:
       * if B inherits a private constructor from A, and C uses that constructor to
         construct a B, then we previously required that A befriends B and B
         befriends C, but the new rules require A to befriend C directly, and
       * if a derived class has its own constructors (and so its implicit default
         constructor is suppressed), it may still inherit a default constructor from
         a base class
      
      
      git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@274049 91177308-0d34-0410-b5e6-96231b3b80d8
      5be817d9
  9. Jun 25, 2016
  10. Jun 24, 2016
  11. Jun 23, 2016
  12. Jun 13, 2016
  13. May 06, 2016
  14. May 05, 2016
  15. Apr 20, 2016
  16. Apr 11, 2016
    • Reid Kleckner's avatar
      Update getting started docs · 500f7868
      Reid Kleckner authored
      compiler-rt is optional. We often get email from users with compiler-rt
      build errors who don't actually need compiler-rt. Marking it optional
      should help them avoid those potential problems.
      
      While I'm here, update a reference to the build directory and remove an
      obsolete reference to llvm-gcc. Nobody today is under the impression
      that Clang depends on GCC.
      
      git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@265963 91177308-0d34-0410-b5e6-96231b3b80d8
      500f7868
  17. Mar 28, 2016
  18. Mar 23, 2016
  19. Mar 21, 2016
    • Faisal Vali's avatar
      [Cxx1z] Implement Lambda Capture of *this by Value as [=,*this] (P0018R3) · 60783472
      Faisal Vali authored
      Implement lambda capture of *this by copy.
      For e.g.:
      struct A {
      
        int d = 10;
        auto foo() { return [*this] (auto a) mutable { d+=a; return d; }; }
      
      };
      
      auto L = A{}.foo(); // A{}'s lifetime is gone.
      
      // Below is still ok, because *this was captured by value.
      assert(L(10) == 20);
      assert(L(100) == 120);
      
      If the capture was implicit, or [this] (i.e. *this was captured by reference), this code would be otherwise undefined.
      
      Implementation Strategy:
        - amend the parser to accept *this in the lambda introducer
        - add a new king of capture LCK_StarThis
        - teach Sema::CheckCXXThisCapture to handle by copy captures of the
          enclosing object (i.e. *this)
        - when CheckCXXThisCapture does capture by copy, the corresponding 
          initializer expression for the closure's data member 
          direct-initializes it thus making a copy of '*this'.
        - in codegen, when assigning to CXXThisValue, if *this was captured by 
          copy, make sure it points to the corresponding field member, and
          not, unlike when captured by reference, what the field member points
          to.
        - mark feature as implemented in svn
      
      Much gratitude to Richard Smith for his carefully illuminating reviews!   
      
      
      git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@263921 91177308-0d34-0410-b5e6-96231b3b80d8
      60783472
  20. Mar 20, 2016
  21. Mar 09, 2016
  22. Mar 08, 2016
  23. Mar 07, 2016
Loading