[WIP][IR] allow `inrange` on non-constant GEP instructions.

[courbet]

Summary

This is an experiment for the following RFC: https://groups.google.com/g/llvm-dev/c/T9o51zB1JHY. This only adds support for inrange in the parser.

llvm/include/llvm/IR/Instructions.h

public:
 
   /// Set or clear the inbounds flag on this GEP instruction.
   /// See LangRef.html for the meaning of inbounds on a getelementptr.
   void setIsInBounds(bool b = true);
 
   /// Determine whether the GEP has the inbounds flag.
   bool isInBounds() const;
 
+  /// Set the inrange index of this GEP instruction.
+  /// See LangRef.html for the meaning of inrange on a getelementptr.
+  void setInRangeIndex(unsigned InRangeIndex);
+
+  /// Determine whether the GEP has an inrange index.
+  Optional<unsigned> getInRangeIndex() const;
+
   /// Accumulate the constant address offset of this GEP if possible.
   ///
   /// This routine accepts an APInt into which it will accumulate the constant
   /// offset of this GEP if the GEP is in fact constant. If the GEP is not
   /// all-constant, it returns false and the value of the offset APInt is
   /// undefined (it is *not* preserved!). The APInt passed into this routine
   /// must be at least as wide as the IntPtr type for the address space of
   /// the base GEP pointer.

llvm/include/llvm/IR/Operator.h

enum {
     // InRangeIndex: bits 1-6
   };
 
   void setIsInBounds(bool B) {
     SubclassOptionalData =
       (SubclassOptionalData & ~IsInBounds) | (B * IsInBounds);
   }
 
+  void setInRangeIndex(unsigned InRangeIndex) {
+    assert(InRangeIndex < 63 && "unsupported");
+    assert(!getInRangeIndex() && "trying to set multiple inrange indices");
+    SubclassOptionalData |= InRangeIndex << 1;
+  }
+
 public:
   /// Test whether this is an inbounds GEP, as defined by LangRef.html.
   bool isInBounds() const {
     return SubclassOptionalData & IsInBounds;
   }
 
   /// Returns the offset of the index with an inrange attachment, or None if
   /// none.

llvm/lib/AsmParser/LLParser.cpp

 //===-- LLParser.cpp - Parser Class ---------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the parser class for .ll files.
int LLParser::parseFence(Instruction *&Inst, PerFunctionState &PFS) {
   if (Ordering == AtomicOrdering::Monotonic)
     return tokError("fence cannot be monotonic");
 
   Inst = new FenceInst(Context, Ordering, SSID);
   return InstNormal;
 }
 
 /// parseGetElementPtr
-///   ::= 'getelementptr' 'inbounds'? TypeAndValue (',' TypeAndValue)*
+///   ::= 'getelementptr' 'inbounds'? TypeAndValue (',' 'inrange'? TypeAndValue)*
 int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Ptr = nullptr;
   Value *Val = nullptr;
   LocTy Loc, EltLoc;
 
   bool InBounds = EatIfPresent(lltok::kw_inbounds);
 
   Type *Ty = nullptr;
int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
   SmallVector<Value*, 16> Indices;
   bool AteExtraComma = false;
   // GEP returns a vector of pointers if at least one of parameters is a vector.
   // All vector parameters should have the same vector width.
   ElementCount GEPWidth = BaseType->isVectorTy()
                               ? cast<VectorType>(BaseType)->getElementCount()
                               : ElementCount::getFixed(0);
 
+  Optional<int> InRangeIndex;
   while (EatIfPresent(lltok::comma)) {
     if (Lex.getKind() == lltok::MetadataVar) {
       AteExtraComma = true;
       break;
     }
+    if (EatIfPresent(lltok::kw_inrange) && !InRangeIndex)
+      InRangeIndex = Indices.size();
     if (parseTypeAndValue(Val, EltLoc, PFS))
       return true;
     if (!Val->getType()->isIntOrIntVectorTy())
       return error(EltLoc, "getelementptr index must be an integer");
 
     if (auto *ValVTy = dyn_cast<VectorType>(Val->getType())) {
       ElementCount ValNumEl = ValVTy->getElementCount();
       if (GEPWidth != ElementCount::getFixed(0) && GEPWidth != ValNumEl)
int LLParser::parseGetElementPtr(Instruction *&Inst, PerFunctionState &PFS) {
   if (!Indices.empty() && !Ty->isSized(&Visited))
     return error(Loc, "base element of getelementptr must be sized");
 
   if (!GetElementPtrInst::getIndexedType(Ty, Indices))
     return error(Loc, "invalid getelementptr indices");
   Inst = GetElementPtrInst::Create(Ty, Ptr, Indices);
   if (InBounds)
     cast<GetElementPtrInst>(Inst)->setIsInBounds(true);
+  if (InRangeIndex && *InRangeIndex < 63)
+    cast<GetElementPtrInst>(Inst)->setInRangeIndex(*InRangeIndex);
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
 /// parseExtractValue
 ///   ::= 'extractvalue' TypeAndValue (',' uint32)+
 int LLParser::parseExtractValue(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Val; LocTy Loc;
   SmallVector<unsigned, 4> Indices;

llvm/lib/IR/Instructions.cpp

 void GetElementPtrInst::setIsInBounds(bool B) {
   cast<GEPOperator>(this)->setIsInBounds(B);
 }
 
 bool GetElementPtrInst::isInBounds() const {
   return cast<GEPOperator>(this)->isInBounds();
 }
 
+void GetElementPtrInst::setInRangeIndex(unsigned InRangeIndex) {
+  cast<GEPOperator>(this)->setInRangeIndex(InRangeIndex);
+}
+
+Optional<unsigned> GetElementPtrInst::getInRangeIndex() const {
+  return cast<GEPOperator>(this)->getInRangeIndex();
+}
+
 bool GetElementPtrInst::accumulateConstantOffset(const DataLayout &DL,
                                                  APInt &Offset) const {
   // Delegate to the generic GEPOperator implementation.
   return cast<GEPOperator>(this)->accumulateConstantOffset(DL, Offset);
 }
 
 //===----------------------------------------------------------------------===//
 //                           ExtractElementInst Implementation