[mlir] Make locations required when adding/creating block arguments

[rriddle]

Summary

BlockArguments gained the ability to have locations attached a while ago, but they
have always been optional. This goes against the core tenant of MLIR where location
information is a requirement, so this commit updates the API to require locations.

Fixes #53279

[lattner]

Nice, this is a great step, thank you for doing this!

What is our policy for the C APIs, are we allowed to fix them, or do we have to add a new entrypoint?

[mehdi_amini]

I don't remember seeing a discussion about "freezing" the C API so far, we stated a "best effort" intent originally. However external users may have started depending on them "de facto", skipping the discussion on getting a better contract first...
Adding trampoline if often trivial, but having to maintain suffixed numbered variant of the symbols isn't very appealing :(

[lattner]

Makes sense, it should definitely be a different discussion from this patch of course. My preference is to keep the C API barnacle free if we can, I simply don't know if anyone cares about compatibility here. Before fixing the C API it is probably best to discuss on the forum etc.

[rriddle]

In D117633#3255898, @lattner wrote:

Nice, this is a great step, thank you for doing this!

What is our policy for the C APIs, are we allowed to fix them, or do we have to add a new entrypoint?

AFAIK (and as Mehdi mentions) we try to maintain them as-is in a best effort manor, but we haven't yet committed to any kind of stability policy. Just went ahead and updated them here.

[stellaraccident]

In D117633#3256726, @lattner wrote:

Makes sense, it should definitely be a different discussion from this patch of course. My preference is to keep the C API barnacle free if we can, I simply don't know if anyone cares about compatibility here. Before fixing the C API it is probably best to discuss on the forum etc.

Worth a discussion, but I think we are still in the phase of aspiring to low churn on the C API vs having a hard line. Personally, I think there is a lot of accumulated debt that is being flushed here and am +1 on actually flushing the queue and getting to a better island of stability from then on.

[stellaraccident]

In D117633#3256727, @rriddle wrote:

In D117633#3255898, @lattner wrote:

Nice, this is a great step, thank you for doing this!

What is our policy for the C APIs, are we allowed to fix them, or do we have to add a new entrypoint?

AFAIK (and as Mehdi mentions) we try to maintain them as-is in a best effort manor, but we haven't yet committed to any kind of stability policy. Just went ahead and updated them here.

If we were to have such a policy for stability, I would rather it be something along the lines of "we can remove entry-points when needed but we should avoid changing the signature of existing entry-points" (basically, we eventually want link/symbol resolution errors, not weird signature mismatches). But I don't think we are even at that point yet in the development process. I vote for just fixing it.

flang/lib/Optimizer/CodeGen/TargetRewrite.cpp

if (!func.empty()) {
       const auto oldArgTys = func.getType().getInputs();
       int offset = 0;
       for (std::remove_const_t<decltype(fixupSize)> i = 0; i < fixupSize; ++i) {
         const auto &fixup = fixups[i];
         switch (fixup.code) {
         case FixupTy::Codes::ArgumentAsLoad: {
           // Argument was pass-by-value, but is now pass-by-reference and
           // possibly with a different element type.
-          auto newArg =
-              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          auto newArg = func.front().insertArgument(fixup.index,
+                                                    newInTys[fixup.index], loc);
           rewriter->setInsertionPointToStart(&func.front());
           auto oldArgTy = ReferenceType::get(oldArgTys[fixup.index - offset]);
           auto cast = rewriter->create<ConvertOp>(loc, oldArgTy, newArg);
           auto load = rewriter->create<fir::LoadOp>(loc, cast);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(load);
           func.front().eraseArgument(fixup.index + 1);
         } break;
         case FixupTy::Codes::ArgumentType: {
           // Argument is pass-by-value, but its type has likely been modified to
           // suit the target ABI convention.
-          auto newArg =
-              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          auto newArg = func.front().insertArgument(fixup.index,
+                                                    newInTys[fixup.index], loc);
           rewriter->setInsertionPointToStart(&func.front());
           auto mem =
               rewriter->create<fir::AllocaOp>(loc, newInTys[fixup.index]);
           rewriter->create<fir::StoreOp>(loc, newArg, mem);
           auto oldArgTy = ReferenceType::get(oldArgTys[fixup.index - offset]);
           auto cast = rewriter->create<ConvertOp>(loc, oldArgTy, mem);
           mlir::Value load = rewriter->create<fir::LoadOp>(loc, cast);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(load);
           func.front().eraseArgument(fixup.index + 1);
           LLVM_DEBUG(llvm::dbgs()
                      << "old argument: " << oldArgTy.getEleTy()
                      << ", repl: " << load << ", new argument: "
                      << func.getArgument(fixup.index).getType() << '\n');
         } break;
         case FixupTy::Codes::CharPair: {
           // The FIR boxchar argument has been split into a pair of distinct
           // arguments that are in juxtaposition to each other.
-          auto newArg =
-              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          auto newArg = func.front().insertArgument(fixup.index,
+                                                    newInTys[fixup.index], loc);
           if (fixup.second == 1) {
             rewriter->setInsertionPointToStart(&func.front());
             auto boxTy = oldArgTys[fixup.index - offset - fixup.second];
             auto box = rewriter->create<EmboxCharOp>(
                 loc, boxTy, func.front().getArgument(fixup.index - 1), newArg);
             func.getArgument(fixup.index + 1).replaceAllUsesWith(box);
             func.front().eraseArgument(fixup.index + 1);
             offset++;
           }
         } break;
         case FixupTy::Codes::ReturnAsStore: {
           // The value being returned is now being returned in memory (callee
           // stack space) through a hidden reference argument.
-          auto newArg =
-              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          auto newArg = func.front().insertArgument(fixup.index,
+                                                    newInTys[fixup.index], loc);
           offset++;
           func.walk([&](mlir::ReturnOp ret) {
             rewriter->setInsertionPoint(ret);
             auto oldOper = ret.getOperand(0);
             auto oldOperTy = ReferenceType::get(oldOper.getType());
             auto cast = rewriter->create<ConvertOp>(loc, oldOperTy, newArg);
             rewriter->create<fir::StoreOp>(loc, oldOper, cast);
             rewriter->create<mlir::ReturnOp>(loc);
if (!func.empty()) {
             mlir::Value load = rewriter->create<fir::LoadOp>(loc, mem);
             rewriter->create<mlir::ReturnOp>(loc, load);
             ret.erase();
           });
         } break;
         case FixupTy::Codes::Split: {
           // The FIR argument has been split into a pair of distinct arguments
           // that are in juxtaposition to each other. (For COMPLEX value.)
-          auto newArg =
-              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
+          auto newArg = func.front().insertArgument(fixup.index,
+                                                    newInTys[fixup.index], loc);
           if (fixup.second == 1) {
             rewriter->setInsertionPointToStart(&func.front());
             auto cplxTy = oldArgTys[fixup.index - offset - fixup.second];
             auto undef = rewriter->create<UndefOp>(loc, cplxTy);
             auto zero = rewriter->getIntegerAttr(rewriter->getIndexType(), 0);
             auto one = rewriter->getIntegerAttr(rewriter->getIndexType(), 1);
             auto cplx1 = rewriter->create<InsertValueOp>(
                 loc, cplxTy, undef, func.front().getArgument(fixup.index - 1),
                 rewriter->getArrayAttr(zero));
             auto cplx = rewriter->create<InsertValueOp>(
                 loc, cplxTy, cplx1, newArg, rewriter->getArrayAttr(one));
             func.getArgument(fixup.index + 1).replaceAllUsesWith(cplx);
             func.front().eraseArgument(fixup.index + 1);
             offset++;
           }
         } break;
         case FixupTy::Codes::Trailing: {
           // The FIR argument has been split into a pair of distinct arguments.
           // The first part of the pair appears in the original argument
           // position. The second part of the pair is appended after all the
           // original arguments. (Boxchar arguments.)
-          auto newBufArg =
-              func.front().insertArgument(fixup.index, newInTys[fixup.index]);
-          auto newLenArg = func.front().addArgument(trailingTys[fixup.second]);
+          auto newBufArg = func.front().insertArgument(
+              fixup.index, newInTys[fixup.index], loc);
+          auto newLenArg =
+              func.front().addArgument(trailingTys[fixup.second], loc);
           auto boxTy = oldArgTys[fixup.index - offset];
           rewriter->setInsertionPointToStart(&func.front());
           auto box =
               rewriter->create<EmboxCharOp>(loc, boxTy, newBufArg, newLenArg);
           func.getArgument(fixup.index + 1).replaceAllUsesWith(box);
           func.front().eraseArgument(fixup.index + 1);
         } break;
         }

flang/lib/Optimizer/Dialect/FIROps.cpp

if (finalCountValue) {
     result.addAttribute(getFinalValueAttrNameStr(), builder.getUnitAttr());
   }
   result.addTypes(iterate.getType());
   result.addOperands(iterArgs);
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block{});
-  bodyRegion->front().addArgument(builder.getIndexType());
-  bodyRegion->front().addArgument(iterate.getType());
-  bodyRegion->front().addArguments(iterArgs.getTypes());
+  bodyRegion->front().addArgument(builder.getIndexType(), result.location);
+  bodyRegion->front().addArgument(iterate.getType(), result.location);
+  bodyRegion->front().addArguments(
+      iterArgs.getTypes(),
+      SmallVector<Location>(iterArgs.size(), result.location));
   result.addAttributes(attributes);
 }
 
 static mlir::ParseResult parseIterWhileOp(mlir::OpAsmParser &parser,
                                           mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
   mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
   if (parser.parseLParen() || parser.parseRegionArgument(inductionVariable) ||
if (finalCountValue) {
     result.addAttribute(finalValueAttrName(result.name), builder.getUnitAttr());
   }
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block{});
   if (iterArgs.empty() && !finalCountValue)
     DoLoopOp::ensureTerminator(*bodyRegion, builder, result.location);
-  bodyRegion->front().addArgument(builder.getIndexType());
-  bodyRegion->front().addArguments(iterArgs.getTypes());
+  bodyRegion->front().addArgument(builder.getIndexType(), result.location);
+  bodyRegion->front().addArguments(
+      iterArgs.getTypes(),
+      SmallVector<Location>(iterArgs.size(), result.location));
   if (unordered)
     result.addAttribute(unorderedAttrName(result.name), builder.getUnitAttr());
   result.addAttributes(attributes);
 }
 
 static mlir::ParseResult parseDoLoopOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   auto &builder = parser.getBuilder();

flang/lib/Optimizer/Transforms/AbstractResult.cpp

void runOnOperation() override {
     if (mustConvertCallOrFunc(funcTy)) {
       func.setType(getNewFunctionType(funcTy, options));
       unsigned zero = 0;
       if (!func.empty()) {
         // Insert new argument
         mlir::OpBuilder rewriter(context);
         auto resultType = funcTy.getResult(0);
         auto argTy = getResultArgumentType(resultType, options);
-        options.newArg = func.front().insertArgument(zero, argTy);
+        options.newArg = func.front().insertArgument(zero, argTy, loc);
         if (mustEmboxResult(resultType, options)) {
           auto bufferType = fir::ReferenceType::get(resultType);
           rewriter.setInsertionPointToStart(&func.front());
           options.newArg =
               rewriter.create<fir::BoxAddrOp>(loc, bufferType, options.newArg);
         }
         patterns.insert<ReturnOpConversion>(context, options);
         target.addDynamicallyLegalOp<mlir::ReturnOp>(

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

matchAndRewrite(DoLoopOp loop,
     auto *initBlock = rewriter.getInsertionBlock();
     auto initPos = rewriter.getInsertionPoint();
     auto *endBlock = rewriter.splitBlock(initBlock, initPos);
 
     // Split the first DoLoopOp block in two parts. The part before will be the
     // conditional block since it already has the induction variable and
     // loop-carried values as arguments.
     auto *conditionalBlock = &loop.region().front();
-    conditionalBlock->addArgument(rewriter.getIndexType());
+    conditionalBlock->addArgument(rewriter.getIndexType(), loc);
     auto *firstBlock =
         rewriter.splitBlock(conditionalBlock, conditionalBlock->begin());
     auto *lastBlock = &loop.region().back();
 
     // Move the blocks from the DoLoopOp between initBlock and endBlock
     rewriter.inlineRegionBefore(loop.region(), endBlock);
 
     // Get loop values from the DoLoopOp

mlir/include/mlir-c/IR.h

 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
 /// Creates a new empty block with the given argument types and transfers
 /// ownership to the caller.
 MLIR_CAPI_EXPORTED MlirBlock mlirBlockCreate(intptr_t nArgs,
-                                             MlirType const *args);
+                                             MlirType const *args,
+                                             MlirLocation const *locs);
 
 /// Takes a block owned by the caller and destroys it.
 MLIR_CAPI_EXPORTED void mlirBlockDestroy(MlirBlock block);
 
 /// Checks whether a block is null.
 static inline bool mlirBlockIsNull(MlirBlock block) { return !block.ptr; }
 
 /// Checks whether two blocks handles point to the same block. This does not
mlirBlockInsertOwnedOperationBefore(MlirBlock block, MlirOperation reference,
                                     MlirOperation operation);
 
 /// Returns the number of arguments of the block.
 MLIR_CAPI_EXPORTED intptr_t mlirBlockGetNumArguments(MlirBlock block);
 
 /// Appends an argument of the specified type to the block. Returns the newly
 /// added argument.
 MLIR_CAPI_EXPORTED MlirValue mlirBlockAddArgument(MlirBlock block,
-                                                  MlirType type);
+                                                  MlirType type,
+                                                  MlirLocation loc);
 
 /// Returns `pos`-th argument of the block.
 MLIR_CAPI_EXPORTED MlirValue mlirBlockGetArgument(MlirBlock block,
                                                   intptr_t pos);
 
 /// Prints a block by sending chunks of the string representation and
 /// forwarding `userData to `callback`. Note that the callback may be called
 /// several times with consecutive chunks of the string.

mlir/include/mlir/Dialect/GPU/GPUOps.td

ArrayRef<BlockArgument> getWorkgroupAttributions() {
       auto begin =
           std::next(getBody().args_begin(), getType().getNumInputs());
       auto end = std::next(begin, getNumWorkgroupAttributions());
       return {begin, end};
     }
 
     /// Adds a new block argument that corresponds to buffers located in
     /// workgroup memory.
-    BlockArgument addWorkgroupAttribution(Type type);
+    BlockArgument addWorkgroupAttribution(Type type, Location loc);
 
     /// Returns the number of buffers located in the private memory.
     unsigned getNumPrivateAttributions() {
       return getBody().getNumArguments() - getType().getNumInputs() -
           getNumWorkgroupAttributions();
     }
 
     /// Returns a list of block arguments that correspond to buffers located in
     /// the private memory.
     ArrayRef<BlockArgument> getPrivateAttributions() {
       // Buffers on the private memory always come after buffers on the workgroup
       // memory.
       auto begin =
           std::next(getBody().args_begin(),
                     getType().getNumInputs() + getNumWorkgroupAttributions());
       return {begin, getBody().args_end()};
     }
 
     /// Adds a new block argument that corresponds to buffers located in
     /// private memory.
-    BlockArgument addPrivateAttribution(Type type);
+    BlockArgument addPrivateAttribution(Type type, Location loc);
 
     /// Returns the name of the attribute containing the number of buffers
     /// located in the workgroup memory.
     static StringRef getNumWorkgroupAttributionsAttrName() {
       return "workgroup_attributions";
     }
 
     /// Returns the type of this function.

mlir/include/mlir/Dialect/Linalg/IR/LinalgOps.td

OpResult getTiedOpResult(OpOperand& opOperand) {
     /// Append `operand` to the `input` arguments.
     OpOperand& appendInputOperand(OpBuilder& builder, Value operand) {
       int numLoops = getNumLoops();
       int numInputs = getNumInputs();
       int numOutputs = getNumOutputs();
 
       getOperation()->insertOperands(getNumControlOperands() + numInputs,
                                      operand);
-      getBody()->insertArgument(numLoops + numInputs, operand.getType());
+      getBody()->insertArgument(numLoops + numInputs, operand.getType(), 
+                                getLoc());
       getOperation()->setAttr(
           TiledLoopOp::getOperandSegmentSizeAttr(),
           builder.getI32VectorAttr(
               {numLoops, numLoops, numLoops, numInputs + 1, numOutputs}));
       return getOperation()->getOpOperand(getNumControlOperands() + numInputs);
     }
 
     /// Append `operand` to the `output` arguments.
     OpOperand& appendOutputOperand(OpBuilder& builder, Value operand) {
       int numLoops = getNumLoops();
       int numInputs = getNumInputs();
       int numOutputs = getNumOutputs();
 
       getOperation()->insertOperands(
           getNumControlOperands() + numInputs + numOutputs, operand);
       getBody()->insertArgument(numLoops + numInputs + numOutputs,
-                                operand.getType());
+                                operand.getType(), getLoc());
       getOperation()->setAttr(
           TiledLoopOp::getOperandSegmentSizeAttr(),
           builder.getI32VectorAttr(
               {numLoops, numLoops, numLoops, numInputs, numOutputs + 1}));
       return getOperation()->getOpOperand(getNumControlOperands() + numInputs +
                                           numOutputs);
     }
 

mlir/include/mlir/IR/Block.h

public:
   args_iterator args_begin() { return getArguments().begin(); }
   args_iterator args_end() { return getArguments().end(); }
   reverse_args_iterator args_rbegin() { return getArguments().rbegin(); }
   reverse_args_iterator args_rend() { return getArguments().rend(); }
 
   bool args_empty() { return arguments.empty(); }
 
   /// Add one value to the argument list.
-  BlockArgument addArgument(Type type, Optional<Location> loc = {});
+  BlockArgument addArgument(Type type, Location loc);
 
   /// Insert one value to the position in the argument list indicated by the
   /// given iterator. The existing arguments are shifted. The block is expected
   /// not to have predecessors.
-  BlockArgument insertArgument(args_iterator it, Type type,
-                               Optional<Location> loc = {});
+  BlockArgument insertArgument(args_iterator it, Type type, Location loc);
 
   /// Add one argument to the argument list for each type specified in the list.
+  /// `locs` is required to have the same number of elements as `types`.
   iterator_range<args_iterator> addArguments(TypeRange types,
-                                             ArrayRef<Location> locs = {});
+                                             ArrayRef<Location> locs);
 
   /// Add one value to the argument list at the specified position.
-  BlockArgument insertArgument(unsigned index, Type type,
-                               Optional<Location> loc = {});
+  BlockArgument insertArgument(unsigned index, Type type, Location loc);
 
   /// Erase the argument at 'index' and remove it from the argument list.
   void eraseArgument(unsigned index);
   /// Erases the arguments listed in `argIndices` and removes them from the
   /// argument list.
   /// `argIndices` is allowed to have duplicates and can be in any order.
   void eraseArguments(ArrayRef<unsigned> argIndices);
   /// Erases the arguments that have their corresponding bit set in

mlir/include/mlir/IR/Builders.h

public:
   Block *getBlock() const { return block; }
 
   //===--------------------------------------------------------------------===//
   // Block Creation
   //===--------------------------------------------------------------------===//
 
   /// Add new block with 'argTypes' arguments and set the insertion point to the
   /// end of it. The block is inserted at the provided insertion point of
-  /// 'parent'.
+  /// 'parent'. `locs` contains the locations of the inserted arguments, and
+  /// should match the size of `argTypes`.
   Block *createBlock(Region *parent, Region::iterator insertPt = {},
                      TypeRange argTypes = llvm::None,
-                     ArrayRef<Location> locs = {});
+                     ArrayRef<Location> locs = llvm::None);
 
   /// Add new block with 'argTypes' arguments and set the insertion point to the
-  /// end of it. The block is placed before 'insertBefore'.
+  /// end of it. The block is placed before 'insertBefore'. `locs` contains the
+  /// locations of the inserted arguments, and should match the size of
+  /// `argTypes`.
   Block *createBlock(Block *insertBefore, TypeRange argTypes = llvm::None,
-                     ArrayRef<Location> locs = {});
+                     ArrayRef<Location> locs = llvm::None);
 
   //===--------------------------------------------------------------------===//
   // Operation Creation
   //===--------------------------------------------------------------------===//
 
   /// Insert the given operation at the current insertion point and return it.
   Operation *insert(Operation *op);
 

mlir/include/mlir/IR/FunctionImplementation.h

 /// Parses function arguments using `parser`. The `allowVariadic` argument
 /// indicates whether functions with variadic arguments are supported. The
 /// trailing arguments are populated by this function with names, types,
 /// attributes and locations of the arguments.
 ParseResult parseFunctionArgumentList(
     OpAsmParser &parser, bool allowAttributes, bool allowVariadic,
     SmallVectorImpl<OpAsmParser::OperandType> &argNames,
     SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
-    SmallVectorImpl<Optional<Location>> &argLocations, bool &isVariadic);
+    SmallVectorImpl<Location> &argLocations, bool &isVariadic);
 
 /// Parses a function signature using `parser`. The `allowVariadic` argument
 /// indicates whether functions with variadic arguments are supported. The
 /// trailing arguments are populated by this function with names, types,
 /// attributes and locations of the arguments and those of the results.
 ParseResult
 parseFunctionSignature(OpAsmParser &parser, bool allowVariadic,
                        SmallVectorImpl<OpAsmParser::OperandType> &argNames,
                        SmallVectorImpl<Type> &argTypes,
                        SmallVectorImpl<NamedAttrList> &argAttrs,
-                       SmallVectorImpl<Optional<Location>> &argLocations,
+                       SmallVectorImpl<Location> &argLocations,
                        bool &isVariadic, SmallVectorImpl<Type> &resultTypes,
                        SmallVectorImpl<NamedAttrList> &resultAttrs);
 
 /// Parser implementation for function-like operations.  Uses
 /// `funcTypeBuilder` to construct the custom function type given lists of
 /// input and output types.  If `allowVariadic` is set, the parser will accept
 /// trailing ellipsis in the function signature and indicate to the builder
 /// whether the function is variadic.  If the builder returns a null type,

mlir/include/mlir/IR/FunctionInterfaces.h

inline ArrayRef<NamedAttribute> getResultAttrs(Operation *op, unsigned index) {
   auto resultDict = getResultAttrDict(op, index);
   return resultDict ? resultDict.getValue() : llvm::None;
 }
 
 /// Insert the specified arguments and update the function type attribute.
 void insertFunctionArguments(Operation *op, ArrayRef<unsigned> argIndices,
                              TypeRange argTypes,
                              ArrayRef<DictionaryAttr> argAttrs,
-                             ArrayRef<Optional<Location>> argLocs,
+                             ArrayRef<Location> argLocs,
                              unsigned originalNumArgs, Type newType);
 
 /// Insert the specified results and update the function type attribute.
 void insertFunctionResults(Operation *op, ArrayRef<unsigned> resultIndices,
                            TypeRange resultTypes,
                            ArrayRef<DictionaryAttr> resultAttrs,
                            unsigned originalNumResults, Type newType);
 

mlir/include/mlir/IR/FunctionInterfaces.td

let extraSharedClassDeclaration = [{
 
     /// Add an entry block to an empty function, and set up the block arguments
     /// to match the signature of the function. The newly inserted entry block
     /// is returned.
     Block *addEntryBlock() {
       assert(empty() && "function already has an entry block");
       Block *entry = new Block();
       push_back(entry);
-      entry->addArguments($_op.getArgumentTypes());
+      
+      // FIXME: Allow for passing in locations for these arguments instead of using
+      // the operations location.
+      ArrayRef<Type> inputTypes = $_op.getArgumentTypes();
+      SmallVector<Location> locations(inputTypes.size(),
+                                      $_op.getOperation()->getLoc());
+      entry->addArguments(inputTypes, locations);
       return entry;
     }
 
     /// Add a normal block to the end of the function's block list. The function
     /// should at least already have an entry block.
     Block *addBlock() {
       assert(!empty() && "function should at least have an entry block");
       push_back(new Block());
let extraSharedClassDeclaration = [{
     /// Support argument iteration.
     args_iterator args_begin() { return getBody().args_begin(); }
     args_iterator args_end() { return getBody().args_end(); }
     BlockArgListType getArguments() { return getBody().getArguments(); }
 
     /// Insert a single argument of type `argType` with attributes `argAttrs` and
     /// location `argLoc` at `argIndex`.
     void insertArgument(unsigned argIndex, Type argType, DictionaryAttr argAttrs,
-                        Optional<Location> argLoc = {}) {
+                        Location argLoc) {
       insertArguments({argIndex}, {argType}, {argAttrs}, {argLoc});
     }
 
     /// Inserts arguments with the listed types, attributes, and locations at the
     /// listed indices. `argIndices` must be sorted. Arguments are inserted in the
     /// order they are listed, such that arguments with identical index will
     /// appear in the same order that they were listed here.
     void insertArguments(ArrayRef<unsigned> argIndices, TypeRange argTypes,
                         ArrayRef<DictionaryAttr> argAttrs,
-                        ArrayRef<Optional<Location>> argLocs) {
+                        ArrayRef<Location> argLocs) {
       unsigned originalNumArgs = $_op.getNumArguments();
       Type newType = $_op.getTypeWithArgsAndResults(
           argIndices, argTypes, /*resultIndices=*/{}, /*resultTypes=*/{});
       function_interface_impl::insertFunctionArguments(
           this->getOperation(), argIndices, argTypes, argAttrs, argLocs,
           originalNumArgs, newType);
     }
 

mlir/include/mlir/IR/OpImplementation.h

public:
 
   //===--------------------------------------------------------------------===//
   // Region Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parses a region. Any parsed blocks are appended to 'region' and must be
   /// moved to the op regions after the op is created. The first block of the
   /// region takes 'arguments' of types 'argTypes'. If `argLocations` is
-  /// non-empty it contains an optional location to be attached to each
-  /// argument. If 'enableNameShadowing' is set to true, the argument names are
-  /// allowed to shadow the names of other existing SSA values defined above the
-  /// region scope. 'enableNameShadowing' can only be set to true for regions
-  /// attached to operations that are 'IsolatedFromAbove'.
-  virtual ParseResult
-  parseRegion(Region &region, ArrayRef<OperandType> arguments = {},
+  /// non-empty it contains a location to be attached to each argument. If
+  /// 'enableNameShadowing' is set to true, the argument names are allowed to
+  /// shadow the names of other existing SSA values defined above the region
+  /// scope. 'enableNameShadowing' can only be set to true for regions attached
+  /// to operations that are 'IsolatedFromAbove'.
+  virtual ParseResult parseRegion(Region &region,
+                                  ArrayRef<OperandType> arguments = {},
                                   ArrayRef<Type> argTypes = {},
-              ArrayRef<Optional<Location>> argLocations = {},
+                                  ArrayRef<Location> argLocations = {},
                                   bool enableNameShadowing = false) = 0;
 
   /// Parses a region if present.
   virtual OptionalParseResult
   parseOptionalRegion(Region &region, ArrayRef<OperandType> arguments = {},
                       ArrayRef<Type> argTypes = {},
-                      ArrayRef<Optional<Location>> argLocations = {},
+                      ArrayRef<Location> argLocations = {},
                       bool enableNameShadowing = false) = 0;
 
   /// Parses a region if present. If the region is present, a new region is
   /// allocated and placed in `region`. If no region is present or on failure,
   /// `region` remains untouched.
   virtual OptionalParseResult parseOptionalRegion(
       std::unique_ptr<Region> &region, ArrayRef<OperandType> arguments = {},
       ArrayRef<Type> argTypes = {}, bool enableNameShadowing = false) = 0;

mlir/include/mlir/IR/Region.h

public:
   //===--------------------------------------------------------------------===//
 
   // This is the list of arguments to the block.
   using BlockArgListType = MutableArrayRef<BlockArgument>;
   BlockArgListType getArguments() {
     return empty() ? BlockArgListType() : front().getArguments();
   }
 
+  /// Returns the argument types of the first block within the region.
   ValueTypeRange<BlockArgListType> getArgumentTypes();
 
   using args_iterator = BlockArgListType::iterator;
   using reverse_args_iterator = BlockArgListType::reverse_iterator;
   args_iterator args_begin() { return getArguments().begin(); }
   args_iterator args_end() { return getArguments().end(); }
   reverse_args_iterator args_rbegin() { return getArguments().rbegin(); }
   reverse_args_iterator args_rend() { return getArguments().rend(); }
 
   bool args_empty() { return getArguments().empty(); }
 
   /// Add one value to the argument list.
-  BlockArgument addArgument(Type type) { return front().addArgument(type); }
+  BlockArgument addArgument(Type type, Location loc) {
+    return front().addArgument(type, loc);
+  }
 
   /// Insert one value to the position in the argument list indicated by the
   /// given iterator. The existing arguments are shifted. The block is expected
   /// not to have predecessors.
-  BlockArgument insertArgument(args_iterator it, Type type) {
-    return front().insertArgument(it, type);
+  BlockArgument insertArgument(args_iterator it, Type type, Location loc) {
+    return front().insertArgument(it, type, loc);
   }
 
   /// Add one argument to the argument list for each type specified in the list.
-  iterator_range<args_iterator> addArguments(TypeRange types);
+  /// `locs` contains the locations for each of the new arguments, and must be
+  /// of equal size to `types`.
+  iterator_range<args_iterator> addArguments(TypeRange types,
+                                             ArrayRef<Location> locs);
 
   /// Add one value to the argument list at the specified position.
-  BlockArgument insertArgument(unsigned index, Type type) {
-    return front().insertArgument(index, type);
+  BlockArgument insertArgument(unsigned index, Type type, Location loc) {
+    return front().insertArgument(index, type, loc);
   }
 
   /// Erase the argument at 'index' and remove it from the argument list.
   void eraseArgument(unsigned index) { front().eraseArgument(index); }
 
   unsigned getNumArguments() { return getArguments().size(); }
   BlockArgument getArgument(unsigned i) { return getArguments()[i]; }
 

mlir/lib/Bindings/Python/IRCore.cpp

while (!mlirBlockIsNull(block)) {
       index -= 1;
     }
     throw SetPyError(PyExc_IndexError, "attempt to access out of bounds block");
   }
 
   PyBlock appendBlock(const py::args &pyArgTypes) {
     operation->checkValid();
     llvm::SmallVector<MlirType, 4> argTypes;
+    llvm::SmallVector<MlirLocation, 4> argLocs;
     argTypes.reserve(pyArgTypes.size());
+    argLocs.reserve(pyArgTypes.size());
     for (auto &pyArg : pyArgTypes) {
       argTypes.push_back(pyArg.cast<PyType &>());
+      // TODO: Pass in a proper location here.
+      argLocs.push_back(
+          mlirLocationUnknownGet(mlirTypeGetContext(argTypes.back())));
     }
 
-    MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data());
+    MlirBlock block =
+        mlirBlockCreate(argTypes.size(), argTypes.data(), argLocs.data());
     mlirRegionAppendOwnedBlock(region, block);
     return PyBlock(operation, block);
   }
 
   static void bind(py::module &m) {
     py::class_<PyBlockList>(m, "BlockList", py::module_local())
         .def("__getitem__", &PyBlockList::dunderGetItem)
         .def("__iter__", &PyBlockList::dunderIter)
py::class_<PyBlock>(m, "Block", py::module_local())
             return PyOperationList(self.getParentOperation(), self.get());
           },
           "Returns a forward-optimized sequence of operations.")
       .def_static(
           "create_at_start",
           [](PyRegion &parent, py::list pyArgTypes) {
             parent.checkValid();
             llvm::SmallVector<MlirType, 4> argTypes;
+            llvm::SmallVector<MlirLocation, 4> argLocs;
             argTypes.reserve(pyArgTypes.size());
+            argLocs.reserve(pyArgTypes.size());
             for (auto &pyArg : pyArgTypes) {
               argTypes.push_back(pyArg.cast<PyType &>());
+              // TODO: Pass in a proper location here.
+              argLocs.push_back(
+                  mlirLocationUnknownGet(mlirTypeGetContext(argTypes.back())));
             }
 
-            MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data());
+            MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data(),
+                                              argLocs.data());
             mlirRegionInsertOwnedBlock(parent, 0, block);
             return PyBlock(parent.getParentOperation(), block);
           },
           py::arg("parent"), py::arg("arg_types") = py::list(),
           "Creates and returns a new Block at the beginning of the given "
           "region (with given argument types).")
       .def(
           "create_before",
           [](PyBlock &self, py::args pyArgTypes) {
             self.checkValid();
             llvm::SmallVector<MlirType, 4> argTypes;
+            llvm::SmallVector<MlirLocation, 4> argLocs;
             argTypes.reserve(pyArgTypes.size());
+            argLocs.reserve(pyArgTypes.size());
             for (auto &pyArg : pyArgTypes) {
               argTypes.push_back(pyArg.cast<PyType &>());
+              // TODO: Pass in a proper location here.
+              argLocs.push_back(
+                  mlirLocationUnknownGet(mlirTypeGetContext(argTypes.back())));
             }
 
-            MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data());
+            MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data(),
+                                              argLocs.data());
             MlirRegion region = mlirBlockGetParentRegion(self.get());
             mlirRegionInsertOwnedBlockBefore(region, self.get(), block);
             return PyBlock(self.getParentOperation(), block);
           },
           "Creates and returns a new Block before this block "
           "(with given argument types).")
       .def(
           "create_after",
           [](PyBlock &self, py::args pyArgTypes) {
             self.checkValid();
             llvm::SmallVector<MlirType, 4> argTypes;
+            llvm::SmallVector<MlirLocation, 4> argLocs;
             argTypes.reserve(pyArgTypes.size());
+            argLocs.reserve(pyArgTypes.size());
             for (auto &pyArg : pyArgTypes) {
               argTypes.push_back(pyArg.cast<PyType &>());
-            }
 
-            MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data());
+              // TODO: Pass in a proper location here.
+              argLocs.push_back(
+                  mlirLocationUnknownGet(mlirTypeGetContext(argTypes.back())));
+            }
+            MlirBlock block = mlirBlockCreate(argTypes.size(), argTypes.data(),
+                                              argLocs.data());
             MlirRegion region = mlirBlockGetParentRegion(self.get());
             mlirRegionInsertOwnedBlockAfter(region, self.get(), block);
             return PyBlock(self.getParentOperation(), block);
           },
           "Creates and returns a new Block after this block "
           "(with given argument types).")
       .def(
           "__iter__",

mlir/lib/CAPI/Dialect/Linalg.cpp

LinalgDialect::RegionBuilderFunType fun =
       dialect->getRegionBuilder(op->getName().getStringRef());
 
   assert(fun && "Expected a builtin named Linalg op.");
   assert(op->getNumRegions() == 1 && "Expected Linalg op with 1 region");
   assert(op->getRegion(0).getBlocks().empty() &&
          "Expected Linalg op with 0 blocks");
 
   SmallVector<Type, 8> argTypes;
-  for (OpOperand *opOperand : linalgOp.getInputAndOutputOperands())
+  SmallVector<Location, 8> argLocs;
+  for (OpOperand *opOperand : linalgOp.getInputAndOutputOperands()) {
     argTypes.push_back(getElementTypeOrSelf(opOperand->get().getType()));
+    argLocs.push_back(opOperand->get().getLoc());
+  }
 
   ImplicitLocOpBuilder b(op->getLoc(), op->getContext());
   Region &region = op->getRegion(0);
-  Block *body = b.createBlock(&region, /*insertPt=*/{}, argTypes);
+  Block *body = b.createBlock(&region, /*insertPt=*/{}, argTypes, argLocs);
   b.setInsertionPointToStart(body);
   fun(b, *body);
 }
 
 MLIR_DEFINE_CAPI_DIALECT_REGISTRATION(Linalg, linalg, LinalgDialect)

mlir/lib/CAPI/IR/IR.cpp

 void mlirRegionDestroy(MlirRegion region) {
   delete static_cast<Region *>(region.ptr);
 }
 
 //===----------------------------------------------------------------------===//
 // Block API.
 //===----------------------------------------------------------------------===//
 
-MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args) {
+MlirBlock mlirBlockCreate(intptr_t nArgs, MlirType const *args,
+                          MlirLocation const *locs) {
   Block *b = new Block;
   for (intptr_t i = 0; i < nArgs; ++i)
-    b->addArgument(unwrap(args[i]));
+    b->addArgument(unwrap(args[i]), unwrap(locs[i]));
   return wrap(b);
 }
 
 bool mlirBlockEqual(MlirBlock block, MlirBlock other) {
   return unwrap(block) == unwrap(other);
 }
 
 MlirOperation mlirBlockGetParentOperation(MlirBlock block) {

 }
 
 void mlirBlockDestroy(MlirBlock block) { delete unwrap(block); }
 
 intptr_t mlirBlockGetNumArguments(MlirBlock block) {
   return static_cast<intptr_t>(unwrap(block)->getNumArguments());
 }
 
-MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type) {
-  return wrap(unwrap(block)->addArgument(unwrap(type)));
+MlirValue mlirBlockAddArgument(MlirBlock block, MlirType type,
+                               MlirLocation loc) {
+  return wrap(unwrap(block)->addArgument(unwrap(type), unwrap(loc)));
 }
 
 MlirValue mlirBlockGetArgument(MlirBlock block, intptr_t pos) {
   return wrap(unwrap(block)->getArgument(static_cast<unsigned>(pos)));
 }
 
 void mlirBlockPrint(MlirBlock block, MlirStringCallback callback,
                     void *userData) {

mlir/lib/Conversion/MemRefToLLVM/MemRefToLLVM.cpp

matchAndRewrite(memref::AllocaScopeOp allocaScopeOp, OpAdaptor adaptor,
     // point.
     auto *currentBlock = rewriter.getInsertionBlock();
     auto *remainingOpsBlock =
         rewriter.splitBlock(currentBlock, rewriter.getInsertionPoint());
     Block *continueBlock;
     if (allocaScopeOp.getNumResults() == 0) {
       continueBlock = remainingOpsBlock;
     } else {
-      continueBlock = rewriter.createBlock(remainingOpsBlock,
-                                           allocaScopeOp.getResultTypes());
+      continueBlock = rewriter.createBlock(
+          remainingOpsBlock, allocaScopeOp.getResultTypes(),
+          SmallVector<Location>(allocaScopeOp->getNumResults(),
+                                allocaScopeOp.getLoc()));
       rewriter.create<LLVM::BrOp>(loc, ValueRange(), remainingOpsBlock);
     }
 
     // Inline body region.
     Block *beforeBody = &allocaScopeOp.bodyRegion().front();
     Block *afterBody = &allocaScopeOp.bodyRegion().back();
     rewriter.inlineRegionBefore(allocaScopeOp.bodyRegion(), continueBlock);
 
convertSourceMemRefToDescriptor(ConversionPatternRewriter &rewriter,
     Value resultRankMinusOne =
         rewriter.create<LLVM::SubOp>(loc, resultRank, oneIndex);
 
     Block *initBlock = rewriter.getInsertionBlock();
     Type indexType = getTypeConverter()->getIndexType();
     Block::iterator remainingOpsIt = std::next(rewriter.getInsertionPoint());
 
     Block *condBlock = rewriter.createBlock(initBlock->getParent(), {},
-                                            {indexType, indexType});
+                                            {indexType, indexType}, {loc, loc});
 
     // Move the remaining initBlock ops to condBlock.
     Block *remainingBlock = rewriter.splitBlock(initBlock, remainingOpsIt);
     rewriter.mergeBlocks(remainingBlock, condBlock, ValueRange());
 
     rewriter.setInsertionPointToEnd(initBlock);
     rewriter.create<LLVM::BrOp>(loc, ValueRange({resultRankMinusOne, oneIndex}),
                                 condBlock);

mlir/lib/Conversion/PDLToPDLInterp/PDLToPDLInterp.cpp

if (pdl::AttributeOp attrOp = dyn_cast<pdl::AttributeOp>(oldOp)) {
                    typeOp.getLoc(), typeOp.getType(), type);
       }
     }
 
     // Otherwise, add this as an input to the rewriter.
     Position *inputPos = valueToPosition.lookup(oldValue);
     assert(inputPos && "expected value to be a pattern input");
     usedMatchValues.push_back(inputPos);
-    return newValue = rewriterFunc.front().addArgument(oldValue.getType());
+    return newValue = rewriterFunc.front().addArgument(oldValue.getType(),
+                                                       oldValue.getLoc());
   };
 
   // If this is a custom rewriter, simply dispatch to the registered rewrite
   // method.
   pdl::RewriteOp rewriter = pattern.getRewriter();
   if (StringAttr rewriteName = rewriter.nameAttr()) {
     SmallVector<Value> args;
     if (rewriter.root())

mlir/lib/Conversion/SCFToOpenMP/SCFToOpenMP.cpp

static omp::ReductionDeclareOp createDecl(PatternRewriter &builder,
                                           Attribute initValue) {
   OpBuilder::InsertionGuard guard(builder);
   auto decl = builder.create<omp::ReductionDeclareOp>(
       reduce.getLoc(), "__scf_reduction", reduce.getOperand().getType());
   symbolTable.insert(decl);
 
   Type type = reduce.getOperand().getType();
   builder.createBlock(&decl.initializerRegion(), decl.initializerRegion().end(),
-                      {type});
+                      {type}, {reduce.getOperand().getLoc()});
   builder.setInsertionPointToEnd(&decl.initializerRegion().back());
   Value init =
       builder.create<LLVM::ConstantOp>(reduce.getLoc(), type, initValue);
   builder.create<omp::YieldOp>(reduce.getLoc(), init);
 
   Operation *terminator = &reduce.getRegion().front().back();
   assert(isa<scf::ReduceReturnOp>(terminator) &&
          "expected reduce op to be terminated by redure return");

 /// using llvm.atomicrmw of the given kind.
 static omp::ReductionDeclareOp addAtomicRMW(OpBuilder &builder,
                                             LLVM::AtomicBinOp atomicKind,
                                             omp::ReductionDeclareOp decl,
                                             scf::ReduceOp reduce) {
   OpBuilder::InsertionGuard guard(builder);
   Type type = reduce.getOperand().getType();
   Type ptrType = LLVM::LLVMPointerType::get(type);
+  Location reduceOperandLoc = reduce.getOperand().getLoc();
   builder.createBlock(&decl.atomicReductionRegion(),
-                      decl.atomicReductionRegion().end(), {ptrType, ptrType});
+                      decl.atomicReductionRegion().end(), {ptrType, ptrType},
+                      {reduceOperandLoc, reduceOperandLoc});
   Block *atomicBlock = &decl.atomicReductionRegion().back();
   builder.setInsertionPointToEnd(atomicBlock);
   Value loaded = builder.create<LLVM::LoadOp>(reduce.getLoc(),
                                               atomicBlock->getArgument(1));
   builder.create<LLVM::AtomicRMWOp>(reduce.getLoc(), type, atomicKind,
                                     atomicBlock->getArgument(0), loaded,
                                     LLVM::AtomicOrdering::monotonic);
   builder.create<omp::YieldOp>(reduce.getLoc(), ArrayRef<Value>());

mlir/lib/Conversion/SCFToSPIRV/SCFToSPIRV.cpp

ForOpConversion::matchAndRewrite(scf::ForOp forOp, OpAdaptor adaptor,
 
   OpBuilder::InsertionGuard guard(rewriter);
   // Create the block for the header.
   auto *header = new Block();
   // Insert the header.
   loopOp.body().getBlocks().insert(getBlockIt(loopOp.body(), 1), header);
 
   // Create the new induction variable to use.
+  Value adapLowerBound = adaptor.getLowerBound();
   BlockArgument newIndVar =
-      header->addArgument(adaptor.getLowerBound().getType());
+      header->addArgument(adapLowerBound.getType(), adapLowerBound.getLoc());
   for (Value arg : adaptor.getInitArgs())
-    header->addArgument(arg.getType());
+    header->addArgument(arg.getType(), arg.getLoc());
   Block *body = forOp.getBody();
 
   // Apply signature conversion to the body of the forOp. It has a single block,
   // with argument which is the induction variable. That has to be replaced with
   // the new induction variable.
   TypeConverter::SignatureConversion signatureConverter(
       body->getNumArguments());
   signatureConverter.remapInput(0, newIndVar);

mlir/lib/Conversion/SCFToStandard/SCFToStandard.cpp

LogicalResult IfLowering::matchAndRewrite(IfOp ifOp,
   auto *condBlock = rewriter.getInsertionBlock();
   auto opPosition = rewriter.getInsertionPoint();
   auto *remainingOpsBlock = rewriter.splitBlock(condBlock, opPosition);
   Block *continueBlock;
   if (ifOp.getNumResults() == 0) {
     continueBlock = remainingOpsBlock;
   } else {
     continueBlock =
-        rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes());
+        rewriter.createBlock(remainingOpsBlock, ifOp.getResultTypes(),
+                             SmallVector<Location>(ifOp.getNumResults(), loc));
     rewriter.create<BranchOp>(loc, remainingOpsBlock);
   }
 
   // Move blocks from the "then" region to the region containing 'scf.if',
   // place it before the continuation block, and branch to it.
   auto &thenRegion = ifOp.getThenRegion();
   auto *thenBlock = &thenRegion.front();
   Operation *thenTerminator = thenRegion.back().getTerminator();
if (auto terminator = dyn_cast<scf::YieldOp>(block.getTerminator())) {
       rewriter.create<BranchOp>(loc, remainingOpsBlock, terminatorOperands);
       rewriter.eraseOp(terminator);
     }
   }
 
   rewriter.inlineRegionBefore(region, remainingOpsBlock);
 
   SmallVector<Value> vals;
-  for (auto arg : remainingOpsBlock->addArguments(op->getResultTypes())) {
+  SmallVector<Location> argLocs(op.getNumResults(), op->getLoc());
+  for (auto arg :
+       remainingOpsBlock->addArguments(op->getResultTypes(), argLocs))
     vals.push_back(arg);
-  }
   rewriter.replaceOp(op, vals);
   return success();
 }
 
 LogicalResult
 ParallelLowering::matchAndRewrite(ParallelOp parallelOp,
                                   PatternRewriter &rewriter) const {
   Location loc = parallelOp.getLoc();

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

struct GenericAtomicRMWOpLowering
   matchAndRewrite(GenericAtomicRMWOp atomicOp, OpAdaptor adaptor,
                   ConversionPatternRewriter &rewriter) const override {
 
     auto loc = atomicOp.getLoc();
     Type valueType = typeConverter->convertType(atomicOp.getResult().getType());
 
     // Split the block into initial, loop, and ending parts.
     auto *initBlock = rewriter.getInsertionBlock();
-    auto *loopBlock =
-        rewriter.createBlock(initBlock->getParent(),
-                             std::next(Region::iterator(initBlock)), valueType);
+    auto *loopBlock = rewriter.createBlock(
+        initBlock->getParent(), std::next(Region::iterator(initBlock)),
+        valueType, loc);
     auto *endBlock = rewriter.createBlock(
         loopBlock->getParent(), std::next(Region::iterator(loopBlock)));
 
     // Operations range to be moved to `endBlock`.
     auto opsToMoveStart = atomicOp->getIterator();
     auto opsToMoveEnd = initBlock->back().getIterator();
 
     // Compute the loaded value and branch to the loop block.

mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp

if (isa<tosa::ClzOp>(op) && elementTy.isa<IntegerType>()) {
     int bitWidth = elementTy.getIntOrFloatBitWidth();
     auto zero =
         rewriter.create<arith::ConstantOp>(loc, IntegerAttr::get(elementTy, 0));
     auto leadingZeros = rewriter.create<arith::ConstantOp>(
         loc, IntegerAttr::get(elementTy, bitWidth));
 
     SmallVector<Value> operands = {args[0], leadingZeros, zero};
     SmallVector<Type> types = {elementTy, elementTy, elementTy};
+    SmallVector<Location> locations = {loc, loc, loc};
 
     auto whileOp = rewriter.create<scf::WhileOp>(loc, types, operands);
-    Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, types);
-    Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, types);
+    Block *before =
+        rewriter.createBlock(&whileOp.getBefore(), {}, types, locations);
+    Block *after =
+        rewriter.createBlock(&whileOp.getAfter(), {}, types, locations);
 
     // The conditional block of the while loop.
     {
       rewriter.setInsertionPointToStart(&whileOp.getBefore().front());
       Value input = before->getArgument(0);
       Value zero = before->getArgument(2);
 
       Value inputLargerThanZero = rewriter.create<arith::CmpIOp>(
LogicalResult matchAndRewrite(tosa::ResizeOp op,
 
     auto genericOp = rewriter.create<linalg::GenericOp>(
         loc, resultTy, ValueRange({}), ValueRange{initTensor}, affineMaps,
         getNParallelLoopsAttrs(resultTy.getRank()));
     rewriter.replaceOp(op, genericOp.getResult(0));
 
     OpBuilder::InsertionGuard regionGuard(rewriter);
     rewriter.createBlock(&genericOp.region(), genericOp.region().end(),
-                         TypeRange({resultElementTy}));
+                         TypeRange({resultElementTy}), loc);
     Value batch = rewriter.create<linalg::IndexOp>(loc, 0);
     Value y = rewriter.create<linalg::IndexOp>(loc, 1);
     Value x = rewriter.create<linalg::IndexOp>(loc, 2);
     Value channel = rewriter.create<linalg::IndexOp>(loc, 3);
 
     auto hwMin =
         rewriter.create<arith::ConstantOp>(loc, rewriter.getI32IntegerAttr(0));
     auto hMax = rewriter.create<arith::ConstantOp>(
LogicalResult matchAndRewrite(tosa::TableOp op,
 
     auto genericOp = rewriter.create<linalg::GenericOp>(
         loc, resultTy, ValueRange({input}), ValueRange{initTensor}, affineMaps,
         getNParallelLoopsAttrs(resultTy.getRank()));
     rewriter.replaceOp(op, genericOp.getResult(0));
 
     {
       OpBuilder::InsertionGuard regionGuard(rewriter);
-      Block *block =
-          rewriter.createBlock(&genericOp.region(), genericOp.region().end(),
-                               TypeRange({inputElementTy, resultElementTy}));
+      Block *block = rewriter.createBlock(
+          &genericOp.region(), genericOp.region().end(),
+          TypeRange({inputElementTy, resultElementTy}), {loc, loc});
 
       auto inputValue = block->getArgument(0);
       rewriter.setInsertionPointToStart(block);
       if (inputElementTy.isInteger(8) && tableElementTy.isInteger(8) &&
           resultElementTy.isInteger(8)) {
         Value index = rewriter.create<arith::IndexCastOp>(
             loc, rewriter.getIndexType(), inputValue);
         Value offset = rewriter.create<arith::ConstantIndexOp>(loc, 128);

mlir/lib/Conversion/VectorToGPU/VectorToGPU.cpp

static scf::ForOp replaceForOpWithNewSignature(OpBuilder &b, scf::ForOp loop,
   operands.append(newIterOperands.begin(), newIterOperands.end());
   scf::ForOp newLoop =
       b.create<scf::ForOp>(loop.getLoc(), loop.getLowerBound(),
                            loop.getUpperBound(), loop.getStep(), operands);
   newLoop.getBody()->erase();
   newLoop.getLoopBody().getBlocks().splice(
       newLoop.getLoopBody().getBlocks().begin(),
       loop.getLoopBody().getBlocks());
-  for (auto operand : newIterOperands)
-    newLoop.getBody()->addArgument(operand.getType());
+  for (Value operand : newIterOperands)
+    newLoop.getBody()->addArgument(operand.getType(), operand.getLoc());
 
   for (auto it : llvm::zip(loop.getResults(), newLoop.getResults().take_front(
                                                   loop.getNumResults())))
     std::get<0>(it).replaceAllUsesWith(std::get<1>(it));
   loop.erase();
   return newLoop;
 }
 

mlir/lib/Dialect/Affine/IR/AffineOps.cpp

void AffineForOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(ubOperands);
 
   result.addOperands(iterArgs);
   // Create a region and a block for the body.  The argument of the region is
   // the loop induction variable.
   Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block);
   Block &bodyBlock = bodyRegion->front();
-  Value inductionVar = bodyBlock.addArgument(builder.getIndexType());
+  Value inductionVar =
+      bodyBlock.addArgument(builder.getIndexType(), result.location);
   for (Value val : iterArgs)
-    bodyBlock.addArgument(val.getType());
+    bodyBlock.addArgument(val.getType(), val.getLoc());
 
   // Create the default terminator if the builder is not provided and if the
   // iteration arguments are not provided. Otherwise, leave this to the caller
   // because we don't know which values to return from the loop.
   if (iterArgs.empty() && !bodyBuilder) {
     ensureTerminator(*bodyRegion, builder, result.location);
   } else if (bodyBuilder) {
     OpBuilder::InsertionGuard guard(builder);
AffineForOp mlir::replaceForOpWithNewYields(OpBuilder &b, AffineForOp loop,
   auto lbMap = loop.getLowerBoundMap();
   auto ubMap = loop.getUpperBoundMap();
   AffineForOp newLoop =
       b.create<AffineForOp>(loop.getLoc(), lbOperands, lbMap, ubOperands, ubMap,
                             loop.getStep(), operands);
   // Take the body of the original parent loop.
   newLoop.getLoopBody().takeBody(loop.getLoopBody());
   for (Value val : newIterArgs)
-    newLoop.getLoopBody().addArgument(val.getType());
+    newLoop.getLoopBody().addArgument(val.getType(), val.getLoc());
 
   // Update yield operation with new values to be added.
   if (!newYieldedValues.empty()) {
     auto yield = cast<AffineYieldOp>(newLoop.getBody()->getTerminator());
     b.setInsertionPoint(yield);
     auto yieldOperands = llvm::to_vector<4>(yield.getOperands());
     yieldOperands.append(newYieldedValues.begin(), newYieldedValues.end());
     b.create<AffineYieldOp>(yield.getLoc(), yieldOperands);
void AffineParallelOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(lbArgs);
   result.addOperands(ubArgs);
 
   // Create a region and a block for the body.
   auto *bodyRegion = result.addRegion();
   auto *body = new Block();
   // Add all the block arguments.
   for (unsigned i = 0, e = steps.size(); i < e; ++i)
-    body->addArgument(IndexType::get(builder.getContext()));
+    body->addArgument(IndexType::get(builder.getContext()), result.location);
   bodyRegion->push_back(body);
   if (resultTypes.empty())
     ensureTerminator(*bodyRegion, builder, result.location);
 }
 
 Region &AffineParallelOp::getLoopBody() { return region(); }
 
 bool AffineParallelOp::isDefinedOutsideOfLoop(Value value) {

mlir/lib/Dialect/Async/IR/Async.cpp

void ExecuteOp::build(OpBuilder &builder, OperationState &result,
 
   // Add a body region with block arguments as unwrapped async value operands.
   Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block);
   Block &bodyBlock = bodyRegion->front();
   for (Value operand : operands) {
     auto valueType = operand.getType().dyn_cast<ValueType>();
     bodyBlock.addArgument(valueType ? valueType.getValueType()
-                                    : operand.getType());
+                                    : operand.getType(),
+                          operand.getLoc());
   }
 
   // Create the default terminator if the builder is not provided and if the
   // expected result is empty. Otherwise, leave this to the caller
   // because we don't know which values to return from the execute op.
   if (resultTypes.empty() && !bodyBuilder) {
     OpBuilder::InsertionGuard guard(builder);
     builder.setInsertionPointToStart(&bodyBlock);

mlir/lib/Dialect/Async/Transforms/AsyncParallelFor.cpp

static ParallelComputeFunction createParallelComputeFunction(
   func.setPrivate();
 
   // Insert function into the module symbol table and assign it unique name.
   SymbolTable symbolTable(module);
   symbolTable.insert(func);
   rewriter.getListener()->notifyOperationInserted(func);
 
   // Create function entry block.
-  Block *block = b.createBlock(&func.getBody(), func.begin(), type.getInputs());
+  Block *block =
+      b.createBlock(&func.getBody(), func.begin(), type.getInputs(),
+                    SmallVector<Location>(type.getNumInputs(), op.getLoc()));
   b.setInsertionPointToEnd(block);
 
   ParallelComputeFunctionArgs args = {op.getNumLoops(), func.getArguments()};
 
   // Block iteration position defined by the block index and size.
   BlockArgument blockIndex = args.blockIndex();
   BlockArgument blockSize = args.blockSize();
 
static FuncOp createAsyncDispatchFunction(ParallelComputeFunction &computeFunc,
   func.setPrivate();
 
   // Insert function into the module symbol table and assign it unique name.
   SymbolTable symbolTable(module);
   symbolTable.insert(func);
   rewriter.getListener()->notifyOperationInserted(func);
 
   // Create function entry block.
-  Block *block = b.createBlock(&func.getBody(), func.begin(), type.getInputs());
+  Block *block = b.createBlock(&func.getBody(), func.begin(), type.getInputs(),
+                               SmallVector<Location>(type.getNumInputs(), loc));
   b.setInsertionPointToEnd(block);
 
   Type indexTy = b.getIndexType();
   Value c1 = b.create<arith::ConstantIndexOp>(1);
   Value c2 = b.create<arith::ConstantIndexOp>(2);
 
   // Get the async group that will track async dispatch completion.
   Value group = block->getArgument(0);
 
   // Get the block iteration range: [blockStart, blockEnd)
   Value blockStart = block->getArgument(1);
   Value blockEnd = block->getArgument(2);
 
   // Create a work splitting while loop for the [blockStart, blockEnd) range.
   SmallVector<Type> types = {indexTy, indexTy};
   SmallVector<Value> operands = {blockStart, blockEnd};
+  SmallVector<Location> locations = {loc, loc};
 
   // Create a recursive dispatch loop.
   scf::WhileOp whileOp = b.create<scf::WhileOp>(types, operands);
-  Block *before = b.createBlock(&whileOp.getBefore(), {}, types);
-  Block *after = b.createBlock(&whileOp.getAfter(), {}, types);
+  Block *before = b.createBlock(&whileOp.getBefore(), {}, types, locations);
+  Block *after = b.createBlock(&whileOp.getAfter(), {}, types, locations);
 
   // Setup dispatch loop condition block: decide if we need to go into the
   // `after` block and launch one more async dispatch.
   {
     b.setInsertionPointToEnd(before);
     Value start = before->getArgument(0);
     Value end = before->getArgument(1);
     Value distance = b.create<arith::SubIOp>(end, start);

mlir/lib/Dialect/GPU/IR/GPUDialect.cpp

void LaunchOp::build(OpBuilder &builder, OperationState &result,
   if (dynamicSharedMemorySize)
     result.addOperands(dynamicSharedMemorySize);
 
   // Create a kernel body region with kNumConfigRegionAttributes + N arguments,
   // where the first kNumConfigRegionAttributes arguments have `index` type and
   // the rest have the same types as the data operands.
   Region *kernelRegion = result.addRegion();
   Block *body = new Block();
-  body->addArguments(
-      std::vector<Type>(kNumConfigRegionAttributes, builder.getIndexType()));
+  for (unsigned i = 0; i < kNumConfigRegionAttributes; ++i)
+    body->addArgument(builder.getIndexType(), result.location);
   kernelRegion->push_back(body);
 }
 
 KernelDim3 LaunchOp::getBlockIds() {
   assert(!body().empty() && "LaunchOp body must not be empty.");
   auto args = body().getArguments();
   return KernelDim3{args[0], args[1], args[2]};
 }

 
 static ParseResult
 parseLaunchFuncOperands(OpAsmParser &parser,
                         SmallVectorImpl<OpAsmParser::OperandType> &argNames,
                         SmallVectorImpl<Type> &argTypes) {
   if (parser.parseOptionalKeyword("args"))
     return success();
   SmallVector<NamedAttrList> argAttrs;
-  SmallVector<Optional<Location>> argLocations;
+  SmallVector<Location> argLocations;
   bool isVariadic = false;
   return function_interface_impl::parseFunctionArgumentList(
       parser, /*allowAttributes=*/false,
       /*allowVariadic=*/false, argNames, argTypes, argAttrs, argLocations,
       isVariadic);
 }
 
 static void printLaunchFuncOperands(OpAsmPrinter &printer, Operation *,

 }
 
 //===----------------------------------------------------------------------===//
 // GPUFuncOp
 //===----------------------------------------------------------------------===//
 
 /// Adds a new block argument that corresponds to buffers located in
 /// workgroup memory.
-BlockArgument GPUFuncOp::addWorkgroupAttribution(Type type) {
+BlockArgument GPUFuncOp::addWorkgroupAttribution(Type type, Location loc) {
   auto attrName = getNumWorkgroupAttributionsAttrName();
   auto attr = (*this)->getAttrOfType<IntegerAttr>(attrName);
   (*this)->setAttr(attrName,
                    IntegerAttr::get(attr.getType(), attr.getValue() + 1));
   return getBody().insertArgument(getType().getNumInputs() + attr.getInt(),
-                                  type);
+                                  type, loc);
 }
 
 /// Adds a new block argument that corresponds to buffers located in
 /// private memory.
-BlockArgument GPUFuncOp::addPrivateAttribution(Type type) {
+BlockArgument GPUFuncOp::addPrivateAttribution(Type type, Location loc) {
   // Buffers on the private memory always come after buffers on the workgroup
   // memory.
-  return getBody().addArgument(type);
+  return getBody().addArgument(type, loc);
 }
 
 void GPUFuncOp::build(OpBuilder &builder, OperationState &result,
                       StringRef name, FunctionType type,
                       TypeRange workgroupAttributions,
                       TypeRange privateAttributions,
                       ArrayRef<NamedAttribute> attrs) {
   result.addAttribute(SymbolTable::getSymbolAttrName(),
                       builder.getStringAttr(name));
   result.addAttribute(getTypeAttrName(), TypeAttr::get(type));
   result.addAttribute(getNumWorkgroupAttributionsAttrName(),
                       builder.getI64IntegerAttr(workgroupAttributions.size()));
   result.addAttributes(attrs);
   Region *body = result.addRegion();
   Block *entryBlock = new Block;
-  entryBlock->addArguments(type.getInputs());
-  entryBlock->addArguments(workgroupAttributions);
-  entryBlock->addArguments(privateAttributions);
+
+  // TODO: Allow passing in proper locations here.
+  for (Type type : type.getInputs())
+    entryBlock->addArgument(type, result.location);
+  for (Type type : workgroupAttributions)
+    entryBlock->addArgument(type, result.location);
+  for (Type type : privateAttributions)
+    entryBlock->addArgument(type, result.location);
 
   body->getBlocks().push_back(entryBlock);
 }
 
 /// Parses a GPU function memory attribution.
 ///
 /// memory-attribution ::= (`workgroup` `(` ssa-id-and-type-list `)`)?
 ///                        (`private` `(` ssa-id-and-type-list `)`)?

 ///                 (`->` function-result-list)? memory-attribution `kernel`?
 ///                 function-attributes? region
 static ParseResult parseGPUFuncOp(OpAsmParser &parser, OperationState &result) {
   SmallVector<OpAsmParser::OperandType> entryArgs;
   SmallVector<NamedAttrList> argAttrs;
   SmallVector<NamedAttrList> resultAttrs;
   SmallVector<Type> argTypes;
   SmallVector<Type> resultTypes;
-  SmallVector<Optional<Location>> argLocations;
+  SmallVector<Location> argLocations;
   bool isVariadic;
 
   // Parse the function name.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, ::mlir::SymbolTable::getSymbolAttrName(),
                              result.attributes))
     return failure();
 

mlir/lib/Dialect/GPU/Transforms/AllReduceLowering.cpp

private:
   template <typename T>
   Value getDimOp(gpu::Dimension dimension) {
     Value dim = create<T>(indexType, dimension);
     return create<arith::IndexCastOp>(int32Type, dim);
   }
 
   /// Adds type to funcOp's workgroup attributions.
   Value createWorkgroupBuffer() {
+    // TODO: Pick a proper location for the attribution.
     int workgroupMemoryAddressSpace =
         gpu::GPUDialect::getWorkgroupAddressSpace();
     auto bufferType = MemRefType::get({kSubgroupSize}, valueType, AffineMap{},
                                       workgroupMemoryAddressSpace);
-    return funcOp.addWorkgroupAttribution(bufferType);
+    return funcOp.addWorkgroupAttribution(bufferType, rewriter.getUnknownLoc());
   }
 
   /// Returns an accumulator factory using either the op attribute or the body
   /// region.
   AccumulatorFactory getFactory() {
     auto &body = reduceOp.body();
     if (!body.empty())
       return getFactory(body);
return AccumulatorFactory([&](Value lhs, Value rhs) {
           continue;
         rewriter.setInsertionPointToEnd(block);
         rewriter.replaceOpWithNewOp<BranchOp>(
             terminator, split, ValueRange(terminator->getOperand(0)));
       }
 
       // Return accumulator result.
       rewriter.setInsertionPointToStart(split);
-      return split->addArgument(lhs.getType());
+      return split->addArgument(lhs.getType(), lhs.getLoc());
     });
   }
 
   /// Returns an accumulator factory that creates an op specified by opName.
   AccumulatorFactory getFactory(gpu::AllReduceOperation opName) {
     bool isFloatingPoint = valueType.isa<FloatType>();
     switch (opName) {
     case gpu::AllReduceOperation::ADD:
void createIf(Value condition, ThenOpsFactory &&thenOpsFactory,
 
     rewriter.setInsertionPointToStart(elseBlock);
     auto elseOperands = elseOpsFactory();
     create<BranchOp>(continueBlock, elseOperands);
 
     assert(thenOperands.size() == elseOperands.size());
     rewriter.setInsertionPointToStart(continueBlock);
     for (auto operand : thenOperands)
-      continueBlock->addArgument(operand.getType());
+      continueBlock->addArgument(operand.getType(), operand.getLoc());
   }
 
   /// Shortcut for createIf with empty else block and no block operands.
   template <typename Factory>
   void createPredicatedBlock(Value condition, Factory &&predicatedOpsFactory) {
     static_assert(std::is_same<decltype(predicatedOpsFactory()), void>::value,
                   "predicatedOpsFactory should not return any value");
     createIf(

mlir/lib/Dialect/GPU/Transforms/AsyncRegionRewriter.cpp

TypeSwitch<Operation *>(op)
         })
         .Case<async::ExecuteOp>([&](auto executeOp) {
           // Set `it` to the beginning of the region and add asyncTokens to the
           // async.execute operands.
           it = executeOp.getBody()->begin();
           executeOp.operandsMutable().append(asyncTokens);
           SmallVector<Type, 1> tokenTypes(
               asyncTokens.size(), builder.getType<gpu::AsyncTokenType>());
-          copy(executeOp.getBody()->addArguments(tokenTypes),
+          SmallVector<Location, 1> tokenLocs(asyncTokens.size(),
+                                             executeOp.getLoc());
+          copy(executeOp.getBody()->addArguments(tokenTypes, tokenLocs),
                std::back_inserter(tokens));
         });
 
     // Advance `it` to terminator or op with side-effects.
     it = std::find_if(it, Block::iterator(), [](Operation &op) {
       return isTerminator(&op) || hasSideEffects(&op);
     });
 

mlir/lib/Dialect/GPU/Transforms/MemoryPromotion.cpp

void mlir::promoteToWorkgroupMemory(GPUFuncOp op, unsigned arg) {
   Value value = op.getArgument(arg);
   auto type = value.getType().dyn_cast<MemRefType>();
   assert(type && type.hasStaticShape() && "can only promote memrefs");
 
   // Get the type of the buffer in the workgroup memory.
   int workgroupMemoryAddressSpace = gpu::GPUDialect::getWorkgroupAddressSpace();
   auto bufferType = MemRefType::get(type.getShape(), type.getElementType(), {},
                                     workgroupMemoryAddressSpace);
-
-  Value attribution = op.addWorkgroupAttribution(bufferType);
+  Value attribution = op.addWorkgroupAttribution(bufferType, value.getLoc());
 
   // Replace the uses first since only the original uses are currently present.
   // Then insert the copies.
   value.replaceAllUsesWith(attribution);
   insertCopies(op.getBody(), op.getLoc(), value, attribution);
 }

mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp

 // Add the entry block to the function.
 Block *LLVMFuncOp::addEntryBlock() {
   assert(empty() && "function already has an entry block");
   assert(!isVarArg() && "unimplemented: non-external variadic functions");
 
   auto *entry = new Block;
   push_back(entry);
 
+  // FIXME: Allow passing in proper locations for the entry arguments.
   LLVMFunctionType type = getType();
   for (unsigned i = 0, e = type.getNumParams(); i < e; ++i)
-    entry->addArgument(type.getParamType(i));
+    entry->addArgument(type.getParamType(i), getLoc());
   return entry;
 }
 
 void LLVMFuncOp::build(OpBuilder &builder, OperationState &result,
                        StringRef name, Type type, LLVM::Linkage linkage,
                        bool dsoLocal, ArrayRef<NamedAttribute> attrs,
                        ArrayRef<DictionaryAttr> argAttrs) {
   result.addRegion();
result.addAttribute(
                            parser, result, LLVM::Linkage::External)));
 
   StringAttr nameAttr;
   SmallVector<OpAsmParser::OperandType> entryArgs;
   SmallVector<NamedAttrList> argAttrs;
   SmallVector<NamedAttrList> resultAttrs;
   SmallVector<Type> argTypes;
   SmallVector<Type> resultTypes;
-  SmallVector<Optional<Location>> argLocations;
+  SmallVector<Location> argLocations;
   bool isVariadic;
 
   auto signatureLocation = parser.getCurrentLocation();
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              result.attributes) ||
       function_interface_impl::parseFunctionSignature(
           parser, /*allowVariadic=*/true, entryArgs, argTypes, argAttrs,
           argLocations, isVariadic, resultTypes, resultAttrs))

mlir/lib/Dialect/LLVMIR/Transforms/LegalizeForExport.cpp

static void ensureDistinctSuccessors(Block &bb) {
   // dominated by the original block and can therefore use any values defined in
   // the original block.
   OpBuilder builder(terminator->getContext());
   for (const auto &successor : successorPositions) {
     // Start from the second occurrence of a block in the successor list.
     for (int position : llvm::drop_begin(successor.second, 1)) {
       Block *dummyBlock = builder.createBlock(bb.getParent());
       terminator->setSuccessor(dummyBlock, position);
-      dummyBlock->addArguments(successor.first->getArgumentTypes());
+      for (BlockArgument arg : successor.first->getArguments())
+        dummyBlock->addArgument(arg.getType(), arg.getLoc());
       builder.create<LLVM::BrOp>(terminator->getLoc(),
                                  dummyBlock->getArguments(), successor.first);
     }
   }
 }
 
 void mlir::LLVM::ensureDistinctSuccessors(Operation *op) {
   op->walk([](Operation *nested) {

mlir/lib/Dialect/Linalg/ComprehensiveBufferize/ModuleBufferization.cpp

static LogicalResult bufferizeFuncOpBoundary(FuncOp funcOp,
   // This guarantees the argument order still matches after the rewrite.
   Block &frontBlock = funcOp.body().front();
   unsigned numArgs = frontBlock.getNumArguments();
   for (unsigned idx = 0; idx < numArgs; ++idx) {
     auto bbArg = frontBlock.getArgument(0);
     auto tensorType = bbArg.getType().dyn_cast<TensorType>();
     // Non-tensor types are just forwarded.
     if (!tensorType) {
-      frontBlock.addArgument(bbArg.getType());
+      frontBlock.addArgument(bbArg.getType(), bbArg.getLoc());
       bbArg.replaceAllUsesWith(frontBlock.getArguments().back());
       frontBlock.eraseArgument(0);
       continue;
     }
 
     // Get the buffer type from the bufferized function type.
     Type memrefType = bufferizedFuncType.getInput(idx);
-    Value memref = frontBlock.addArgument(memrefType);
+    Value memref = frontBlock.addArgument(memrefType, bbArg.getLoc());
     OpBuilder b(funcOp->getContext());
     b.setInsertionPointToStart(&frontBlock);
     // Replace all uses of bbArg through a ToMemRefOp by a memref::CastOp.
     for (auto &use : llvm::make_early_inc_range(bbArg.getUses())) {
       if (auto toMemrefOp =
               dyn_cast<bufferization::ToMemrefOp>(use.getOwner())) {
         assert(memref::CastOp::areCastCompatible(
                    memref.getType(), toMemrefOp.memref().getType()) &&

mlir/lib/Dialect/Linalg/IR/LinalgOps.cpp

static LogicalResult foldMemRefCastInTiledLoopOp(TiledLoopOp op) {
   for (size_t operandIndex = op.getNumControlOperands(),
               bbArgIndex = op.getNumLoops(), e = op.getNumOperands();
        operandIndex < e; ++operandIndex, ++bbArgIndex) {
     OpOperand &operand = op->getOpOperand(operandIndex);
 
     auto castOp = operand.get().getDefiningOp<memref::CastOp>();
     if (castOp && memref::CastOp::canFoldIntoConsumerOp(castOp)) {
       operand.set(castOp.getOperand());
-      BlockArgument newBbArg =
-          body->insertArgument(bbArgIndex, castOp.getOperand().getType());
+      BlockArgument newBbArg = body->insertArgument(
+          bbArgIndex, castOp.getOperand().getType(), op.getLoc());
       BlockArgument oldBbArg = body->getArgument(newBbArg.getArgNumber() + 1);
 
       // Insert memref.cast back to the original type.
       oldBbArg.replaceAllUsesWith(
           b.create<memref::CastOp>(loc, oldBbArg.getType(), newBbArg));
       body->eraseArgument(oldBbArg.getArgNumber());
 
       folded = true;
build(builder, result, resultTensorTypes, inputs, outputs,
         doc.empty() ? StringAttr() : builder.getStringAttr(doc),
         libraryCall.empty() ? StringAttr()
                             : builder.getStringAttr(libraryCall));
   result.addAttributes(attributes);
   if (!bodyBuild)
     return;
 
   SmallVector<Type, 4> blockArgTypes;
-  for (ValueRange container : {inputs, outputs})
-    for (Value v : container)
+  SmallVector<Location, 4> blockArgLocs;
+  for (ValueRange container : {inputs, outputs}) {
+    for (Value v : container) {
       blockArgTypes.push_back(getElementTypeOrSelf(v));
+      blockArgLocs.push_back(v.getLoc());
+    }
+  }
 
   OpBuilder::InsertionGuard guard(builder);
   auto &region = *result.regions.front();
-  Block *bodyBlock = builder.createBlock(&region, region.end(), blockArgTypes);
+  Block *bodyBlock =
+      builder.createBlock(&region, region.end(), blockArgTypes, blockArgLocs);
   bodyBuild(builder, result.location, bodyBlock->getArguments());
 }
 
 void GenericOp::build(
     OpBuilder &builder, OperationState &result, ValueRange inputs,
     ValueRange outputs, ArrayRef<AffineMap> indexingMaps,
     ArrayRef<StringRef> iteratorTypes, StringRef doc, StringRef libraryCall,
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuild,

 PadTensorOp PadTensorOp::createPadScalarOp(Type type, Value source, Value pad,
                                            ArrayRef<OpFoldResult> low,
                                            ArrayRef<OpFoldResult> high,
                                            bool nofold, Location loc,
                                            OpBuilder &builder) {
   auto padTensorOp =
       builder.create<linalg::PadTensorOp>(loc, type, source, low, high, nofold);
   int rank = padTensorOp.getResultType().getRank();
-  SmallVector<Type, 4> blockArgTypes;
-  blockArgTypes.assign(rank, builder.getIndexType());
+  SmallVector<Type, 4> blockArgTypes(rank, builder.getIndexType());
+  SmallVector<Location, 4> blockArgLocs(rank, loc);
   auto &region = padTensorOp.region();
   // `builder.createBlock` changes the insertion point within the block. Create
   // a guard to reset the insertion point of the builder after it is destroyed.
   OpBuilder::InsertionGuard guard(builder);
-  builder.createBlock(&region, region.end(), blockArgTypes);
+  builder.createBlock(&region, region.end(), blockArgTypes, blockArgLocs);
   builder.create<linalg::YieldOp>(loc, pad);
   return padTensorOp;
 }
 
 PadTensorOp PadTensorOp::createPadHighOp(Type type, Value source, Value pad,
                                          bool nofold, Location loc,
                                          OpBuilder &b) {
   SmallVector<OpFoldResult, 4> low, high;
for (Value output : outputs) {
     Type outputType = output.getType();
     if (outputType.isa<RankedTensorType>())
       result.addTypes(outputType);
   }
 
   OpBuilder::InsertionGuard guard(builder);
   unsigned numIVs = steps.size();
   SmallVector<Type, 8> argTypes(numIVs, builder.getIndexType());
-  for (Type type : TypeRange(inputs))
-    argTypes.push_back(type);
-  for (Type type : TypeRange(outputs))
-    argTypes.push_back(type);
+  SmallVector<Location, 8> argLocs(numIVs, result.location);
+  for (Value input : inputs) {
+    argTypes.push_back(input.getType());
+    argLocs.push_back(input.getLoc());
+  }
+  for (Value output : outputs) {
+    argTypes.push_back(output.getType());
+    argLocs.push_back(output.getLoc());
+  }
   Region *bodyRegion = result.addRegion();
-  Block *bodyBlock = builder.createBlock(bodyRegion, {}, argTypes);
+  Block *bodyBlock = builder.createBlock(bodyRegion, {}, argTypes, argLocs);
 
   if (bodyBuilderFn) {
     builder.setInsertionPointToStart(bodyBlock);
     bodyBuilderFn(builder, result.location,
                   bodyBlock->getArguments().take_front(numIVs),
                   bodyBlock->getArguments().slice(numIVs, inputs.size()),
                   bodyBlock->getArguments().take_back(outputs.size()));
     TiledLoopOp::ensureTerminator(*bodyRegion, builder, result.location);
static void fillStructuredOpRegion(
     OpBuilder &opBuilder, Region &region, TypeRange inputTypes,
     TypeRange outputTypes,
     llvm::function_ref<void(unsigned, unsigned)> errorHandler) {
   assert(llvm::all_of(outputTypes, [](Type t) { return t.isa<ShapedType>(); }));
 
   // TODO: atm all operands go through getElementTypeOrSelf,
   // reconsider when we have evidence we need to.
   SmallVector<Type, 8> argTypes;
-  for (auto containers : {inputTypes, outputTypes})
-    for (auto t : containers)
+  SmallVector<Location, 8> argLocs;
+  for (auto containers : {inputTypes, outputTypes}) {
+    for (auto t : containers) {
       argTypes.push_back(getElementTypeOrSelf(t));
 
+      // TODO: Pass in a proper location here.
+      argLocs.push_back(opBuilder.getUnknownLoc());
+    }
+  }
+
   // RAII.
   OpBuilder::InsertionGuard guard(opBuilder);
-  Block *body = opBuilder.createBlock(&region, /*insertPt=*/{}, argTypes);
+  Block *body =
+      opBuilder.createBlock(&region, /*insertPt=*/{}, argTypes, argLocs);
   unsigned actual = body->getNumArguments();
   unsigned expected = NamedStructuredOpType::getNumRegionArgs();
   if (expected != actual) {
     if (errorHandler)
       errorHandler(expected, actual);
     return;
   }
 

mlir/lib/Dialect/Linalg/Transforms/ElementwiseOpFusion.cpp

if (producer.hasIndexSemantics()) {
     }
   }
   // TODO: allow fusing the producer of an output operand.
   assert(consumer.isInputTensor(consumerOpOperand) &&
          "expected producer of input operand");
   // 3. Consumer input operands up to consumerIdx (exclusive).
   for (BlockArgument bbArg : consumerBlock.getArguments().take_front(
            consumerOpOperand->getOperandNumber())) // input assumption.
-    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
+    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // Replacing consumerIdx requires getting the cloned, yielded, value from
   // the (cloned) producer block. This happens in step 9.
 
   // 4. Splice in producer's input operands.
   for (BlockArgument bbArg :
        producerBlock.getArguments().take_front(producer.getNumInputs()))
-    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
+    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
 
   // 4.b. Producer output operand/map that is fused needs to be mapped to the
   // producer bbArg if it is an "initTensor" (i.e. its value is actually read).
   assert(producer->getNumResults() == 1 && "expected single result producer");
   if (producer.isInitTensor(producer.getOutputOperand(0))) {
     BlockArgument bbArg = producerBlock.getArguments()
                               .drop_front(producer.getNumInputs())
                               // TODO: bbArg index of
                               .front();
-    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
+    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
   }
   // 5. Remaining consumer's input operands (drop past index `consumerIdx`).
   for (BlockArgument bbArg :
        consumerBlock.getArguments()
            .take_front(consumer.getNumInputs())
            .drop_front(consumerOpOperand->getOperandNumber() + 1))
-    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
+    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
   // 6. All of consumer's output operands.
   for (BlockArgument bbArg :
        consumerBlock.getArguments().take_back(consumer.getNumOutputs()))
-    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType()));
+    mapper.map(bbArg, fusedBlock->addArgument(bbArg.getType(), bbArg.getLoc()));
   // 7. All of producer's output operands except the one fused.
   // TODO: allow fusion of multi-result producers.
   assert(producer->getNumResults() == 1 && "expected single result producer");
 
   // 8. Clone all producer operations except for the yield and index operations
   // to the fused operation.
   for (auto &op : producerBlock.without_terminator()) {
     if (!isa<IndexOp>(op))

mlir/lib/Dialect/OpenMP/IR/OpenMPDialect.cpp

result.addAttribute(
            static_cast<int32_t>(reductionVars.size()),
            static_cast<int32_t>(scheduleChunkVar != nullptr ? 1 : 0)}));
 
   Region *bodyRegion = result.addRegion();
   if (buildBody) {
     OpBuilder::InsertionGuard guard(builder);
     unsigned numIVs = steps.size();
     SmallVector<Type, 8> argTypes(numIVs, steps.getType().front());
-    builder.createBlock(bodyRegion, {}, argTypes);
+    SmallVector<Location, 8> argLocs(numIVs, result.location);
+    builder.createBlock(bodyRegion, {}, argTypes, argLocs);
   }
 }
 
 static LogicalResult verifyWsLoopOp(WsLoopOp op) {
   return verifyReductionVarList(op, op.reductions(), op.reduction_vars());
 }
 
 //===----------------------------------------------------------------------===//

mlir/lib/Dialect/PDLInterp/IR/PDLInterp.cpp

 // pdl_interp::ForEachOp
 //===----------------------------------------------------------------------===//
 
 void ForEachOp::build(::mlir::OpBuilder &builder, ::mlir::OperationState &state,
                       Value range, Block *successor, bool initLoop) {
   build(builder, state, range, successor);
   if (initLoop) {
     // Create the block and the loop variable.
+    // FIXME: Allow passing in a proper location for the loop variable.
     auto rangeType = range.getType().cast<pdl::RangeType>();
     state.regions.front()->emplaceBlock();
-    state.regions.front()->addArgument(rangeType.getElementType());
+    state.regions.front()->addArgument(rangeType.getElementType(),
+                                       state.location);
   }
 }
 
 static ParseResult parseForEachOp(OpAsmParser &parser, OperationState &result) {
   // Parse the loop variable followed by type.
   OpAsmParser::OperandType loopVariable;
   Type loopVariableType;
   if (parser.parseRegionArgument(loopVariable) ||

mlir/lib/Dialect/SCF/SCF.cpp

for (Block &blk : op.getRegion()) {
         rewriter.eraseOp(yieldOp);
       }
     }
 
     rewriter.inlineRegionBefore(op.getRegion(), postBlock);
     SmallVector<Value> blockArgs;
 
     for (auto res : op.getResults())
-      blockArgs.push_back(postBlock->addArgument(res.getType()));
+      blockArgs.push_back(postBlock->addArgument(res.getType(), res.getLoc()));
 
     rewriter.replaceOp(op, blockArgs);
     return success();
   }
 };
 
 void ExecuteRegionOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                   MLIRContext *context) {
void ForOp::build(OpBuilder &builder, OperationState &result, Value lb,
                   BodyBuilderFn bodyBuilder) {
   result.addOperands({lb, ub, step});
   result.addOperands(iterArgs);
   for (Value v : iterArgs)
     result.addTypes(v.getType());
   Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block);
   Block &bodyBlock = bodyRegion->front();
-  bodyBlock.addArgument(builder.getIndexType());
+  bodyBlock.addArgument(builder.getIndexType(), result.location);
   for (Value v : iterArgs)
-    bodyBlock.addArgument(v.getType());
+    bodyBlock.addArgument(v.getType(), v.getLoc());
 
   // Create the default terminator if the builder is not provided and if the
   // iteration arguments are not provided. Otherwise, leave this to the caller
   // because we don't know which values to return from the loop.
   if (iterArgs.empty() && !bodyBuilder) {
     ForOp::ensureTerminator(*bodyRegion, builder, result.location);
   } else if (bodyBuilder) {
     OpBuilder::InsertionGuard guard(builder);
result.addAttribute(
                                 static_cast<int32_t>(upperBounds.size()),
                                 static_cast<int32_t>(steps.size()),
                                 static_cast<int32_t>(initVals.size())}));
   result.addTypes(initVals.getTypes());
 
   OpBuilder::InsertionGuard guard(builder);
   unsigned numIVs = steps.size();
   SmallVector<Type, 8> argTypes(numIVs, builder.getIndexType());
+  SmallVector<Location, 8> argLocs(numIVs, result.location);
   Region *bodyRegion = result.addRegion();
-  Block *bodyBlock = builder.createBlock(bodyRegion, {}, argTypes);
+  Block *bodyBlock = builder.createBlock(bodyRegion, {}, argTypes, argLocs);
 
   if (bodyBuilderFn) {
     builder.setInsertionPointToStart(bodyBlock);
     bodyBuilderFn(builder, result.location,
                   bodyBlock->getArguments().take_front(numIVs),
                   bodyBlock->getArguments().drop_front(numIVs));
   }
   ParallelOp::ensureTerminator(*bodyRegion, builder, result.location);

 void ReduceOp::build(
     OpBuilder &builder, OperationState &result, Value operand,
     function_ref<void(OpBuilder &, Location, Value, Value)> bodyBuilderFn) {
   auto type = operand.getType();
   result.addOperands(operand);
 
   OpBuilder::InsertionGuard guard(builder);
   Region *bodyRegion = result.addRegion();
-  Block *body = builder.createBlock(bodyRegion, {}, ArrayRef<Type>{type, type});
+  Block *body = builder.createBlock(bodyRegion, {}, ArrayRef<Type>{type, type},
+                                    {result.location, result.location});
   if (bodyBuilderFn)
     bodyBuilderFn(builder, result.location, body->getArgument(0),
                   body->getArgument(1));
 }
 
 static LogicalResult verify(ReduceOp op) {
   // The region of a ReduceOp has two arguments of the same type as its operand.
   auto type = op.getOperand().getType();
LogicalResult matchAndRewrite(WhileOp op,
     auto term = op.getConditionOp();
     auto afterArgs = op.getAfterArguments();
     auto termArgs = term.getArgs();
 
     // Collect results mapping, new terminator args and new result types.
     SmallVector<unsigned> newResultsIndices;
     SmallVector<Type> newResultTypes;
     SmallVector<Value> newTermArgs;
+    SmallVector<Location> newArgLocs;
     bool needUpdate = false;
     for (const auto &it :
          llvm::enumerate(llvm::zip(op.getResults(), afterArgs, termArgs))) {
       auto i = static_cast<unsigned>(it.index());
       Value result = std::get<0>(it.value());
       Value afterArg = std::get<1>(it.value());
       Value termArg = std::get<2>(it.value());
       if (result.use_empty() && afterArg.use_empty()) {
         needUpdate = true;
       } else {
         newResultsIndices.emplace_back(i);
         newTermArgs.emplace_back(termArg);
         newResultTypes.emplace_back(result.getType());
+        newArgLocs.emplace_back(result.getLoc());
       }
     }
 
     if (!needUpdate)
       return failure();
 
     {
       OpBuilder::InsertionGuard g(rewriter);
       rewriter.setInsertionPoint(term);
       rewriter.replaceOpWithNewOp<ConditionOp>(term, term.getCondition(),
                                                newTermArgs);
     }
 
     auto newWhile =
         rewriter.create<WhileOp>(op.getLoc(), newResultTypes, op.getInits());
 
     Block &newAfterBlock = *rewriter.createBlock(
-        &newWhile.getAfter(), /*insertPt*/ {}, newResultTypes);
+        &newWhile.getAfter(), /*insertPt*/ {}, newResultTypes, newArgLocs);
 
     // Build new results list and new after block args (unused entries will be
     // null).
     SmallVector<Value> newResults(op.getNumResults());
     SmallVector<Value> newAfterBlockArgs(op.getNumResults());
     for (const auto &it : llvm::enumerate(newResultsIndices)) {
       newResults[it.value()] = newWhile.getResult(it.index());
       newAfterBlockArgs[it.value()] = newAfterBlock.getArgument(it.index());

mlir/lib/Dialect/SCF/Transforms/ForToWhile.cpp

 
 struct ForLoopLoweringPattern : public OpRewritePattern<ForOp> {
   using OpRewritePattern<ForOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(ForOp forOp,
                                 PatternRewriter &rewriter) const override {
     // Generate type signature for the loop-carried values. The induction
     // variable is placed first, followed by the forOp.iterArgs.
-    SmallVector<Type, 8> lcvTypes;
+    SmallVector<Type> lcvTypes;
+    SmallVector<Location> lcvLocs;
     lcvTypes.push_back(forOp.getInductionVar().getType());
-    llvm::transform(forOp.getInitArgs(), std::back_inserter(lcvTypes),
-                    [&](auto v) { return v.getType(); });
+    lcvLocs.push_back(forOp.getInductionVar().getLoc());
+    for (Value value : forOp.getInitArgs()) {
+      lcvTypes.push_back(value.getType());
+      lcvLocs.push_back(value.getLoc());
+    }
 
     // Build scf.WhileOp
     SmallVector<Value> initArgs;
     initArgs.push_back(forOp.getLowerBound());
     llvm::append_range(initArgs, forOp.getInitArgs());
     auto whileOp = rewriter.create<WhileOp>(forOp.getLoc(), lcvTypes, initArgs,
                                             forOp->getAttrs());
 
     // 'before' region contains the loop condition and forwarding of iteration
     // arguments to the 'after' region.
     auto *beforeBlock = rewriter.createBlock(
-        &whileOp.getBefore(), whileOp.getBefore().begin(), lcvTypes, {});
+        &whileOp.getBefore(), whileOp.getBefore().begin(), lcvTypes, lcvLocs);
     rewriter.setInsertionPointToStart(&whileOp.getBefore().front());
     auto cmpOp = rewriter.create<arith::CmpIOp>(
         whileOp.getLoc(), arith::CmpIPredicate::slt,
         beforeBlock->getArgument(0), forOp.getUpperBound());
     rewriter.create<scf::ConditionOp>(whileOp.getLoc(), cmpOp.getResult(),
                                       beforeBlock->getArguments());
 
     // Inline for-loop body into an executeRegion operation in the "after"
     // region. The return type of the execRegionOp does not contain the
     // iv - yields in the source for-loop contain only iterArgs.
     auto *afterBlock = rewriter.createBlock(
-        &whileOp.getAfter(), whileOp.getAfter().begin(), lcvTypes, {});
+        &whileOp.getAfter(), whileOp.getAfter().begin(), lcvTypes, lcvLocs);
 
     // Add induction variable incrementation
     rewriter.setInsertionPointToEnd(afterBlock);
     auto ivIncOp = rewriter.create<arith::AddIOp>(
         whileOp.getLoc(), afterBlock->getArgument(0), forOp.getStep());
 
     // Rewrite uses of the for-loop block arguments to the new while-loop
     // "after" arguments

mlir/lib/Dialect/SCF/Transforms/Utils.cpp

FailureOr<FuncOp> mlir::outlineSingleBlockRegion(RewriterBase &rewriter,
   OpBuilder::InsertionGuard g(rewriter);
   rewriter.setInsertionPoint(region.getParentOfType<FuncOp>());
 
   SetVector<Value> captures;
   getUsedValuesDefinedAbove(region, captures);
 
   ValueRange outlinedValues(captures.getArrayRef());
   SmallVector<Type> outlinedFuncArgTypes;
+  SmallVector<Location> outlinedFuncArgLocs;
   // Region's arguments are exactly the first block's arguments as per
   // Region::getArguments().
   // Func's arguments are cat(regions's arguments, captures arguments).
-  llvm::append_range(outlinedFuncArgTypes, region.getArgumentTypes());
-  llvm::append_range(outlinedFuncArgTypes, outlinedValues.getTypes());
+  for (BlockArgument arg : region.getArguments()) {
+    outlinedFuncArgTypes.push_back(arg.getType());
+    outlinedFuncArgLocs.push_back(arg.getLoc());
+  }
+  for (Value value : outlinedValues) {
+    outlinedFuncArgTypes.push_back(value.getType());
+    outlinedFuncArgLocs.push_back(value.getLoc());
+  }
   FunctionType outlinedFuncType =
       FunctionType::get(rewriter.getContext(), outlinedFuncArgTypes,
                         originalTerminator->getOperandTypes());
   auto outlinedFunc = rewriter.create<FuncOp>(loc, funcName, outlinedFuncType);
   Block *outlinedFuncBody = outlinedFunc.addEntryBlock();
 
   // Merge blocks while replacing the original block operands.
   // Warning: `mergeBlocks` erases the original block, reconstruct it later.
auto outlinedFuncBlockArgs = outlinedFuncBody->getArguments();
     rewriter.create<ReturnOp>(loc, originalTerminator->getResultTypes(),
                               originalTerminator->getOperands());
   }
 
   // Reconstruct the block that was deleted and add a
   // terminator(call_results).
   Block *newBlock = rewriter.createBlock(
       &region, region.begin(),
-      TypeRange{outlinedFuncArgTypes}.take_front(numOriginalBlockArguments));
+      TypeRange{outlinedFuncArgTypes}.take_front(numOriginalBlockArguments),
+      ArrayRef<Location>(outlinedFuncArgLocs)
+          .take_front(numOriginalBlockArguments));
   {
     OpBuilder::InsertionGuard g(rewriter);
     rewriter.setInsertionPointToEnd(newBlock);
     SmallVector<Value> callValues;
     llvm::append_range(callValues, newBlock->getArguments());
     llvm::append_range(callValues, outlinedValues);
     Operation *call = rewriter.create<CallOp>(loc, outlinedFunc, callValues);
 

mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp

 //===----------------------------------------------------------------------===//
 
 static ParseResult parseFuncOp(OpAsmParser &parser, OperationState &state) {
   SmallVector<OpAsmParser::OperandType> entryArgs;
   SmallVector<NamedAttrList> argAttrs;
   SmallVector<NamedAttrList> resultAttrs;
   SmallVector<Type> argTypes;
   SmallVector<Type> resultTypes;
-  SmallVector<Optional<Location>> argLocations;
+  SmallVector<Location> argLocations;
   auto &builder = parser.getBuilder();
 
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
                              state.attributes))
     return failure();
 

mlir/lib/Dialect/Shape/IR/Shape.cpp

 void ReduceOp::build(OpBuilder &builder, OperationState &result, Value shape,
                      ValueRange initVals) {
   result.addOperands(shape);
   result.addOperands(initVals);
 
   Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block);
   Block &bodyBlock = bodyRegion->front();
-  bodyBlock.addArgument(builder.getIndexType());
+  bodyBlock.addArgument(builder.getIndexType(), result.location);
 
   Type elementType;
   if (auto tensorType = shape.getType().dyn_cast<TensorType>())
     elementType = tensorType.getElementType();
   else
     elementType = SizeType::get(builder.getContext());
-  bodyBlock.addArgument(elementType);
+  bodyBlock.addArgument(elementType, shape.getLoc());
 
-  for (Type initValType : initVals.getTypes()) {
-    bodyBlock.addArgument(initValType);
-    result.addTypes(initValType);
+  for (Value initVal : initVals) {
+    bodyBlock.addArgument(initVal.getType(), initVal.getLoc());
+    result.addTypes(initVal.getType());
   }
 }
 
 static LogicalResult verify(ReduceOp op) {
   // Verify block arg types.
   Block &block = op.getRegion().front();
 
   // The block takes index, extent, and aggregated values as arguments.

mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp

static Operation *genWhile(Merger &merger, CodeGen &codegen,
   }
   if (needsUniv) {
     types.push_back(indexType);
     operands.push_back(codegen.loops[idx]);
   }
   assert(types.size() == operands.size());
   Location loc = op.getLoc();
   scf::WhileOp whileOp = rewriter.create<scf::WhileOp>(loc, types, operands);
-  Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, types);
-  Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, types);
+
+  SmallVector<Location> locs(types.size(), loc);
+  Block *before = rewriter.createBlock(&whileOp.getBefore(), {}, types, locs);
+  Block *after = rewriter.createBlock(&whileOp.getAfter(), {}, types, locs);
 
   // Build the "before" region, which effectively consists
   // of a conjunction of "i < upper" tests on all induction.
   rewriter.setInsertionPointToStart(&whileOp.getBefore().front());
   Value cond;
   unsigned o = 0;
   for (unsigned b = 0, be = indices.size(); b < be; b++) {
     if (indices[b] && merger.isDim(b, Dim::kSparse)) {

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

void GenericAtomicRMWOp::build(OpBuilder &builder, OperationState &result,
   result.addOperands(ivs);
 
   if (auto memrefType = memref.getType().dyn_cast<MemRefType>()) {
     Type elementType = memrefType.getElementType();
     result.addTypes(elementType);
 
     Region *bodyRegion = result.addRegion();
     bodyRegion->push_back(new Block());
-    bodyRegion->addArgument(elementType);
+    bodyRegion->addArgument(elementType, memref.getLoc());
   }
 }
 
 static LogicalResult verify(GenericAtomicRMWOp op) {
   auto &body = op.getRegion();
   if (body.getNumArguments() != 1)
     return op.emitOpError("expected single number of entry block arguments");
 

mlir/lib/Dialect/Tensor/IR/TensorOps.cpp

void GenerateOp::build(
     function_ref<void(OpBuilder &, Location, ValueRange)> bodyBuilder) {
   build(b, result, resultTy, dynamicExtents);
 
   // Build and populate body.
   OpBuilder::InsertionGuard guard(b);
   Region *bodyRegion = result.regions.front().get();
   auto rank = resultTy.cast<RankedTensorType>().getRank();
   SmallVector<Type, 2> argumentTypes(rank, b.getIndexType());
+  SmallVector<Location, 2> argumentLocs(rank, result.location);
   Block *bodyBlock =
-      b.createBlock(bodyRegion, bodyRegion->end(), argumentTypes);
+      b.createBlock(bodyRegion, bodyRegion->end(), argumentTypes, argumentLocs);
   bodyBuilder(b, result.location, bodyBlock->getArguments());
 }
 
 namespace {
 
 /// Canonicalizes tensor.generate operations with a constant
 /// operand into the equivalent operation with the operand expressed in the
 /// result type, instead. We also insert a type cast to make sure that the

mlir/lib/IR/Block.cpp

 // Argument list management.
 //===----------------------------------------------------------------------===//
 
 /// Return a range containing the types of the arguments for this block.
 auto Block::getArgumentTypes() -> ValueTypeRange<BlockArgListType> {
   return ValueTypeRange<BlockArgListType>(getArguments());
 }
 
-BlockArgument Block::addArgument(Type type, Optional<Location> loc) {
-  // TODO: Require locations for BlockArguments.
-  if (!loc.hasValue()) {
-    // Use the location of the parent operation if the block is attached.
-    if (Operation *parentOp = getParentOp())
-      loc = parentOp->getLoc();
-    else
-      loc = UnknownLoc::get(type.getContext());
-  }
-
-  BlockArgument arg = BlockArgument::create(type, this, arguments.size(), *loc);
+BlockArgument Block::addArgument(Type type, Location loc) {
+  BlockArgument arg = BlockArgument::create(type, this, arguments.size(), loc);
   arguments.push_back(arg);
   return arg;
 }
 
 /// Add one argument to the argument list for each type specified in the list.
 auto Block::addArguments(TypeRange types, ArrayRef<Location> locs)
     -> iterator_range<args_iterator> {
-  // TODO: Require locations for BlockArguments.
-  assert((locs.empty() || types.size() == locs.size()) &&
+  assert(types.size() == locs.size() &&
          "incorrect number of block argument locations");
   size_t initialSize = arguments.size();
-
   arguments.reserve(initialSize + types.size());
 
-  // TODO: Require locations for BlockArguments.
-  if (locs.empty()) {
-    for (auto type : types)
-      addArgument(type);
-  } else {
-    for (auto typeAndLoc : llvm::zip(types, locs))
-      addArgument(std::get<0>(typeAndLoc), std::get<1>(typeAndLoc));
-  }
   return {arguments.data() + initialSize, arguments.data() + arguments.size()};
 }
 
-BlockArgument Block::insertArgument(unsigned index, Type type,
-                                    Optional<Location> loc) {
-  // TODO: Require locations for BlockArguments.
-  if (!loc.hasValue()) {
-    // Use the location of the parent operation if the block is attached.
-    if (Operation *parentOp = getParentOp())
-      loc = parentOp->getLoc();
-    else
-      loc = UnknownLoc::get(type.getContext());
-  }
+BlockArgument Block::insertArgument(unsigned index, Type type, Location loc) {
+  assert(index <= arguments.size() && "invalid insertion index");
 
-  auto arg = BlockArgument::create(type, this, index, *loc);
-  assert(index <= arguments.size());
+  auto arg = BlockArgument::create(type, this, index, loc);
   arguments.insert(arguments.begin() + index, arg);
   // Update the cached position for all the arguments after the newly inserted
   // one.
   ++index;
   for (BlockArgument arg : llvm::drop_begin(arguments, index))
     arg.setArgNumber(index++);
   return arg;
 }
 
 /// Insert one value to the given position of the argument list. The existing
 /// arguments are shifted. The block is expected not to have predecessors.
-BlockArgument Block::insertArgument(args_iterator it, Type type,
-                                    Optional<Location> loc) {
+BlockArgument Block::insertArgument(args_iterator it, Type type, Location loc) {
   assert(llvm::empty(getPredecessors()) &&
          "cannot insert arguments to blocks with predecessors");
   return insertArgument(it->getArgNumber(), type, loc);
 }
 
 void Block::eraseArgument(unsigned index) {
   assert(index < arguments.size());
   arguments[index].destroy();

mlir/lib/IR/Builders.cpp

Operation *OpBuilder::insert(Operation *op) {
   if (block)
     block->getOperations().insert(insertPoint, op);
 
   if (listener)
     listener->notifyOperationInserted(op);
   return op;
 }
 
-/// Add new block with 'argTypes' arguments and set the insertion point to the
-/// end of it. The block is inserted at the provided insertion point of
-/// 'parent'.
 Block *OpBuilder::createBlock(Region *parent, Region::iterator insertPt,
                               TypeRange argTypes, ArrayRef<Location> locs) {
   assert(parent && "expected valid parent region");
+  assert(argTypes.size() == locs.size() && "argument location mismatch");
   if (insertPt == Region::iterator())
     insertPt = parent->end();
 
   Block *b = new Block();
   b->addArguments(argTypes, locs);
   parent->getBlocks().insert(insertPt, b);
   setInsertionPointToEnd(b);
 

mlir/lib/IR/FunctionImplementation.cpp

 #include "mlir/IR/SymbolTable.h"
 
 using namespace mlir;
 
 ParseResult mlir::function_interface_impl::parseFunctionArgumentList(
     OpAsmParser &parser, bool allowAttributes, bool allowVariadic,
     SmallVectorImpl<OpAsmParser::OperandType> &argNames,
     SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
-    SmallVectorImpl<Optional<Location>> &argLocations, bool &isVariadic) {
+    SmallVectorImpl<Location> &argLocations, bool &isVariadic) {
   if (parser.parseLParen())
     return failure();
 
   // The argument list either has to consistently have ssa-id's followed by
   // types, or just be a type list.  It isn't ok to sometimes have SSA ID's and
   // sometimes not.
   auto parseArgument = [&]() -> ParseResult {
     llvm::SMLoc loc = parser.getCurrentLocation();
if (!allowAttributes && !attrs.empty())
       return parser.emitError(loc, "expected arguments without attributes");
     argAttrs.push_back(attrs);
 
     // Parse a location if specified.
     Optional<Location> explicitLoc;
     if (!argument.name.empty() &&
         parser.parseOptionalLocationSpecifier(explicitLoc))
       return failure();
-    argLocations.push_back(explicitLoc);
+    if (!explicitLoc)
+      explicitLoc = parser.getEncodedSourceLoc(loc);
+    argLocations.push_back(*explicitLoc);
 
     return success();
   };
 
   // Parse the function arguments.
   isVariadic = false;
   if (failed(parser.parseOptionalRParen())) {
     do {
parseFunctionResultList(OpAsmParser &parser, SmallVectorImpl<Type> &resultTypes,
   } while (succeeded(parser.parseOptionalComma()));
   return parser.parseRParen();
 }
 
 ParseResult mlir::function_interface_impl::parseFunctionSignature(
     OpAsmParser &parser, bool allowVariadic,
     SmallVectorImpl<OpAsmParser::OperandType> &argNames,
     SmallVectorImpl<Type> &argTypes, SmallVectorImpl<NamedAttrList> &argAttrs,
-    SmallVectorImpl<Optional<Location>> &argLocations, bool &isVariadic,
+    SmallVectorImpl<Location> &argLocations, bool &isVariadic,
     SmallVectorImpl<Type> &resultTypes,
     SmallVectorImpl<NamedAttrList> &resultAttrs) {
   bool allowArgAttrs = true;
   if (parseFunctionArgumentList(parser, allowArgAttrs, allowVariadic, argNames,
                                 argTypes, argAttrs, argLocations, isVariadic))
     return failure();
   if (succeeded(parser.parseOptionalArrow()))
     return parseFunctionResultList(parser, resultTypes, resultAttrs);

 ParseResult mlir::function_interface_impl::parseFunctionOp(
     OpAsmParser &parser, OperationState &result, bool allowVariadic,
     FuncTypeBuilder funcTypeBuilder) {
   SmallVector<OpAsmParser::OperandType> entryArgs;
   SmallVector<NamedAttrList> argAttrs;
   SmallVector<NamedAttrList> resultAttrs;
   SmallVector<Type> argTypes;
   SmallVector<Type> resultTypes;
-  SmallVector<Optional<Location>> argLocations;
+  SmallVector<Location> argLocations;
   auto &builder = parser.getBuilder();
 
   // Parse visibility.
   impl::parseOptionalVisibilityKeyword(parser, result.attributes);
 
   // Parse the name as a symbol.
   StringAttr nameAttr;
   if (parser.parseSymbolName(nameAttr, SymbolTable::getSymbolAttrName(),
ParseResult mlir::function_interface_impl::parseFunctionOp(
   addArgAndResultAttrs(builder, result, argAttrs, resultAttrs);
 
   // Parse the optional function body. The printer will not print the body if
   // its empty, so disallow parsing of empty body in the parser.
   auto *body = result.addRegion();
   llvm::SMLoc loc = parser.getCurrentLocation();
   OptionalParseResult parseResult = parser.parseOptionalRegion(
       *body, entryArgs, entryArgs.empty() ? ArrayRef<Type>() : argTypes,
-      entryArgs.empty() ? ArrayRef<Optional<Location>>() : argLocations,
+      entryArgs.empty() ? ArrayRef<Location>() : argLocations,
       /*enableNameShadowing=*/false);
   if (parseResult.hasValue()) {
     if (failed(*parseResult))
       return failure();
     // Function body was parsed, make sure its not empty.
     if (body->empty())
       return parser.emitError(loc, "expected non-empty function body");
   }

mlir/lib/IR/FunctionInterfaces.cpp

auto wrappedAttrs = llvm::map_range(attrs, [op](Attribute attr) -> Attribute {
     return !attr ? DictionaryAttr::get(op->getContext()) : attr;
   });
   setAllArgResAttrDicts(op, getResultDictAttrName(),
                         llvm::to_vector<8>(wrappedAttrs));
 }
 
 void mlir::function_interface_impl::insertFunctionArguments(
     Operation *op, ArrayRef<unsigned> argIndices, TypeRange argTypes,
-    ArrayRef<DictionaryAttr> argAttrs, ArrayRef<Optional<Location>> argLocs,
+    ArrayRef<DictionaryAttr> argAttrs, ArrayRef<Location> argLocs,
     unsigned originalNumArgs, Type newType) {
   assert(argIndices.size() == argTypes.size());
   assert(argIndices.size() == argAttrs.size() || argAttrs.empty());
-  assert(argIndices.size() == argLocs.size() || argLocs.empty());
+  assert(argIndices.size() == argLocs.size());
   if (argIndices.empty())
     return;
 
   // There are 3 things that need to be updated:
   // - Function type.
   // - Arg attrs.
   // - Block arguments of entry block.
   Block &entry = op->getRegion(0).front();
if (oldArgAttrs || !argAttrs.empty()) {
     }
     migrate(originalNumArgs);
     setAllArgAttrDicts(op, newArgAttrs);
   }
 
   // Update the function type and any entry block arguments.
   op->setAttr(getTypeAttrName(), TypeAttr::get(newType));
   for (unsigned i = 0, e = argIndices.size(); i < e; ++i)
-    entry.insertArgument(argIndices[i] + i, argTypes[i],
-                         argLocs.empty() ? Optional<Location>{} : argLocs[i]);
+    entry.insertArgument(argIndices[i] + i, argTypes[i], argLocs[i]);
 }
 
 void mlir::function_interface_impl::insertFunctionResults(
     Operation *op, ArrayRef<unsigned> resultIndices, TypeRange resultTypes,
     ArrayRef<DictionaryAttr> resultAttrs, unsigned originalNumResults,
     Type newType) {
   assert(resultIndices.size() == resultTypes.size());
   assert(resultIndices.size() == resultAttrs.size() || resultAttrs.empty());

mlir/lib/IR/Region.cpp

 
 /// Return a location for this region. This is the location attached to the
 /// parent container. The region must have a valid parent container.
 Location Region::getLoc() {
   assert(container && "region is not attached to a container");
   return container->getLoc();
 }
 
-/// Return a range containing the types of the arguments for this region.
 auto Region::getArgumentTypes() -> ValueTypeRange<BlockArgListType> {
   return ValueTypeRange<BlockArgListType>(getArguments());
 }
 
-/// Add one argument to the argument list for each type specified in the list.
-iterator_range<Region::args_iterator> Region::addArguments(TypeRange types) {
-  return front().addArguments(types);
+iterator_range<Region::args_iterator>
+Region::addArguments(TypeRange types, ArrayRef<Location> locs) {
+  return front().addArguments(types, locs);
 }
 
 Region *Region::getParentRegion() {
   assert(container && "region is not attached to a container");
   return container->getParentRegion();
 }
 
 bool Region::isProperAncestor(Region *other) {

mlir/lib/Parser/Parser.cpp

public:
   //===--------------------------------------------------------------------===//
 
   /// Parse a region into 'region' with the provided entry block arguments.
   /// If non-empty, 'argLocations' contains an optional locations for each
   /// argument. 'isIsolatedNameScope' indicates if the naming scope of this
   /// region is isolated from those above.
   ParseResult parseRegion(Region &region,
                           ArrayRef<std::pair<SSAUseInfo, Type>> entryArguments,
-                          ArrayRef<Optional<Location>> argLocations = {},
+                          ArrayRef<Location> argLocations,
                           bool isIsolatedNameScope = false);
 
   /// Parse a region body into 'region'.
   ParseResult
   parseRegionBody(Region &region, llvm::SMLoc startLoc,
                   ArrayRef<std::pair<SSAUseInfo, Type>> entryArguments,
-                  ArrayRef<Optional<Location>> argLocations,
-                  bool isIsolatedNameScope);
+                  ArrayRef<Location> argLocations, bool isIsolatedNameScope);
 
   //===--------------------------------------------------------------------===//
   // Block Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a new block into 'block'.
   ParseResult parseBlock(Block *&block);
 
ParseResult OperationParser::parseGenericOperationAfterOpName(
   }
 
   // Parse the region list, if not explicitly provided.
   if (!parsedRegions) {
     if (consumeIf(Token::l_paren)) {
       do {
         // Create temporary regions with the top level region as parent.
         result.regions.emplace_back(new Region(topLevelOp));
-        if (parseRegion(*result.regions.back(), /*entryArguments=*/{}))
+        if (parseRegion(*result.regions.back(), /*entryArguments=*/{},
+                        /*argLocations=*/{}))
           return failure();
       } while (consumeIf(Token::comma));
       if (parseToken(Token::r_paren, "expected ')' to end region list"))
         return failure();
     }
   } else {
     result.addRegions(*parsedRegions);
   }
public:
   //===--------------------------------------------------------------------===//
   // Region Parsing
   //===--------------------------------------------------------------------===//
 
   /// Parse a region that takes `arguments` of `argTypes` types.  This
   /// effectively defines the SSA values of `arguments` and assigns their type.
   ParseResult parseRegion(Region &region, ArrayRef<OperandType> arguments,
                           ArrayRef<Type> argTypes,
-                          ArrayRef<Optional<Location>> argLocations,
+                          ArrayRef<Location> argLocations,
                           bool enableNameShadowing) override {
     assert(arguments.size() == argTypes.size() &&
            "mismatching number of arguments and types");
 
     SmallVector<std::pair<OperationParser::SSAUseInfo, Type>, 2>
         regionArguments;
     for (auto pair : llvm::zip(arguments, argTypes)) {
       const OperandType &operand = std::get<0>(pair);
assert((!enableNameShadowing || isIsolatedFromAbove) &&
            "name shadowing is only allowed on isolated regions");
     if (parser.parseRegion(region, regionArguments, argLocations,
                            enableNameShadowing))
       return failure();
     return success();
   }
 
   /// Parses a region if present.
-  OptionalParseResult
-  parseOptionalRegion(Region &region, ArrayRef<OperandType> arguments,
+  OptionalParseResult parseOptionalRegion(Region &region,
+                                          ArrayRef<OperandType> arguments,
                                           ArrayRef<Type> argTypes,
-                      ArrayRef<Optional<Location>> argLocations,
+                                          ArrayRef<Location> argLocations,
                                           bool enableNameShadowing) override {
     if (parser.getToken().isNot(Token::l_brace))
       return llvm::None;
     return parseRegion(region, arguments, argTypes, argLocations,
                        enableNameShadowing);
   }
 
   /// Parses a region if present. If the region is present, a new region is
   /// allocated and placed in `region`. If no region is present, `region`

 
 //===----------------------------------------------------------------------===//
 // Region Parsing
 //===----------------------------------------------------------------------===//
 
 ParseResult OperationParser::parseRegion(
     Region &region,
     ArrayRef<std::pair<OperationParser::SSAUseInfo, Type>> entryArguments,
-    ArrayRef<Optional<Location>> argLocations, bool isIsolatedNameScope) {
+    ArrayRef<Location> argLocations, bool isIsolatedNameScope) {
   // Parse the '{'.
   Token lBraceTok = getToken();
   if (parseToken(Token::l_brace, "expected '{' to begin a region"))
     return failure();
 
   // If we are populating the parser state, start a new region definition.
   if (state.asmState)
     state.asmState->startRegionDefinition();
if (state.asmState)
     state.asmState->finalizeRegionDefinition();
 
   return success();
 }
 
 ParseResult OperationParser::parseRegionBody(
     Region &region, llvm::SMLoc startLoc,
     ArrayRef<std::pair<OperationParser::SSAUseInfo, Type>> entryArguments,
-    ArrayRef<Optional<Location>> argLocations, bool isIsolatedNameScope) {
+    ArrayRef<Location> argLocations, bool isIsolatedNameScope) {
   assert(argLocations.empty() || argLocations.size() == entryArguments.size());
   auto currentPt = opBuilder.saveInsertionPoint();
 
   // Push a new named value scope.
   pushSSANameScope(isIsolatedNameScope);
 
   // Parse the first block directly to allow for it to be unnamed.
   auto owningBlock = std::make_unique<Block>();
for (const auto &it : llvm::enumerate(entryArguments)) {
 
       // Ensure that the argument was not already defined.
       if (auto defLoc = getReferenceLoc(argInfo.name, argInfo.number)) {
         return emitError(argInfo.loc, "region entry argument '" + argInfo.name +
                                           "' is already in use")
                    .attachNote(getEncodedSourceLocation(*defLoc))
                << "previously referenced here";
       }
-      Location loc =
-          (!argLocations.empty() && argLocations[argIndex])
-              ? *argLocations[argIndex]
-              : getEncodedSourceLocation(placeholderArgPair.first.loc);
-      BlockArgument arg = block->addArgument(placeholderArgPair.second, loc);
+      BlockArgument arg = block->addArgument(
+          placeholderArgPair.second,
+          argLocations.empty()
+              ? getEncodedSourceLocation(placeholderArgPair.first.loc)
+              : argLocations[argIndex]);
 
       // Add a definition of this arg to the assembly state if provided.
       if (state.asmState)
         state.asmState->addDefinition(arg, argInfo.loc);
 
       // Record the definition for this argument.
       if (addDefinition(argInfo, arg))
         return failure();

mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp

case llvm::Instruction::Br: {
 
     b.createOperation(state);
     return success();
   }
   case llvm::Instruction::PHI: {
     Type type = processType(inst->getType());
     if (!type)
       return failure();
-    v = b.getInsertionBlock()->addArgument(type);
+    v = b.getInsertionBlock()->addArgument(
+        type, processDebugLoc(inst->getDebugLoc(), inst));
     return success();
   }
   case llvm::Instruction::Call: {
     llvm::CallInst *ci = cast<llvm::CallInst>(inst);
     SmallVector<Value, 4> ops;
     ops.reserve(inst->getNumOperands());
     for (auto &op : ci->args()) {
       Value arg = processValue(op.get());
LogicalResult Importer::processFunction(llvm::Function *f) {
   SmallVector<Block *, 4> blockList;
   for (llvm::BasicBlock &bb : *f) {
     blockList.push_back(b.createBlock(&fop.getBody(), fop.getBody().end()));
     blocks[&bb] = blockList.back();
   }
   currentEntryBlock = blockList[0];
 
   // Add function arguments to the entry block.
-  for (const auto &kv : llvm::enumerate(f->args()))
-    instMap[&kv.value()] =
-        blockList[0]->addArgument(functionType.getParamType(kv.index()));
+  for (const auto &kv : llvm::enumerate(f->args())) {
+    instMap[&kv.value()] = blockList[0]->addArgument(
+        functionType.getParamType(kv.index()), fop.getLoc());
+  }
 
   for (auto bbs : llvm::zip(*f, blockList)) {
     if (failed(processBasicBlock(&std::get<0>(bbs), std::get<1>(bbs))))
       return failure();
   }
 
   // Now that all instructions are guaranteed to have been visited, ensure
   // any unknown uses we encountered are remapped.

mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp

LogicalResult spirv::Deserializer::processPhi(ArrayRef<uint32_t> operands) {
 
   if (operands.size() < 4) {
     return emitError(unknownLoc, "OpPhi must specify result type, result <id>, "
                                  "and variable-parent pairs");
   }
 
   // Create a block argument for this OpPhi instruction.
   Type blockArgType = getType(operands[0]);
-  BlockArgument blockArg = curBlock->addArgument(blockArgType);
+  BlockArgument blockArg = curBlock->addArgument(blockArgType, unknownLoc);
   valueMap[operands[1]] = blockArg;
   LLVM_DEBUG(logger.startLine()
              << "[phi] created block argument " << blockArg
              << " id = " << operands[1] << " of type " << blockArgType << "\n");
 
   // For each (value, predecessor) pair, insert the value to the predecessor's
   // blockPhiInfo entry so later we can fix the block argument there.
   for (unsigned i = 2, e = operands.size(); i < e; i += 2) {
for (auto *block : constructBlocks) {
     // Create a block and insert it before the selection/loop merge block in the
     // SelectionOp/LoopOp's region.
     auto *newBlock = builder.createBlock(&body.back());
     mapper.map(block, newBlock);
     LLVM_DEBUG(logger.startLine() << "[cf] cloned block " << newBlock
                                   << " from block " << block << "\n");
     if (!isFnEntryBlock(block)) {
       for (BlockArgument blockArg : block->getArguments()) {
-        auto newArg = newBlock->addArgument(blockArg.getType());
+        auto newArg =
+            newBlock->addArgument(blockArg.getType(), blockArg.getLoc());
         mapper.map(blockArg, newArg);
         LLVM_DEBUG(logger.startLine() << "[cf] remapped block argument "
                                       << blockArg << " to " << newArg << "\n");
       }
     } else {
       LLVM_DEBUG(logger.startLine()
                  << "[cf] block " << block << " is a function entry block\n");
     }
if (isLoop) {
     if (!mergeBlock->args_empty()) {
       return mergeBlock->getParentOp()->emitError(
           "OpPhi in loop merge block unsupported");
     }
 
     // The loop header block may have block arguments. Since now we place the
     // loop op inside the old merge block, we need to make sure the old merge
     // block has the same block argument list.
-    for (BlockArgument blockArg : headerBlock->getArguments()) {
-      mergeBlock->addArgument(blockArg.getType());
-    }
+    for (BlockArgument blockArg : headerBlock->getArguments())
+      mergeBlock->addArgument(blockArg.getType(), blockArg.getLoc());
 
     // If the loop header block has block arguments, make sure the spv.Branch op
     // matches.
     SmallVector<Value, 4> blockArgs;
     if (!headerBlock->args_empty())
       blockArgs = {mergeBlock->args_begin(), mergeBlock->args_end()};
 
     // The loop entry block should have a unconditional branch jumping to the

mlir/lib/Transforms/BufferResultsToOutParams.cpp

func.setArgAttrs(functionType.getNumInputs() + i,
                      func.getResultAttrs(erasedResultIndices[i]));
 
   // Erase the results.
   func.eraseResults(erasedResultIndices);
 
   // Add the new arguments to the entry block if the function is not external.
   if (func.isExternal())
     return;
-  auto newArgs = func.front().addArguments(erasedResultTypes);
-  appendedEntryArgs.append(newArgs.begin(), newArgs.end());
+  Location loc = func.getLoc();
+  for (Type type : erasedResultTypes)
+    appendedEntryArgs.push_back(func.front().addArgument(type, loc));
 }
 
 // Updates all ReturnOps in the scope of the given FuncOp by either keeping them
 // as return values or copying the associated buffer contents into the given
 // out-params.
 static void updateReturnOps(FuncOp func,
                             ArrayRef<BlockArgument> appendedEntryArgs) {
   func.walk([&](ReturnOp op) {

mlir/lib/Transforms/NormalizeMemRefs.cpp

void NormalizeMemRefs::normalizeFuncOpMemRefs(FuncOp funcOp,
   funcOp.walk([&](memref::AllocOp op) { allocOps.push_back(op); });
   for (memref::AllocOp allocOp : allocOps)
     (void)normalizeMemRef(&allocOp);
 
   // We use this OpBuilder to create new memref layout later.
   OpBuilder b(funcOp);
 
   FunctionType functionType = funcOp.getType();
+  SmallVector<Location> functionArgLocs(llvm::map_range(
+      funcOp.getArguments(), [](BlockArgument arg) { return arg.getLoc(); }));
   SmallVector<Type, 8> inputTypes;
   // Walk over each argument of a function to perform memref normalization (if
   for (unsigned argIndex :
        llvm::seq<unsigned>(0, functionType.getNumInputs())) {
     Type argType = functionType.getInput(argIndex);
     MemRefType memrefType = argType.dyn_cast<MemRefType>();
     // Check whether argument is of MemRef type. Any other argument type can
     // simply be part of the final function signature.
     if (!memrefType) {
       inputTypes.push_back(argType);
       continue;
     }
     // Fetch a new memref type after normalizing the old memref to have an
     // identity map layout.
     MemRefType newMemRefType = normalizeMemRefType(memrefType, b,
                                                    /*numSymbolicOperands=*/0);
     if (newMemRefType == memrefType || funcOp.isExternal()) {
       // Either memrefType already had an identity map or the map couldn't be
       // transformed to an identity map.
       inputTypes.push_back(newMemRefType);
       continue;
     }
 
     // Insert a new temporary argument with the new memref type.
-    BlockArgument newMemRef =
-        funcOp.front().insertArgument(argIndex, newMemRefType);
+    BlockArgument newMemRef = funcOp.front().insertArgument(
+        argIndex, newMemRefType, functionArgLocs[argIndex]);
     BlockArgument oldMemRef = funcOp.getArgument(argIndex + 1);
     AffineMap layoutMap = memrefType.getLayout().getAffineMap();
     // Replace all uses of the old memref.
     if (failed(replaceAllMemRefUsesWith(oldMemRef, /*newMemRef=*/newMemRef,
                                         /*extraIndices=*/{},
                                         /*indexRemap=*/layoutMap,
                                         /*extraOperands=*/{},
                                         /*symbolOperands=*/{},

mlir/lib/Transforms/Utils/DialectConversion.cpp

Block *ArgConverter::applySignatureConversion(
   if (origArgCount == 0 && convertedTypes.empty())
     return block;
 
   // Split the block at the beginning to get a new block to use for the updated
   // signature.
   Block *newBlock = block->splitBlock(block->begin());
   block->replaceAllUsesWith(newBlock);
 
-  SmallVector<Value, 4> newArgRange(newBlock->addArguments(convertedTypes));
+  // FIXME: We should map the new arguments to proper locations.
+  SmallVector<Location> newLocs(convertedTypes.size(),
+                                rewriter.getUnknownLoc());
+  SmallVector<Value, 4> newArgRange(
+      newBlock->addArguments(convertedTypes, newLocs));
   ArrayRef<Value> newArgs(newArgRange);
 
   // Remap each of the original arguments as determined by the signature
   // conversion.
   ConvertedBlockInfo info(block, converter);
   info.argInfo.resize(origArgCount);
 
   OpBuilder::InsertionGuard guard(rewriter);

mlir/lib/Transforms/Utils/InliningUtils.cpp

if (std::next(newBlocks.begin()) == newBlocks.end()) {
     // Merge the post insert block into the cloned entry block.
     firstNewBlock->getOperations().splice(firstNewBlock->end(),
                                           postInsertBlock->getOperations());
     postInsertBlock->erase();
   } else {
     // Otherwise, there were multiple blocks inlined. Add arguments to the post
     // insertion block to represent the results to replace.
     for (const auto &resultToRepl : llvm::enumerate(resultsToReplace)) {
-      resultToRepl.value().replaceAllUsesWith(postInsertBlock->addArgument(
-          regionResultTypes[resultToRepl.index()]));
+      resultToRepl.value().replaceAllUsesWith(
+          postInsertBlock->addArgument(regionResultTypes[resultToRepl.index()],
+                                       resultToRepl.value().getLoc()));
     }
 
     /// Handle the terminators for each of the new blocks.
     for (auto &newBlock : newBlocks)
       interface.handleTerminator(newBlock.getTerminator(), postInsertBlock);
   }
 
   // Splice the instructions of the inlined entry block into the insert block.

mlir/lib/Transforms/Utils/RegionUtils.cpp

for (const auto &it : llvm::enumerate(operandsToMerge)) {
       // Process the operand for each of the block iterators.
       for (unsigned i = 0, e = blockIterators.size(); i != e; ++i) {
         Block::iterator &blockIter = blockIterators[i];
         std::advance(blockIter, nextOpOffset);
         auto &operand = blockIter->getOpOperand(it.value().second);
         newArguments[i][it.index()] = operand.get();
 
         // Update the operand and insert an argument if this is the leader.
-        if (i == 0)
-          operand.set(leaderBlock->addArgument(operand.get().getType()));
+        if (i == 0) {
+          Value operandVal = operand.get();
+          operand.set(leaderBlock->addArgument(operandVal.getType(),
+                                               operandVal.getLoc()));
+        }
       }
     }
     // Update the predecessors for each of the blocks.
     auto updatePredecessors = [&](Block *block, unsigned clusterIndex) {
       for (auto predIt = block->pred_begin(), predE = block->pred_end();
            predIt != predE; ++predIt) {
         auto branch = cast<BranchOpInterface>((*predIt)->getTerminator());
         unsigned succIndex = predIt.getSuccessorIndex();

mlir/test/CAPI/ir.c

 
 MlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
   MlirModule moduleOp = mlirModuleCreateEmpty(location);
   MlirBlock moduleBody = mlirModuleGetBody(moduleOp);
 
   MlirType memrefType =
       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString("memref<?xf32>"));
   MlirType funcBodyArgTypes[] = {memrefType, memrefType};
+  MlirLocation funcBodyArgLocs[] = {location, location};
   MlirRegion funcBodyRegion = mlirRegionCreate();
-  MlirBlock funcBody = mlirBlockCreate(
-      sizeof(funcBodyArgTypes) / sizeof(MlirType), funcBodyArgTypes);
+  MlirBlock funcBody =
+      mlirBlockCreate(sizeof(funcBodyArgTypes) / sizeof(MlirType),
+                      funcBodyArgTypes, funcBodyArgLocs);
   mlirRegionAppendOwnedBlock(funcBodyRegion, funcBody);
 
   MlirAttribute funcTypeAttr = mlirAttributeParseGet(
       ctx,
       mlirStringRefCreateFromCString("(memref<?xf32>, memref<?xf32>) -> ()"));
   MlirAttribute funcNameAttr =
       mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("\"add\""));
   MlirNamedAttribute funcAttrs[] = {
MlirModule makeAndDumpAdd(MlirContext ctx, MlirLocation location) {
   MlirOperationState dimState = mlirOperationStateGet(
       mlirStringRefCreateFromCString("memref.dim"), location);
   mlirOperationStateAddOperands(&dimState, 2, dimOperands);
   mlirOperationStateAddResults(&dimState, 1, &indexType);
   MlirOperation dim = mlirOperationCreate(&dimState);
   mlirBlockAppendOwnedOperation(funcBody, dim);
 
   MlirRegion loopBodyRegion = mlirRegionCreate();
-  MlirBlock loopBody = mlirBlockCreate(0, NULL);
-  mlirBlockAddArgument(loopBody, indexType);
+  MlirBlock loopBody = mlirBlockCreate(0, NULL, NULL);
+  mlirBlockAddArgument(loopBody, indexType, location);
   mlirRegionAppendOwnedBlock(loopBodyRegion, loopBody);
 
   MlirAttribute indexOneLiteral =
       mlirAttributeParseGet(ctx, mlirStringRefCreateFromCString("1 : index"));
   MlirNamedAttribute indexOneValueAttr = mlirNamedAttributeGet(
       mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("value")),
       indexOneLiteral);
   MlirOperationState constOneState = mlirOperationStateGet(
static void buildWithInsertionsAndPrint(MlirContext ctx) {
   MlirRegion region = mlirOperationGetRegion(op, 0);
 
   // Use integer types of different bitwidth as block arguments in order to
   // differentiate blocks.
   MlirType i1 = mlirIntegerTypeGet(ctx, 1);
   MlirType i2 = mlirIntegerTypeGet(ctx, 2);
   MlirType i3 = mlirIntegerTypeGet(ctx, 3);
   MlirType i4 = mlirIntegerTypeGet(ctx, 4);
-  MlirBlock block1 = mlirBlockCreate(1, &i1);
-  MlirBlock block2 = mlirBlockCreate(1, &i2);
-  MlirBlock block3 = mlirBlockCreate(1, &i3);
-  MlirBlock block4 = mlirBlockCreate(1, &i4);
+  MlirBlock block1 = mlirBlockCreate(1, &i1, &loc);
+  MlirBlock block2 = mlirBlockCreate(1, &i2, &loc);
+  MlirBlock block3 = mlirBlockCreate(1, &i3, &loc);
+  MlirBlock block4 = mlirBlockCreate(1, &i4, &loc);
   // Insert blocks so as to obtain the 1-2-3-4 order,
   mlirRegionInsertOwnedBlockBefore(region, nullBlock, block3);
   mlirRegionInsertOwnedBlockBefore(region, block3, block2);
   mlirRegionInsertOwnedBlockAfter(region, nullBlock, block1);
   mlirRegionInsertOwnedBlockAfter(region, block3, block4);
 
   MlirOperationState op1State =
       mlirOperationStateGet(mlirStringRefCreateFromCString("dummy.op1"), loc);
static int testBackreferences() {
 
   MlirContext ctx = mlirContextCreate();
   mlirContextSetAllowUnregisteredDialects(ctx, true);
   MlirLocation loc = mlirLocationUnknownGet(ctx);
 
   MlirOperationState opState =
       mlirOperationStateGet(mlirStringRefCreateFromCString("invalid.op"), loc);
   MlirRegion region = mlirRegionCreate();
-  MlirBlock block = mlirBlockCreate(0, NULL);
+  MlirBlock block = mlirBlockCreate(0, NULL, NULL);
   mlirRegionAppendOwnedBlock(region, block);
   mlirOperationStateAddOwnedRegions(&opState, 1, &region);
   MlirOperation op = mlirOperationCreate(&opState);
   MlirIdentifier ident =
       mlirIdentifierGet(ctx, mlirStringRefCreateFromCString("identifier"));
 
   if (!mlirContextEqual(ctx, mlirOperationGetContext(op))) {
     fprintf(stderr, "ERROR: Getting context from operation failed\n");

mlir/test/lib/Dialect/Test/TestPatterns.cpp

struct TestRegionRewriteUndo : public RewritePattern {
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const final {
     // Create the region operation with an entry block containing arguments.
     OperationState newRegion(op->getLoc(), "test.region");
     newRegion.addRegion();
     auto *regionOp = rewriter.createOperation(newRegion);
     auto *entryBlock = rewriter.createBlock(&regionOp->getRegion(0));
-    entryBlock->addArgument(rewriter.getIntegerType(64));
+    entryBlock->addArgument(rewriter.getIntegerType(64),
+                            rewriter.getUnknownLoc());
 
     // Add an explicitly illegal operation to ensure the conversion fails.
     rewriter.create<ILLegalOpF>(op->getLoc(), rewriter.getIntegerType(32));
     rewriter.create<TestValidOp>(op->getLoc(), ArrayRef<Value>());
 
     // Drop this operation.
     rewriter.eraseOp(op);
     return success();
   }
 };
 /// A simple pattern that creates a block at the end of the parent region of the
 /// matched operation.
 struct TestCreateBlock : public RewritePattern {
   TestCreateBlock(MLIRContext *ctx)
       : RewritePattern("test.create_block", /*benefit=*/1, ctx) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const final {
     Region &region = *op->getParentRegion();
     Type i32Type = rewriter.getIntegerType(32);
-    rewriter.createBlock(&region, region.end(), {i32Type, i32Type});
-    rewriter.create<TerminatorOp>(op->getLoc());
+    Location loc = op->getLoc();
+    rewriter.createBlock(&region, region.end(), {i32Type, i32Type}, {loc, loc});
+    rewriter.create<TerminatorOp>(loc);
     rewriter.replaceOp(op, {});
     return success();
   }
 };
 
 /// A simple pattern that creates a block containing an invalid operation in
 /// order to trigger the block creation undo mechanism.
 struct TestCreateIllegalBlock : public RewritePattern {
   TestCreateIllegalBlock(MLIRContext *ctx)
       : RewritePattern("test.create_illegal_block", /*benefit=*/1, ctx) {}
 
   LogicalResult matchAndRewrite(Operation *op,
                                 PatternRewriter &rewriter) const final {
     Region &region = *op->getParentRegion();
     Type i32Type = rewriter.getIntegerType(32);
-    rewriter.createBlock(&region, region.end(), {i32Type, i32Type});
+    Location loc = op->getLoc();
+    rewriter.createBlock(&region, region.end(), {i32Type, i32Type}, {loc, loc});
     // Create an illegal op to ensure the conversion fails.
-    rewriter.create<ILLegalOpF>(op->getLoc(), i32Type);
-    rewriter.create<TerminatorOp>(op->getLoc());
+    rewriter.create<ILLegalOpF>(loc, i32Type);
+    rewriter.create<TerminatorOp>(loc);
     rewriter.replaceOp(op, {});
     return success();
   }
 };
 
 /// A simple pattern that tests the undo mechanism when replacing the uses of a
 /// block argument.
 struct TestUndoBlockArgReplace : public ConversionPattern {

mlir/test/lib/IR/TestFunc.cpp

 /// This is a test pass for verifying FuncOp's insertArgument method.
 struct TestFuncInsertArg
     : public PassWrapper<TestFuncInsertArg, OperationPass<ModuleOp>> {
   StringRef getArgument() const final { return "test-func-insert-arg"; }
   StringRef getDescription() const final { return "Test inserting func args."; }
   void runOnOperation() override {
     auto module = getOperation();
 
+    UnknownLoc unknownLoc = UnknownLoc::get(module.getContext());
     for (FuncOp func : module.getOps<FuncOp>()) {
       auto inserts = func->getAttrOfType<ArrayAttr>("test.insert_args");
       if (!inserts || inserts.empty())
         continue;
       SmallVector<unsigned, 4> indicesToInsert;
       SmallVector<Type, 4> typesToInsert;
       SmallVector<DictionaryAttr, 4> attrsToInsert;
-      SmallVector<Optional<Location>, 4> locsToInsert;
+      SmallVector<Location, 4> locsToInsert;
       for (auto insert : inserts.getAsRange<ArrayAttr>()) {
         indicesToInsert.push_back(
             insert[0].cast<IntegerAttr>().getValue().getZExtValue());
         typesToInsert.push_back(insert[1].cast<TypeAttr>().getValue());
         attrsToInsert.push_back(insert.size() > 2
                                     ? insert[2].cast<DictionaryAttr>()
                                     : DictionaryAttr::get(&getContext()));
-        locsToInsert.push_back(
-            insert.size() > 3
-                ? Optional<Location>(insert[3].cast<LocationAttr>())
-                : Optional<Location>{});
+        locsToInsert.push_back(insert.size() > 3
+                                   ? Location(insert[3].cast<LocationAttr>())
+                                   : unknownLoc);
       }
       func->removeAttr("test.insert_args");
       func.insertArguments(indicesToInsert, typesToInsert, attrsToInsert,
                            locsToInsert);
     }
   }
 };