1 # http://lists.llvm.org/pipermail/llvm-dev/2015-October/091115.html

     2 # - 22031298 - toxic bugs in LLVM ilist/plist end up eliminating entire

     3 # MachineBasicBlocks

     4 # - Presumed fixed (?) in trunk upstream. Not verified.

     5 # - Verified fixed in our 3.6.2 fork.

     6 # Not for upstream. Autoconf-based built system is removed in 3.8.X.

     7 --- Makefile.rules	2015-10-05 11:01:32.687305595 -0700

     8 +++ Makefile.rules	2015-12-08 11:12:41.094567698 -0800

     9 @@ -331,6 +331,12 @@

    10   endif

    11  endif

    12  

    13 +ifeq ($(HOST_OS), $(filter $(HOST_OS), SunOS))

    14 +  REQUIRES_EH := 1

    15 +else

    16 +  REQUIRES_EH := 0

    17 +endif

    18 +

    19  ifeq ($(ENABLE_WERROR),1)

    20    CXX.Flags += -Werror

    21    C.Flags += -Werror

    22 @@ -355,14 +361,16 @@

    23  endif

    24  

    25  # IF REQUIRES_EH=1 is specified then don't disable exceptions

    26 -ifndef REQUIRES_EH

    27 +ifneq ($(REQUIRES_EH), 1)

    28 +  REQUIRES_RTTI := 0

    29    CXX.Flags += -fno-exceptions

    30  else

    31    # If the library requires EH, it also requires RTTI.

    32    REQUIRES_RTTI := 1

    33 +  CXX.Flags += -fexceptions

    34  endif

    35  

    36 -ifdef REQUIRES_FRAME_POINTER

    37 +ifeq ($(REQUIRES_FRAME_POINTER), 1)

    38    CXX.Flags := $(filter-out -fomit-frame-pointer,$(CXX.Flags))

    39    C.Flags   := $(filter-out -fomit-frame-pointer,$(C.Flags))

    40    LD.Flags  := $(filter-out -fomit-frame-pointer,$(LD.Flags))

    41 @@ -371,6 +379,8 @@

    42  # If REQUIRES_RTTI=1 is specified then don't disable run-time type id.

    43  ifneq ($(REQUIRES_RTTI), 1)

    44    CXX.Flags += -fno-rtti

    45 +else

    46 +  CXX.Flags += -frtti

    47  endif

    48  

    49  ifeq ($(ENABLE_COVERAGE),1)

    50 --- include/llvm/ADT/DenseMap.h	2015-10-05 11:01:32.000000000 -0700

    51 +++ include/llvm/ADT/DenseMap.h	2016-01-24 14:13:03.000000000 -0800

    52 @@ -254,7 +254,7 @@

    53    DenseMapBase() {}

    54  

    55    void destroyAll() {

    56 -    if ((getNumBuckets() == 0) || empty()) // Nothing to do.

    57 +    if (getNumBuckets() == 0) // Nothing to do.

    58        return;

    59  

    60      const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();

    61 @@ -264,10 +264,6 @@

    62          P->getSecond().~ValueT();

    63        P->getFirst().~KeyT();

    64      }

    65 -

    66 -#ifndef NDEBUG

    67 -    memset((void*)getBuckets(), 0x5a, sizeof(BucketT)*getNumBuckets());

    68 -#endif

    69    }

    70  

    71    void initEmpty() {

    72 @@ -856,7 +852,8 @@

    73  

    74        // First move the inline buckets into a temporary storage.

    75        AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;

    76 -      BucketT *TmpBegin = reinterpret_cast<BucketT *>(TmpStorage.buffer);

    77 +      BucketT *TmpBegin =

    78 +        reinterpret_cast<BucketT*>(reinterpret_cast<void*>(TmpStorage.buffer));

    79        BucketT *TmpEnd = TmpBegin;

    80  

    81        // Loop over the buckets, moving non-empty, non-tombstones into the

    82 @@ -940,17 +937,22 @@

    83      // Note that this cast does not violate aliasing rules as we assert that

    84      // the memory's dynamic type is the small, inline bucket buffer, and the

    85      // 'storage.buffer' static type is 'char *'.

    86 -    return reinterpret_cast<const BucketT *>(storage.buffer);

    87 +    return reinterpret_cast<const BucketT*>(

    88 +      reinterpret_cast<const void*>(storage.buffer));

    89    }

    90 +

    91    BucketT *getInlineBuckets() {

    92      return const_cast<BucketT *>(

    93        const_cast<const SmallDenseMap *>(this)->getInlineBuckets());

    94    }

    95 +

    96    const LargeRep *getLargeRep() const {

    97      assert(!Small);

    98      // Note, same rule about aliasing as with getInlineBuckets.

    99 -    return reinterpret_cast<const LargeRep *>(storage.buffer);

   100 +    return reinterpret_cast<const LargeRep*>(

   101 +      reinterpret_cast<const void*>(storage.buffer));

   102    }

   103 +

   104    LargeRep *getLargeRep() {

   105      return const_cast<LargeRep *>(

   106        const_cast<const SmallDenseMap *>(this)->getLargeRep());

   107 --- include/llvm/ADT/Optional.h	2014-09-30 19:12:35.000000000 -0700

   108 +++ include/llvm/ADT/Optional.h	2015-12-07 14:59:03.998240128 -0800

   109 @@ -163,16 +163,34 @@

   110      reset();

   111    }

   112  

   113 -  const T* getPointer() const { assert(hasVal); return reinterpret_cast<const T*>(storage.buffer); }

   114 -  T* getPointer() { assert(hasVal); return reinterpret_cast<T*>(storage.buffer); }

   115 -  const T& getValue() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }

   116 +  const T* getPointer() const {

   117 +    assert(hasVal);

   118 +    return reinterpret_cast<const T*>(

   119 +      reinterpret_cast<const void*>(storage.buffer));

   120 +  }

   121 +

   122 +  T* getPointer() {

   123 +    assert(hasVal);

   124 +    return reinterpret_cast<T*>(

   125 +      reinterpret_cast<void*>(storage.buffer));

   126 +  }

   127 +

   128 +  const T& getValue() const LLVM_LVALUE_FUNCTION {

   129 +    assert(hasVal);

   130 +    return *getPointer();

   131 +  }

   132 +

   133    T& getValue() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }

   134  

   135    LLVM_EXPLICIT operator bool() const { return hasVal; }

   136    bool hasValue() const { return hasVal; }

   137    const T* operator->() const { return getPointer(); }

   138    T* operator->() { return getPointer(); }

   139 -  const T& operator*() const LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }

   140 +  const T& operator*() const LLVM_LVALUE_FUNCTION {

   141 +    assert(hasVal);

   142 +    return *getPointer();

   143 +  }

   144 +

   145    T& operator*() LLVM_LVALUE_FUNCTION { assert(hasVal); return *getPointer(); }

   146  

   147    template <typename U>

   148 --- include/llvm/ADT/ilist.h	2014-07-28 17:38:55.000000000 -0700

   149 +++ include/llvm/ADT/ilist.h	2015-11-10 13:51:33.696789150 -0800

   150 @@ -104,6 +104,53 @@

   151    }

   152  };

   153  

   154 +template <typename NodeTy> class ilist_half_node;

   155 +template <typename NodeTy> class ilist_node;

   156 +

   157 +/// Traits with an embedded ilist_node as a sentinel.

   158 +///

   159 +/// FIXME: The downcast in createSentinel() is UB.

   160 +template <typename NodeTy> struct ilist_embedded_sentinel_traits {

   161 +  /// Get hold of the node that marks the end of the list.

   162 +  NodeTy *createSentinel() const {

   163 +    // Since i(p)lists always publicly derive from their corresponding traits,

   164 +    // placing a data member in this class will augment the i(p)list.  But since

   165 +    // the NodeTy is expected to be publicly derive from ilist_node<NodeTy>,

   166 +    // there is a legal viable downcast from it to NodeTy. We use this trick to

   167 +    // superimpose an i(p)list with a "ghostly" NodeTy, which becomes the

   168 +    // sentinel. Dereferencing the sentinel is forbidden (save the

   169 +    // ilist_node<NodeTy>), so no one will ever notice the superposition.

   170 +    return static_cast<NodeTy *>(&Sentinel);

   171 +  }

   172 +  static void destroySentinel(NodeTy *) {}

   173 +

   174 +  NodeTy *provideInitialHead() const { return createSentinel(); }

   175 +  NodeTy *ensureHead(NodeTy *) const { return createSentinel(); }

   176 +  static void noteHead(NodeTy *, NodeTy *) {}

   177 +

   178 +private:

   179 +  mutable ilist_node<NodeTy> Sentinel;

   180 +};

   181 +

   182 +/// Trait with an embedded ilist_half_node as a sentinel.

   183 +///

   184 +/// FIXME: The downcast in createSentinel() is UB.

   185 +template <typename NodeTy> struct ilist_half_embedded_sentinel_traits {

   186 +  /// Get hold of the node that marks the end of the list.

   187 +  NodeTy *createSentinel() const {

   188 +    // See comment in ilist_embedded_sentinel_traits::createSentinel().

   189 +    return static_cast<NodeTy *>(&Sentinel);

   190 +  }

   191 +  static void destroySentinel(NodeTy *) {}

   192 +

   193 +  NodeTy *provideInitialHead() const { return createSentinel(); }

   194 +  NodeTy *ensureHead(NodeTy *) const { return createSentinel(); }

   195 +  static void noteHead(NodeTy *, NodeTy *) {}

   196 +

   197 +private:

   198 +  mutable ilist_half_node<NodeTy> Sentinel;

   199 +};

   200 +

   201  /// ilist_node_traits - A fragment for template traits for intrusive list

   202  /// that provides default node related operations.

   203  ///

   204 @@ -173,8 +220,8 @@

   205    template<class T> void operator-(T) const;

   206  public:

   207  

   208 -  ilist_iterator(pointer NP) : NodePtr(NP) {}

   209 -  ilist_iterator(reference NR) : NodePtr(&NR) {}

   210 +  explicit ilist_iterator(pointer NP) : NodePtr(NP) {}

   211 +  explicit ilist_iterator(reference NR) : NodePtr(&NR) {}

   212    ilist_iterator() : NodePtr(nullptr) {}

   213  

   214    // This is templated so that we can allow constructing a const iterator from

   215 @@ -191,8 +238,10 @@

   216      return *this;

   217    }

   218  

   219 +  void reset(pointer NP) { NodePtr = NP; }

   220 +

   221    // Accessors...

   222 -  operator pointer() const {

   223 +  explicit operator pointer() const {

   224      return NodePtr;

   225    }

   226  

   227 @@ -237,14 +286,14 @@

   228  // These are to catch errors when people try to use them as random access

   229  // iterators.

   230  template<typename T>

   231 -void operator-(int, ilist_iterator<T>) LLVM_DELETED_FUNCTION;

   232 +void operator-(int, ilist_iterator<T>) = delete;

   233  template<typename T>

   234 -void operator-(ilist_iterator<T>,int) LLVM_DELETED_FUNCTION;

   235 +void operator-(ilist_iterator<T>,int) = delete;

   236  

   237  template<typename T>

   238 -void operator+(int, ilist_iterator<T>) LLVM_DELETED_FUNCTION;

   239 +void operator+(int, ilist_iterator<T>) = delete;

   240  template<typename T>

   241 -void operator+(ilist_iterator<T>,int) LLVM_DELETED_FUNCTION;

   242 +void operator+(ilist_iterator<T>,int) = delete;

   243  

   244  // operator!=/operator== - Allow mixed comparisons without dereferencing

   245  // the iterator, which could very likely be pointing to end().

   246 @@ -332,8 +381,8 @@

   247  

   248    // No fundamental reason why iplist can't be copyable, but the default

   249    // copy/copy-assign won't do.

   250 -  iplist(const iplist &) LLVM_DELETED_FUNCTION;

   251 -  void operator=(const iplist &) LLVM_DELETED_FUNCTION;

   252 +  iplist(const iplist &) = delete;

   253 +  void operator=(const iplist &) = delete;

   254  

   255  public:

   256    typedef NodeTy *pointer;

   257 @@ -422,7 +471,7 @@

   258      this->setPrev(CurNode, New);

   259  

   260      this->addNodeToList(New);  // Notify traits that we added a node...

   261 -    return New;

   262 +    return iterator(New);

   263    }

   264  

   265    iterator insertAfter(iterator where, NodeTy *New) {

   266 @@ -443,7 +492,7 @@

   267      else

   268        Head = NextNode;

   269      this->setPrev(NextNode, PrevNode);

   270 -    IT = NextNode;

   271 +    IT.reset(NextNode);

   272      this->removeNodeFromList(Node);  // Notify traits that we removed a node...

   273  

   274      // Set the next/prev pointers of the current node to null.  This isn't

   275 @@ -461,12 +510,18 @@

   276      return remove(MutIt);

   277    }

   278  

   279 +  NodeTy *remove(NodeTy *IT) { return remove(iterator(IT)); }

   280 +  NodeTy *remove(NodeTy &IT) { return remove(iterator(IT)); }

   281 +

   282    // erase - remove a node from the controlled sequence... and delete it.

   283    iterator erase(iterator where) {

   284      this->deleteNode(remove(where));

   285      return where;

   286    }

   287  

   288 +  iterator erase(NodeTy *IT) { return erase(iterator(IT)); }

   289 +  iterator erase(NodeTy &IT) { return erase(iterator(IT)); }

   290 +

   291    /// Remove all nodes from the list like clear(), but do not call

   292    /// removeNodeFromList() or deleteNode().

   293    ///

   294 @@ -522,7 +577,7 @@

   295        this->setNext(Last, PosNext);

   296        this->setPrev(PosNext, Last);

   297  

   298 -      this->transferNodesFromList(L2, First, PosNext);

   299 +      this->transferNodesFromList(L2, iterator(First), iterator(PosNext));

   300  

   301        // Now that everything is set, restore the pointers to the list sentinels.

   302        L2.setTail(L2Sentinel);

   303 @@ -579,6 +634,59 @@

   304    void splice(iterator where, iplist &L2, iterator first, iterator last) {

   305      if (first != last) transfer(where, L2, first, last);

   306    }

   307 +  void splice(iterator where, iplist &L2, NodeTy &N) {

   308 +    splice(where, L2, iterator(N));

   309 +  }

   310 +  void splice(iterator where, iplist &L2, NodeTy *N) {

   311 +    splice(where, L2, iterator(N));

   312 +  }

   313 +

   314 +  template <class Compare>

   315 +  void merge(iplist &Right, Compare comp) {

   316 +    if (this == &Right)

   317 +      return;

   318 +    iterator First1 = begin(), Last1 = end();

   319 +    iterator First2 = Right.begin(), Last2 = Right.end();

   320 +    while (First1 != Last1 && First2 != Last2) {

   321 +      if (comp(*First2, *First1)) {

   322 +        iterator Next = First2;

   323 +        transfer(First1, Right, First2, ++Next);

   324 +        First2 = Next;

   325 +      } else {

   326 +        ++First1;

   327 +      }

   328 +    }

   329 +    if (First2 != Last2)

   330 +      transfer(Last1, Right, First2, Last2);

   331 +  }

   332 +  void merge(iplist &Right) { return merge(Right, op_less); }

   333 +

   334 +  template <class Compare>

   335 +  void sort(Compare comp) {

   336 +    // The list is empty, vacuously sorted.

   337 +    if (empty())

   338 +      return;

   339 +    // The list has a single element, vacuously sorted.

   340 +    if (std::next(begin()) == end())

   341 +      return;

   342 +    // Find the split point for the list.

   343 +    iterator Center = begin(), End = begin();

   344 +    while (End != end() && std::next(End) != end()) {

   345 +      Center = std::next(Center);

   346 +      End = std::next(std::next(End));

   347 +    }

   348 +    // Split the list into two.

   349 +    iplist RightHalf;

   350 +    RightHalf.splice(RightHalf.begin(), *this, Center, end());

   351 +

   352 +    // Sort the two sublists.

   353 +    sort(comp);

   354 +    RightHalf.sort(comp);

   355 +

   356 +    // Merge the two sublists back together.

   357 +    merge(RightHalf, comp);

   358 +  }

   359 +  void sort() { sort(op_less); }

   360  };

   361  

   362  

   363 --- include/llvm/ADT/ilist_node.h	2014-08-13 09:26:38.000000000 -0700

   364 +++ include/llvm/ADT/ilist_node.h	2015-11-02 09:17:47.446456035 -0800

   365 @@ -19,12 +19,15 @@

   366  

   367  template<typename NodeTy>

   368  struct ilist_traits;

   369 +template <typename NodeTy> struct ilist_embedded_sentinel_traits;

   370 +template <typename NodeTy> struct ilist_half_embedded_sentinel_traits;

   371  

   372  /// ilist_half_node - Base class that provides prev services for sentinels.

   373  ///

   374  template<typename NodeTy>

   375  class ilist_half_node {

   376    friend struct ilist_traits<NodeTy>;

   377 +  friend struct ilist_half_embedded_sentinel_traits<NodeTy>;

   378    NodeTy *Prev;

   379  protected:

   380    NodeTy *getPrev() { return Prev; }

   381 @@ -36,6 +39,8 @@

   382  template<typename NodeTy>

   383  struct ilist_nextprev_traits;

   384  

   385 +template <typename NodeTy> class ilist_iterator;

   386 +

   387  /// ilist_node - Base class that provides next/prev services for nodes

   388  /// that use ilist_nextprev_traits or ilist_default_traits.

   389  ///

   390 @@ -43,6 +48,8 @@

   391  class ilist_node : private ilist_half_node<NodeTy> {

   392    friend struct ilist_nextprev_traits<NodeTy>;

   393    friend struct ilist_traits<NodeTy>;

   394 +  friend struct ilist_half_embedded_sentinel_traits<NodeTy>;

   395 +  friend struct ilist_embedded_sentinel_traits<NodeTy>;

   396    NodeTy *Next;

   397    NodeTy *getNext() { return Next; }

   398    const NodeTy *getNext() const { return Next; }

   399 @@ -51,6 +58,15 @@

   400    ilist_node() : Next(nullptr) {}

   401  

   402  public:

   403 +  ilist_iterator<NodeTy> getIterator() {

   404 +    // FIXME: Stop downcasting to create the iterator (potential UB).

   405 +    return ilist_iterator<NodeTy>(static_cast<NodeTy *>(this));

   406 +  }

   407 +  ilist_iterator<const NodeTy> getIterator() const {

   408 +    // FIXME: Stop downcasting to create the iterator (potential UB).

   409 +    return ilist_iterator<const NodeTy>(static_cast<const NodeTy *>(this));

   410 +  }

   411 +

   412    /// @name Adjacent Node Accessors

   413    /// @{

   414  

   415 --- include/llvm/CodeGen/CommandFlags.h	2015-01-13 21:24:33.000000000 -0800

   416 +++ include/llvm/CodeGen/CommandFlags.h	2016-01-26 14:46:39.000000000 -0800

   417 @@ -31,7 +31,7 @@

   418  MCPU("mcpu",

   419       cl::desc("Target a specific cpu type (-mcpu=help for details)"),

   420       cl::value_desc("cpu-name"),

   421 -     cl::init(""));

   422 +     cl::init(std::string("")));

   423  

   424  cl::list<std::string>

   425  MAttrs("mattr",

   426 @@ -177,7 +177,7 @@

   427  cl::opt<std::string>

   428  TrapFuncName("trap-func", cl::Hidden,

   429          cl::desc("Emit a call to trap function rather than a trap instruction"),

   430 -        cl::init(""));

   431 +        cl::init(std::string("")));

   432  

   433  cl::opt<bool>

   434  EnablePIE("enable-pie",

   435 @@ -192,11 +192,11 @@

   436  cl::opt<std::string> StopAfter("stop-after",

   437                              cl::desc("Stop compilation after a specific pass"),

   438                              cl::value_desc("pass-name"),

   439 -                                      cl::init(""));

   440 +                                      cl::init(std::string("")));

   441  cl::opt<std::string> StartAfter("start-after",

   442                            cl::desc("Resume compilation after a specific pass"),

   443                            cl::value_desc("pass-name"),

   444 -                          cl::init(""));

   445 +                          cl::init(std::string("")));

   446  

   447  cl::opt<bool> DataSections("data-sections",

   448                             cl::desc("Emit data into separate sections"),

   449 @@ -258,7 +258,7 @@

   450  // CFI.

   451  cl::opt<std::string>

   452  CFIFuncName("cfi-func-name", cl::desc("The name of the CFI function to call"),

   453 -            cl::init(""));

   454 +            cl::init(std::string("")));

   455  

   456  // Common utility function tightly tied to the options listed here. Initializes

   457  // a TargetOptions object with CodeGen flags and returns it.

   458 --- include/llvm/CodeGen/MachineBasicBlock.h	2014-11-13 16:34:59.000000000 -0800

   459 +++ include/llvm/CodeGen/MachineBasicBlock.h	2015-12-06 12:31:19.423838338 -0800

   460 @@ -165,7 +165,7 @@

   461      Ty &operator*() const { return *MII; }

   462      Ty *operator->() const { return &operator*(); }

   463  

   464 -    operator Ty*() const { return MII; }

   465 +    operator Ty*() const { return MII.getNodePtrUnchecked(); }

   466  

   467      bool operator==(const bundle_iterator &x) const {

   468        return MII == x.MII;

   469 --- include/llvm/CodeGen/MachineFunction.h	2015-01-06 12:05:02.000000000 -0800

   470 +++ include/llvm/CodeGen/MachineFunction.h	2015-12-06 20:18:16.623633498 -0800

   471 @@ -352,12 +352,10 @@

   472      BasicBlocks.splice(InsertPt, BasicBlocks, MBBI, MBBE);

   473    }

   474  

   475 -  void remove(iterator MBBI) {

   476 -    BasicBlocks.remove(MBBI);

   477 -  }

   478 -  void erase(iterator MBBI) {

   479 -    BasicBlocks.erase(MBBI);

   480 -  }

   481 +  void remove(iterator MBBI) { BasicBlocks.remove(MBBI); }

   482 +  void remove(MachineBasicBlock *MBBI) { BasicBlocks.remove(MBBI); }

   483 +  void erase(iterator MBBI) { BasicBlocks.erase(MBBI); }

   484 +  void erase(MachineBasicBlock *MBBI) { BasicBlocks.erase(MBBI); }

   485  

   486    //===--------------------------------------------------------------------===//

   487    // Internal functions used to automatically number MachineBasicBlocks

   488 --- include/llvm/CodeGen/MachineInstrBuilder.h	2014-10-31 16:19:46.000000000 -0700

   489 +++ include/llvm/CodeGen/MachineInstrBuilder.h	2015-12-06 13:48:56.344154780 -0800

   490 @@ -280,7 +280,7 @@

   491                                     const MCInstrDesc &MCID,

   492                                     unsigned DestReg) {

   493    if (I->isInsideBundle()) {

   494 -    MachineBasicBlock::instr_iterator MII = I;

   495 +    MachineBasicBlock::instr_iterator MII(I);

   496      return BuildMI(BB, MII, DL, MCID, DestReg);

   497    }

   498  

   499 @@ -317,7 +317,7 @@

   500                                     DebugLoc DL,

   501                                     const MCInstrDesc &MCID) {

   502    if (I->isInsideBundle()) {

   503 -    MachineBasicBlock::instr_iterator MII = I;

   504 +    MachineBasicBlock::instr_iterator MII(I);

   505      return BuildMI(BB, MII, DL, MCID);

   506    }

   507  

   508 @@ -472,7 +472,7 @@

   509      if (I == Begin) {

   510        if (!empty())

   511          MI->bundleWithSucc();

   512 -      Begin = MI;

   513 +      Begin = MI->getIterator();

   514        return *this;

   515      }

   516      if (I == End) {

   517 --- include/llvm/CodeGen/MachineInstrBundle.h	2014-04-13 17:51:57.000000000 -0700

   518 +++ include/llvm/CodeGen/MachineInstrBundle.h	2015-12-06 12:35:51.016366535 -0800

   519 @@ -44,23 +44,23 @@

   520  /// getBundleStart - Returns the first instruction in the bundle containing MI.

   521  ///

   522  inline MachineInstr *getBundleStart(MachineInstr *MI) {

   523 -  MachineBasicBlock::instr_iterator I = MI;

   524 +  MachineBasicBlock::instr_iterator I(MI);

   525    while (I->isBundledWithPred())

   526      --I;

   527 -  return I;

   528 +  return &*I;

   529  }

   530  

   531  inline const MachineInstr *getBundleStart(const MachineInstr *MI) {

   532 -  MachineBasicBlock::const_instr_iterator I = MI;

   533 +  MachineBasicBlock::const_instr_iterator I(MI);

   534    while (I->isBundledWithPred())

   535      --I;

   536 -  return I;

   537 +  return &*I;

   538  }

   539  

   540  /// Return an iterator pointing beyond the bundle containing MI.

   541  inline MachineBasicBlock::instr_iterator

   542  getBundleEnd(MachineInstr *MI) {

   543 -  MachineBasicBlock::instr_iterator I = MI;

   544 +  MachineBasicBlock::instr_iterator I(MI);

   545    while (I->isBundledWithSucc())

   546      ++I;

   547    return ++I;

   548 @@ -69,7 +69,7 @@

   549  /// Return an iterator pointing beyond the bundle containing MI.

   550  inline MachineBasicBlock::const_instr_iterator

   551  getBundleEnd(const MachineInstr *MI) {

   552 -  MachineBasicBlock::const_instr_iterator I = MI;

   553 +  MachineBasicBlock::const_instr_iterator I(MI);

   554    while (I->isBundledWithSucc())

   555      ++I;

   556    return ++I;

   557 @@ -116,10 +116,10 @@

   558    ///

   559    explicit MachineOperandIteratorBase(MachineInstr *MI, bool WholeBundle) {

   560      if (WholeBundle) {

   561 -      InstrI = getBundleStart(MI);

   562 +      InstrI = getBundleStart(MI)->getIterator();

   563        InstrE = MI->getParent()->instr_end();

   564      } else {

   565 -      InstrI = InstrE = MI;

   566 +      InstrI = InstrE = MI->getIterator();

   567        ++InstrE;

   568      }

   569      OpI = InstrI->operands_begin();

   570 --- include/llvm/CodeGen/SlotIndexes.h	2014-04-13 17:51:57.000000000 -0700

   571 +++ include/llvm/CodeGen/SlotIndexes.h	2015-12-06 13:26:01.031361628 -0800

   572 @@ -427,11 +427,11 @@

   573      /// Returns the next non-null index, if one exists.

   574      /// Otherwise returns getLastIndex().

   575      SlotIndex getNextNonNullIndex(SlotIndex Index) {

   576 -      IndexList::iterator I = Index.listEntry();

   577 +      IndexList::iterator I = Index.listEntry()->getIterator();

   578        IndexList::iterator E = indexList.end();

   579        while (++I != E)

   580          if (I->getInstr())

   581 -          return SlotIndex(I, Index.getSlot());

   582 +          return SlotIndex(&*I, Index.getSlot());

   583        // We reached the end of the function.

   584        return getLastIndex();

   585      }

   586 @@ -580,11 +580,11 @@

   587        IndexList::iterator prevItr, nextItr;

   588        if (Late) {

   589          // Insert mi's index immediately before the following instruction.

   590 -        nextItr = getIndexAfter(mi).listEntry();

   591 +        nextItr = getIndexAfter(mi).listEntry()->getIterator();

   592          prevItr = std::prev(nextItr);

   593        } else {

   594          // Insert mi's index immediately after the preceding instruction.

   595 -        prevItr = getIndexBefore(mi).listEntry();

   596 +        prevItr = getIndexBefore(mi).listEntry()->getIterator();

   597          nextItr = std::next(prevItr);

   598        }

   599  

   600 @@ -646,11 +646,11 @@

   601        if (nextMBB == mbb->getParent()->end()) {

   602          startEntry = &indexList.back();

   603          endEntry = createEntry(nullptr, 0);

   604 -        newItr = indexList.insertAfter(startEntry, endEntry);

   605 +        newItr = indexList.insertAfter(startEntry->getIterator(), endEntry);

   606        } else {

   607          startEntry = createEntry(nullptr, 0);

   608 -        endEntry = getMBBStartIdx(nextMBB).listEntry();

   609 -        newItr = indexList.insert(endEntry, startEntry);

   610 +        endEntry = getMBBStartIdx(&*nextMBB).listEntry();

   611 +        newItr = indexList.insert(endEntry->getIterator(), startEntry);

   612        }

   613  

   614        SlotIndex startIdx(startEntry, SlotIndex::Slot_Block);

   615 --- include/llvm/IR/IRBuilder.h	2014-12-30 06:28:14.000000000 -0800

   616 +++ include/llvm/IR/IRBuilder.h	2015-11-24 09:08:00.970126898 -0800

   617 @@ -58,9 +58,10 @@

   618    FastMathFlags FMF;

   619  public:

   620  

   621 -  IRBuilderBase(LLVMContext &context, MDNode *FPMathTag = nullptr)

   622 -    : Context(context), DefaultFPMathTag(FPMathTag), FMF() {

   623 -    ClearInsertionPoint();

   624 +  IRBuilderBase(LLVMContext &Ctx, MDNode *FPMathTag = nullptr)

   625 +    : CurDbgLocation(), BB(nullptr), InsertPt(),

   626 +    Context(Ctx), DefaultFPMathTag(FPMathTag), FMF() {

   627 +    // ClearInsertionPoint();

   628    }

   629  

   630    //===--------------------------------------------------------------------===//

   631 @@ -71,7 +72,7 @@

   632    /// inserted into a block.

   633    void ClearInsertionPoint() {

   634      BB = nullptr;

   635 -    InsertPt = nullptr;

   636 +    InsertPt.reset(nullptr);

   637    }

   638  

   639    BasicBlock *GetInsertBlock() const { return BB; }

   640 @@ -89,8 +90,8 @@

   641    /// the specified instruction.

   642    void SetInsertPoint(Instruction *I) {

   643      BB = I->getParent();

   644 -    InsertPt = I;

   645 -    assert(I != BB->end() && "Can't read debug loc from end()");

   646 +    InsertPt = I->getIterator();

   647 +    assert(InsertPt != BB->end() && "Can't read debug loc from end()");

   648      SetCurrentDebugLocation(I->getDebugLoc());

   649    }

   650  

   651 @@ -99,6 +100,8 @@

   652    void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {

   653      BB = TheBB;

   654      InsertPt = IP;

   655 +    if (IP != TheBB->end())

   656 +      SetCurrentDebugLocation(IP->getDebugLoc());

   657    }

   658  

   659    /// \brief Find the nearest point that dominates this use, and specify that

   660 @@ -107,10 +110,12 @@

   661      Instruction *UseInst = cast<Instruction>(U.getUser());

   662      if (PHINode *Phi = dyn_cast<PHINode>(UseInst)) {

   663        BasicBlock *PredBB = Phi->getIncomingBlock(U);

   664 -      assert(U != PredBB->getTerminator() && "critical edge not split");

   665 -      SetInsertPoint(PredBB, PredBB->getTerminator());

   666 +      TerminatorInst *TI = PredBB->getTerminator();

   667 +      assert(U != TI && "critical edge not split");

   668 +      SetInsertPoint(PredBB, TI->getIterator());

   669        return;

   670      }

   671 +

   672      SetInsertPoint(UseInst);

   673    }

   674  

   675 --- include/llvm/IR/Metadata.h	2015-10-05 11:01:32.758196248 -0700

   676 +++ include/llvm/IR/Metadata.h	2015-11-27 09:20:10.357775627 -0800

   677 @@ -927,6 +927,71 @@

   678    using ReplaceableMetadataImpl::replaceAllUsesWith;

   679  };

   680  

   681 +template <class T>

   682 +class TypedMDOperandIterator : public std::iterator<std::input_iterator_tag, T*, std::ptrdiff_t, void, T*> {

   683 +private:

   684 +  MDNode::op_iterator I = nullptr;

   685 +

   686 +public:

   687 +  TypedMDOperandIterator() = default;

   688 +  explicit TypedMDOperandIterator(MDNode::op_iterator I) : I(I) {}

   689 +  ~TypedMDOperandIterator() { }

   690 +

   691 +  T *operator*() const { return cast_or_null<T>(*I); }

   692 +

   693 +  TypedMDOperandIterator &operator++() {

   694 +    ++I;

   695 +    return *this;

   696 +  }

   697 +

   698 +  TypedMDOperandIterator operator++(int) {

   699 +    TypedMDOperandIterator Temp(*this);

   700 +    ++I;

   701 +    return Temp;

   702 +  }

   703 +

   704 +  bool operator==(const TypedMDOperandIterator &X) const { return I == X.I; }

   705 +  bool operator!=(const TypedMDOperandIterator &X) const { return I != X.I; }

   706 +};

   707 +

   708 +template<class T> class MDTupleTypedArrayWrapper {

   709 +private:

   710 +  const MDTuple *N = nullptr;

   711 +

   712 +public:

   713 +  MDTupleTypedArrayWrapper() = default;

   714 +  MDTupleTypedArrayWrapper(const MDTuple *N) : N(N) {}

   715 +  ~MDTupleTypedArrayWrapper() { }

   716 +

   717 +  template<class U>

   718 +  MDTupleTypedArrayWrapper(const MDTupleTypedArrayWrapper<U> &Other,

   719 +                           typename std::enable_if<std::is_convertible<U*, T*>::value>::type* = nullptr)

   720 +  : N(Other.get()) { }

   721 +

   722 +  template<class U>

   723 +  explicit MDTupleTypedArrayWrapper(const MDTupleTypedArrayWrapper<U> &Other,

   724 +                                    typename std::enable_if<!std::is_convertible<U*, T*>::value>::type* = nullptr)

   725 +  : N(Other.get()) { }

   726 +

   727 +  explicit operator bool() const { return get(); }

   728 +  explicit operator MDTuple *() const { return get(); }

   729 +

   730 +  MDTuple *get() const { return const_cast<MDTuple *>(N); }

   731 +  MDTuple *operator->() const { return get(); }

   732 +  MDTuple &operator*() const { return *get(); }

   733 +

   734 +  unsigned size() const { return N ? N->getNumOperands() : 0u; }

   735 +  T *operator[](unsigned I) const { return cast_or_null<T>(N->getOperand(I)); }

   736 +

   737 +  typedef TypedMDOperandIterator<T> iterator;

   738 +  iterator begin() const { return N ? iterator(N->op_begin()) : iterator(); }

   739 +  iterator end() const { return N ? iterator(N->op_end()) : iterator(); }

   740 +};

   741 +

   742 +#define HANDLE_METADATA(CLASS)                                                 \

   743 +  typedef MDTupleTypedArrayWrapper<CLASS> CLASS##Array;

   744 +#include "llvm/IR/Metadata.def"

   745 +

   746  //===----------------------------------------------------------------------===//

   747  /// \brief A tuple of MDNodes.

   748  ///

   749 --- include/llvm/MC/MCSection.h	2013-04-17 14:18:16.000000000 -0700

   750 +++ include/llvm/MC/MCSection.h	2015-12-07 12:32:38.557027450 -0800

   751 @@ -15,6 +15,9 @@

   752  #define LLVM_MC_MCSECTION_H

   753  

   754  #include "llvm/ADT/StringRef.h"

   755 +#include "llvm/ADT/ilist.h"

   756 +#include "llvm/ADT/ilist_node.h"

   757 +#include "llvm/MC/MCAssembler.h"

   758  #include "llvm/MC/SectionKind.h"

   759  #include "llvm/Support/Compiler.h"

   760  

   761 @@ -41,6 +44,14 @@

   762      MCSection(SectionVariant V, SectionKind K) : Variant(V), Kind(K) {}

   763      SectionVariant Variant;

   764      SectionKind Kind;

   765 +

   766 +  public:

   767 +    typedef iplist<MCFragment> FragmentListType;

   768 +    typedef FragmentListType::const_iterator const_iterator;

   769 +    typedef FragmentListType::iterator iterator;

   770 +    typedef FragmentListType::const_reverse_iterator const_reverse_iterator;

   771 +    typedef FragmentListType::reverse_iterator reverse_iterator;

   772 +

   773    public:

   774      virtual ~MCSection();

   775  

   776 --- include/llvm/MC/MCTargetOptionsCommandFlags.h	2015-01-14 03:23:27.000000000 -0800

   777 +++ include/llvm/MC/MCTargetOptionsCommandFlags.h	2016-01-26 19:29:37.000000000 -0800

   778 @@ -43,7 +43,7 @@

   779  cl::opt<std::string>

   780  ABIName("target-abi", cl::Hidden,

   781          cl::desc("The name of the ABI to be targeted from the backend."),

   782 -        cl::init(""));

   783 +        cl::init(std::string("")));

   784  

   785  static inline MCTargetOptions InitMCTargetOptionsFromFlags() {

   786    MCTargetOptions Options;

   787 --- include/llvm/Support/GenericDomTree.h	2015-01-14 02:33:21.000000000 -0800

   788 +++ include/llvm/Support/GenericDomTree.h	2015-12-08 09:12:30.450453075 -0800

   789 @@ -715,7 +715,11 @@

   790    /// recalculate - compute a dominator tree for the given function

   791    template <class FT> void recalculate(FT &F) {

   792      typedef GraphTraits<FT *> TraitsTy;

   793 +    typedef typename GraphTraits<FT*>::ChildIteratorType TraitsTyChildIterator;

   794 +    typedef typename GraphTraits<FT*>::nodes_iterator TraitsTyNodeIterator;

   795 +

   796      reset();

   797 +

   798      this->Vertex.push_back(nullptr);

   799  

   800      if (!this->IsPostDominators) {

   801 @@ -728,19 +732,22 @@

   802        Calculate<FT, NodeT *>(*this, F);

   803      } else {

   804        // Initialize the roots list

   805 -      for (typename TraitsTy::nodes_iterator I = TraitsTy::nodes_begin(&F),

   806 -                                             E = TraitsTy::nodes_end(&F);

   807 +      for (TraitsTyNodeIterator I = TraitsTy::nodes_begin(&F),

   808 +                                E = TraitsTy::nodes_end(&F);

   809             I != E; ++I) {

   810 -        if (TraitsTy::child_begin(I) == TraitsTy::child_end(I))

   811 -          addRoot(I);

   812 +        TraitsTyChildIterator ChildBegin(TraitsTy::child_begin(&*I));

   813 +        TraitsTyChildIterator ChildEnd(TraitsTy::child_end(&*I));

   814 +

   815 +        if (ChildBegin == ChildEnd)

   816 +          addRoot(&*I);

   817  

   818          // Prepopulate maps so that we don't get iterator invalidation issues

   819          // later.

   820 -        this->IDoms[I] = nullptr;

   821 -        this->DomTreeNodes[I] = nullptr;

   822 +        this->IDoms[&*I] = nullptr;

   823 +        this->DomTreeNodes[&*I] = nullptr;

   824        }

   825  

   826 -      Calculate<FT, Inverse<NodeT *>>(*this, F);

   827 +      Calculate<FT, Inverse<NodeT*> >(*this, F);

   828      }

   829    }

   830  };

   831 --- include/llvm/Transforms/Utils/SSAUpdaterImpl.h	2014-04-21 15:55:11.000000000 -0700

   832 +++ include/llvm/Transforms/Utils/SSAUpdaterImpl.h	2015-11-29 13:46:28.070241785 -0800

   833 @@ -378,7 +378,7 @@

   834    void FindExistingPHI(BlkT *BB, BlockListTy *BlockList) {

   835      for (typename BlkT::iterator BBI = BB->begin(), BBE = BB->end();

   836           BBI != BBE; ++BBI) {

   837 -      PhiT *SomePHI = Traits::InstrIsPHI(BBI);

   838 +      PhiT *SomePHI = Traits::InstrIsPHI(&*BBI);

   839        if (!SomePHI)

   840          break;

   841        if (CheckIfPHIMatches(SomePHI)) {

   842 --- lib/Analysis/AliasAnalysisEvaluator.cpp	2014-07-24 05:16:19.000000000 -0700

   843 +++ lib/Analysis/AliasAnalysisEvaluator.cpp	2015-11-27 17:10:53.853958210 -0800

   844 @@ -146,9 +146,9 @@

   845    SetVector<Value *> Loads;

   846    SetVector<Value *> Stores;

   847  

   848 -  for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I)

   849 -    if (I->getType()->isPointerTy())    // Add all pointer arguments.

   850 -      Pointers.insert(I);

   851 +  for (auto &I : F.args())

   852 +    if (I.getType()->isPointerTy())    // Add all pointer arguments.

   853 +      Pointers.insert(&I);

   854  

   855    for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {

   856      if (I->getType()->isPointerTy()) // Add all pointer instructions.

   857 --- lib/Analysis/AliasAnalysis.cpp	2014-12-15 06:09:53.000000000 -0800

   858 +++ lib/Analysis/AliasAnalysis.cpp	2015-11-27 09:33:58.058293495 -0800

   859 @@ -501,12 +501,12 @@

   860                                                const ModRefResult Mode) {

   861    assert(I1.getParent() == I2.getParent() &&

   862           "Instructions not in same basic block!");

   863 -  BasicBlock::const_iterator I = &I1;

   864 -  BasicBlock::const_iterator E = &I2;

   865 +  BasicBlock::const_iterator I = I1.getIterator();

   866 +  BasicBlock::const_iterator E = I2.getIterator();

   867    ++E;  // Convert from inclusive to exclusive range.

   868  

   869    for (; I != E; ++I) // Check every instruction in range

   870 -    if (getModRefInfo(I, Loc) & Mode)

   871 +    if (getModRefInfo(&(*I), Loc) & Mode)

   872        return true;

   873    return false;

   874  }

   875 --- lib/Analysis/AliasSetTracker.cpp	2014-11-19 11:36:18.000000000 -0800

   876 +++ lib/Analysis/AliasSetTracker.cpp	2015-11-27 09:52:20.756423865 -0800

   877 @@ -229,8 +229,8 @@

   878      iterator Cur = I++;

   879      if (Cur->Forward || !Cur->aliasesPointer(Ptr, Size, AAInfo, AA)) continue;

   880      

   881 -    if (!FoundSet) {      // If this is the first alias set ptr can go into.

   882 -      FoundSet = Cur;     // Remember it.

   883 +    if (!FoundSet) {        // If this is the first alias set ptr can go into.

   884 +      FoundSet = &(*Cur);   // Remember it.

   885      } else {              // Otherwise, we must merge the sets.

   886        FoundSet->mergeSetIn(*Cur, *this);     // Merge in contents.

   887      }

   888 @@ -264,16 +264,13 @@

   889      if (Cur->Forward || !Cur->aliasesUnknownInst(Inst, AA))

   890        continue;

   891      if (!FoundSet)            // If this is the first alias set ptr can go into.

   892 -      FoundSet = Cur;         // Remember it.

   893 +      FoundSet = &(*Cur);     // Remember it.

   894      else if (!Cur->Forward)   // Otherwise, we must merge the sets.

   895        FoundSet->mergeSetIn(*Cur, *this);     // Merge in contents.

   896    }

   897    return FoundSet;

   898  }

   899  

   900 -

   901 -

   902 -

   903  /// getAliasSetForPointer - Return the alias set that the specified pointer

   904  /// lives in.

   905  AliasSet &AliasSetTracker::getAliasSetForPointer(Value *Pointer, uint64_t Size,

   906 @@ -287,13 +284,13 @@

   907      // Return the set!

   908      return *Entry.getAliasSet(*this)->getForwardedTarget(*this);

   909    }

   910 -  

   911 +

   912    if (AliasSet *AS = findAliasSetForPointer(Pointer, Size, AAInfo)) {

   913      // Add it to the alias set it aliases.

   914      AS->addPointer(*this, Entry, Size, AAInfo);

   915      return *AS;

   916    }

   917 -  

   918 +

   919    if (New) *New = true;

   920    // Otherwise create a new alias set to hold the loaded pointer.

   921    AliasSets.push_back(new AliasSet());

   922 @@ -379,8 +376,8 @@

   923  }

   924  

   925  void AliasSetTracker::add(BasicBlock &BB) {

   926 -  for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ++I)

   927 -    add(I);

   928 +  for (auto &I : BB)

   929 +    add(&I);

   930  }

   931  

   932  void AliasSetTracker::add(const AliasSetTracker &AST) {

   933 --- lib/Analysis/BasicAliasAnalysis.cpp	2015-01-04 04:03:27.000000000 -0800

   934 +++ lib/Analysis/BasicAliasAnalysis.cpp	2015-11-27 09:53:17.612141117 -0800

   935 @@ -1440,7 +1440,7 @@

   936    // the Values cannot come from different iterations of a potential cycle the

   937    // phi nodes could be involved in.

   938    for (auto *P : VisitedPhiBBs)

   939 -    if (isPotentiallyReachable(P->begin(), Inst, DT, LI))

   940 +    if (isPotentiallyReachable(&P->front(), Inst, DT, LI))

   941        return false;

   942  

   943    return true;

   944 --- lib/Analysis/BlockFrequencyInfo.cpp	2014-06-26 15:52:05.000000000 -0700

   945 +++ lib/Analysis/BlockFrequencyInfo.cpp	2015-11-27 09:55:32.251496178 -0800

   946 @@ -34,17 +34,17 @@

   947  };

   948  

   949  static cl::opt<GVDAGType>

   950 -ViewBlockFreqPropagationDAG("view-block-freq-propagation-dags", cl::Hidden,

   951 -          cl::desc("Pop up a window to show a dag displaying how block "

   952 -                   "frequencies propagation through the CFG."),

   953 -          cl::values(

   954 -            clEnumValN(GVDT_None, "none",

   955 -                       "do not display graphs."),

   956 -            clEnumValN(GVDT_Fraction, "fraction", "display a graph using the "

   957 -                       "fractional block frequency representation."),

   958 -            clEnumValN(GVDT_Integer, "integer", "display a graph using the raw "

   959 -                       "integer fractional block frequency representation."),

   960 -            clEnumValEnd));

   961 +ViewBlockFreqPropagationDAG("view-block-freq-propagation-dags",

   962 +                            cl::Hidden,

   963 +                            cl::desc("Pop up a window to show a dag displaying how block "

   964 +                                     "frequencies propagation through the CFG."),

   965 +                            cl::values(clEnumValN(GVDT_None, "none",

   966 +                                                  "do not display graphs."),

   967 +                                       clEnumValN(GVDT_Fraction, "fraction", "display a graph using the "

   968 +                                                  "fractional block frequency representation."),

   969 +                                       clEnumValN(GVDT_Integer, "integer", "display a graph using the raw "

   970 +                                                  "integer fractional block frequency representation."),

   971 +                                       clEnumValEnd));

   972  

   973  namespace llvm {

   974  

   975 @@ -55,8 +55,9 @@

   976    typedef Function::const_iterator nodes_iterator;

   977  

   978    static inline const NodeType *getEntryNode(const BlockFrequencyInfo *G) {

   979 -    return G->getFunction()->begin();

   980 +    return &(G->getFunction()->front());

   981    }

   982 +

   983    static ChildIteratorType child_begin(const NodeType *N) {

   984      return succ_begin(N);

   985    }

   986 --- lib/Analysis/BranchProbabilityInfo.cpp	2014-12-09 10:38:53.000000000 -0800

   987 +++ lib/Analysis/BranchProbabilityInfo.cpp	2015-11-27 09:59:58.010012465 -0800

   988 @@ -529,11 +529,10 @@

   989    // We print the probabilities from the last function the analysis ran over,

   990    // or the function it is currently running over.

   991    assert(LastF && "Cannot print prior to running over a function");

   992 -  for (Function::const_iterator BI = LastF->begin(), BE = LastF->end();

   993 -       BI != BE; ++BI) {

   994 -    for (succ_const_iterator SI = succ_begin(BI), SE = succ_end(BI);

   995 +  for (const auto &BI : *LastF) {

   996 +    for (succ_const_iterator SI = succ_begin(&BI), SE = succ_end(&BI);

   997           SI != SE; ++SI) {

   998 -      printEdgeProbability(OS << "  ", BI, *SI);

   999 +      printEdgeProbability(OS << "  ", &BI, *SI);

  1000      }

  1001    }

  1002  }

  1003 --- lib/Analysis/CFG.cpp	2015-01-12 19:46:47.000000000 -0800

  1004 +++ lib/Analysis/CFG.cpp	2015-11-27 10:13:16.659243122 -0800

  1005 @@ -204,8 +204,9 @@

  1006        return true;

  1007  

  1008      // Linear scan, start at 'A', see whether we hit 'B' or the end first.

  1009 -    for (BasicBlock::const_iterator I = A, E = BB->end(); I != E; ++I) {

  1010 -      if (&*I == B)

  1011 +    for (BasicBlock::const_iterator I = A->getIterator(), E = BB->end();

  1012 +         I != E; ++I) {

  1013 +      if (&(*I) == B)

  1014          return true;

  1015      }

  1016  

  1017 --- lib/Analysis/CodeMetrics.cpp	2015-01-04 04:03:27.000000000 -0800

  1018 +++ lib/Analysis/CodeMetrics.cpp	2015-11-27 10:14:02.544976823 -0800

  1019 @@ -115,7 +115,7 @@

  1020    for (BasicBlock::const_iterator II = BB->begin(), E = BB->end();

  1021         II != E; ++II) {

  1022      // Skip ephemeral values.

  1023 -    if (EphValues.count(II))

  1024 +    if (EphValues.count(&(*II)))

  1025        continue;

  1026  

  1027      // Special handling for calls.

  1028 --- lib/Analysis/CostModel.cpp	2014-07-03 15:24:18.000000000 -0700

  1029 +++ lib/Analysis/CostModel.cpp	2015-11-27 10:20:35.600601500 -0800

  1030 @@ -524,7 +524,7 @@

  1031  

  1032    for (Function::iterator B = F->begin(), BE = F->end(); B != BE; ++B) {

  1033      for (BasicBlock::iterator it = B->begin(), e = B->end(); it != e; ++it) {

  1034 -      Instruction *Inst = it;

  1035 +      Instruction *Inst = &(*it);

  1036        unsigned Cost = getInstructionCost(Inst);

  1037        if (Cost != (unsigned)-1)

  1038          OS << "Cost Model: Found an estimated cost of " << Cost;

  1039 --- lib/Analysis/IPA/CallGraph.cpp	2014-08-07 13:41:17.000000000 -0700

  1040 +++ lib/Analysis/IPA/CallGraph.cpp	2015-11-27 17:17:06.153920405 -0800

  1041 @@ -25,7 +25,7 @@

  1042        CallsExternalNode(new CallGraphNode(nullptr)) {

  1043    // Add every function to the call graph.

  1044    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)

  1045 -    addToCallGraph(I);

  1046 +    addToCallGraph(&*I);

  1047  

  1048    // If we didn't find a main function, use the external call graph node

  1049    if (!Root)

  1050 --- lib/Analysis/IPA/GlobalsModRef.cpp	2014-05-08 10:57:50.000000000 -0700

  1051 +++ lib/Analysis/IPA/GlobalsModRef.cpp	2015-11-27 17:21:08.993461915 -0800

  1052 @@ -209,9 +209,9 @@

  1053    std::vector<Function*> Readers, Writers;

  1054    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)

  1055      if (I->hasLocalLinkage()) {

  1056 -      if (!AnalyzeUsesOfPointer(I, Readers, Writers)) {

  1057 +      if (!AnalyzeUsesOfPointer(&*I, Readers, Writers)) {

  1058          // Remember that we are tracking this global.

  1059 -        NonAddressTakenGlobals.insert(I);

  1060 +        NonAddressTakenGlobals.insert(&*I);

  1061          ++NumNonAddrTakenFunctions;

  1062        }

  1063        Readers.clear(); Writers.clear();

  1064 @@ -220,24 +220,26 @@

  1065    for (Module::global_iterator I = M.global_begin(), E = M.global_end();

  1066         I != E; ++I)

  1067      if (I->hasLocalLinkage()) {

  1068 -      if (!AnalyzeUsesOfPointer(I, Readers, Writers)) {

  1069 +      if (!AnalyzeUsesOfPointer(&*I, Readers, Writers)) {

  1070          // Remember that we are tracking this global, and the mod/ref fns

  1071 -        NonAddressTakenGlobals.insert(I);

  1072 +        NonAddressTakenGlobals.insert(&*I);

  1073  

  1074          for (unsigned i = 0, e = Readers.size(); i != e; ++i)

  1075 -          FunctionInfo[Readers[i]].GlobalInfo[I] |= Ref;

  1076 +          FunctionInfo[Readers[i]].GlobalInfo[&*I] |= Ref;

  1077  

  1078          if (!I->isConstant())  // No need to keep track of writers to constants

  1079            for (unsigned i = 0, e = Writers.size(); i != e; ++i)

  1080 -            FunctionInfo[Writers[i]].GlobalInfo[I] |= Mod;

  1081 +            FunctionInfo[Writers[i]].GlobalInfo[&*I] |= Mod;

  1082          ++NumNonAddrTakenGlobalVars;

  1083  

  1084          // If this global holds a pointer type, see if it is an indirect global.

  1085          if (I->getType()->getElementType()->isPointerTy() &&

  1086 -            AnalyzeIndirectGlobalMemory(I))

  1087 +            AnalyzeIndirectGlobalMemory(&*I))

  1088            ++NumIndirectGlobalVars;

  1089        }

  1090 -      Readers.clear(); Writers.clear();

  1091 +

  1092 +      Readers.clear();

  1093 +      Writers.clear();

  1094      }

  1095  }

  1096  

  1097 --- lib/Analysis/IPA/InlineCost.cpp	2015-02-12 13:28:02.000000000 -0800

  1098 +++ lib/Analysis/IPA/InlineCost.cpp	2015-11-27 17:25:16.116008808 -0800

  1099 @@ -900,7 +900,7 @@

  1100        continue;

  1101  

  1102      // Skip ephemeral values.

  1103 -    if (EphValues.count(I))

  1104 +    if (EphValues.count(&*I))

  1105        continue;

  1106  

  1107      ++NumInstructions;

  1108 @@ -912,7 +912,7 @@

  1109      // all of the per-instruction logic. The visit tree returns true if we

  1110      // consumed the instruction in any way, and false if the instruction's base

  1111      // cost should count against inlining.

  1112 -    if (Base::visit(I))

  1113 +    if (Base::visit(&*I))

  1114        ++NumInstructionsSimplified;

  1115      else

  1116        Cost += InlineConstants::InstrCost;

  1117 @@ -1089,15 +1089,15 @@

  1118         FAI != FAE; ++FAI, ++CAI) {

  1119      assert(CAI != CS.arg_end());

  1120      if (Constant *C = dyn_cast<Constant>(CAI))

  1121 -      SimplifiedValues[FAI] = C;

  1122 +      SimplifiedValues[&*FAI] = C;

  1123  

  1124      Value *PtrArg = *CAI;

  1125      if (ConstantInt *C = stripAndComputeInBoundsConstantOffsets(PtrArg)) {

  1126 -      ConstantOffsetPtrs[FAI] = std::make_pair(PtrArg, C->getValue());

  1127 +      ConstantOffsetPtrs[&*FAI] = std::make_pair(PtrArg, C->getValue());

  1128  

  1129        // We can SROA any pointer arguments derived from alloca instructions.

  1130        if (isa<AllocaInst>(PtrArg)) {

  1131 -        SROAArgValues[FAI] = PtrArg;

  1132 +        SROAArgValues[&*FAI] = PtrArg;

  1133          SROAArgCosts[PtrArg] = 0;

  1134        }

  1135      }