diff --git a/include/mlir/IR/Builders.h b/include/mlir/IR/Builders.h
index 3cc8227..a545fe1 100644
--- a/include/mlir/IR/Builders.h
+++ b/include/mlir/IR/Builders.h
@@ -18,7 +18,6 @@
 #ifndef MLIR_IR_BUILDERS_H
 #define MLIR_IR_BUILDERS_H
 
-#include "mlir/IR/Attributes.h"
 #include "mlir/IR/CFGFunction.h"
 #include "mlir/IR/MLFunction.h"
 #include "mlir/IR/Statements.h"
@@ -26,6 +25,9 @@
 namespace mlir {
 class MLIRContext;
 class Module;
+class UnknownLoc;
+class UniquedFilename;
+class FileLineColLoc;
 class Type;
 class PrimitiveType;
 class IntegerType;
@@ -59,6 +61,12 @@
   Identifier getIdentifier(StringRef str);
   Module *createModule();
 
+  // Locations.
+  UnknownLoc *getUnknownLoc();
+  UniquedFilename getUniquedFilename(StringRef filename);
+  FileLineColLoc *getFileLineColLoc(UniquedFilename filename, unsigned line,
+                                    unsigned column);
+
   // Types.
   FloatType *getBF16Type();
   FloatType *getF16Type();
@@ -185,7 +193,7 @@
 
   /// Create operation of specific op type at the current insertion point.
   template <typename OpTy, typename... Args>
-  OpPointer<OpTy> create(Attribute *location, Args... args) {
+  OpPointer<OpTy> create(Location *location, Args... args) {
     OperationState state(getContext(), location, OpTy::getOperationName());
     OpTy::build(this, &state, args...);
     auto *inst = createOperation(state);
@@ -202,16 +210,16 @@
 
   // Terminators.
 
-  ReturnInst *createReturn(Attribute *location, ArrayRef<CFGValue *> operands) {
+  ReturnInst *createReturn(Location *location, ArrayRef<CFGValue *> operands) {
     return insertTerminator(ReturnInst::create(location, operands));
   }
 
-  BranchInst *createBranch(Attribute *location, BasicBlock *dest,
+  BranchInst *createBranch(Location *location, BasicBlock *dest,
                            ArrayRef<CFGValue *> operands = {}) {
     return insertTerminator(BranchInst::create(location, dest, operands));
   }
 
-  CondBranchInst *createCondBranch(Attribute *location, CFGValue *condition,
+  CondBranchInst *createCondBranch(Location *location, CFGValue *condition,
                                    BasicBlock *trueDest,
                                    BasicBlock *falseDest) {
     return insertTerminator(
@@ -290,7 +298,7 @@
 
   /// Create operation of specific op type at the current insertion point.
   template <typename OpTy, typename... Args>
-  OpPointer<OpTy> create(Attribute *location, Args... args) {
+  OpPointer<OpTy> create(Location *location, Args... args) {
     OperationState state(getContext(), location, OpTy::getOperationName());
     OpTy::build(this, &state, args...);
     auto *stmt = createOperation(state);
@@ -311,15 +319,12 @@
     return cloneStmt;
   }
 
-  /// Create a 'for' statement with bounds that may involve MLValue operands.
-  /// When step is not specified, it is set to 1.
-  ForStmt *createFor(Attribute *location, ArrayRef<MLValue *> lbOperands,
+  // Creates for statement. When step is not specified, it is set to 1.
+  ForStmt *createFor(Location *location, ArrayRef<MLValue *> lbOperands,
                      AffineMap *lbMap, ArrayRef<MLValue *> ubOperands,
                      AffineMap *ubMap, int64_t step = 1);
 
-  /// Create if statement.
-  /// TODO: pass operands.
-  IfStmt *createIf(Attribute *location, IntegerSet *condition);
+  IfStmt *createIf(Location *location, IntegerSet *condition);
 
 private:
   StmtBlock *block = nullptr;
diff --git a/include/mlir/IR/Instructions.h b/include/mlir/IR/Instructions.h
index ad0cb05..1f75241 100644
--- a/include/mlir/IR/Instructions.h
+++ b/include/mlir/IR/Instructions.h
@@ -49,9 +49,8 @@
   /// Return the context this operation is associated with.
   MLIRContext *getContext() const;
 
-  /// The source location the operation was defined or derived from.  Note that
-  /// it is possible for this pointer to be null.
-  Attribute *getLoc() const { return location; }
+  /// The source location the operation was defined or derived from.
+  Location *getLoc() const { return location; }
 
   /// Return the BasicBlock containing this instruction.
   BasicBlock *getBlock() const { return block; }
@@ -138,8 +137,9 @@
   void emitNote(const Twine &message) const;
 
 protected:
-  Instruction(Kind kind, Attribute *location)
-      : kind(kind), location(location) {}
+  Instruction(Kind kind, Location *location) : kind(kind), location(location) {
+    assert(location && "location can never be null");
+  }
 
   // Instructions are deleted through the destroy() member because this class
   // does not have a virtual destructor.  A vtable would bloat the size of
@@ -153,7 +153,7 @@
 
   /// This holds information about the source location the operation was defined
   /// or derived from.
-  Attribute *location;
+  Location *location;
 
   friend struct llvm::ilist_traits<OperationInst>;
   friend class BasicBlock;
@@ -172,8 +172,8 @@
       public llvm::ilist_node_with_parent<OperationInst, BasicBlock>,
       private llvm::TrailingObjects<OperationInst, InstOperand, InstResult> {
 public:
-  /// Create a new OperationInst with the specific fields.
-  static OperationInst *create(Attribute *location, Identifier name,
+  /// Create a new OperationInst with the specified fields.
+  static OperationInst *create(Location *location, Identifier name,
                                ArrayRef<CFGValue *> operands,
                                ArrayRef<Type *> resultTypes,
                                ArrayRef<NamedAttribute> attributes,
@@ -312,7 +312,7 @@
 private:
   const unsigned numOperands, numResults;
 
-  OperationInst(Attribute *location, Identifier name, unsigned numOperands,
+  OperationInst(Location *location, Identifier name, unsigned numOperands,
                 unsigned numResults, ArrayRef<NamedAttribute> attributes,
                 MLIRContext *context);
   ~OperationInst();
@@ -358,8 +358,7 @@
   }
 
 protected:
-  TerminatorInst(Kind kind, Attribute *location)
-      : Instruction(kind, location) {}
+  TerminatorInst(Kind kind, Location *location) : Instruction(kind, location) {}
   ~TerminatorInst() {}
 };
 
@@ -367,7 +366,7 @@
 /// and may pass basic block arguments to the successor.
 class BranchInst : public TerminatorInst {
 public:
-  static BranchInst *create(Attribute *location, BasicBlock *dest,
+  static BranchInst *create(Location *location, BasicBlock *dest,
                             ArrayRef<CFGValue *> operands = {}) {
     return new BranchInst(location, dest, operands);
   }
@@ -400,9 +399,8 @@
   }
 
 private:
-  explicit BranchInst(Attribute *location, BasicBlock *dest,
+  explicit BranchInst(Location *location, BasicBlock *dest,
                       ArrayRef<CFGValue *> operands);
-
   BasicBlockOperand dest;
   std::vector<InstOperand> operands;
 };
@@ -415,7 +413,7 @@
   enum { trueIndex = 0, falseIndex = 1 };
 
 public:
-  static CondBranchInst *create(Attribute *location, CFGValue *condition,
+  static CondBranchInst *create(Location *location, CFGValue *condition,
                                 BasicBlock *trueDest, BasicBlock *falseDest) {
     return new CondBranchInst(location, condition, trueDest, falseDest);
   }
@@ -561,7 +559,7 @@
   }
 
 private:
-  CondBranchInst(Attribute *location, CFGValue *condition, BasicBlock *trueDest,
+  CondBranchInst(Location *location, CFGValue *condition, BasicBlock *trueDest,
                  BasicBlock *falseDest);
 
   CFGValue *condition;
@@ -581,7 +579,7 @@
       private llvm::TrailingObjects<ReturnInst, InstOperand> {
 public:
   /// Create a new ReturnInst with the specific fields.
-  static ReturnInst *create(Attribute *location, ArrayRef<CFGValue *> operands);
+  static ReturnInst *create(Location *location, ArrayRef<CFGValue *> operands);
 
   unsigned getNumOperands() const { return numOperands; }
 
@@ -606,7 +604,7 @@
     return numOperands;
   }
 
-  ReturnInst(Attribute *location, unsigned numOperands);
+  ReturnInst(Location *location, unsigned numOperands);
   ~ReturnInst();
 
   unsigned numOperands;
diff --git a/include/mlir/IR/Location.h b/include/mlir/IR/Location.h
new file mode 100644
index 0000000..613d0b6
--- /dev/null
+++ b/include/mlir/IR/Location.h
@@ -0,0 +1,137 @@
+//===- Location.h - MLIR Location Classes -----------------------*- C++ -*-===//
+//
+// Copyright 2019 The MLIR Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// =============================================================================
+//
+// These classes provide the ability to relate MLIR objects back to source
+// location position information.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MLIR_IR_LOCATION_H
+#define MLIR_IR_LOCATION_H
+
+#include "mlir/Support/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace mlir {
+class MLIRContext;
+
+/// Location objects represent source locations information in MLIR.
+class Location {
+public:
+  enum class Kind {
+    /// This represents an unknown location.
+    Unknown,
+
+    /// This represents a file/line/column location.
+    FileLineCol,
+
+    // Represents a location as a 'void*' pointer to a front-end's opaque
+    // location information, which must live longer than the MLIR objects that
+    // refer to it.  OpaqueLocation's are never serialized.
+    //
+    // TODO: OpaqueLocation,
+
+    // Represents a value inlined through a function call.
+    // TODO: InlinedLocation,
+
+    // Represents a value composed of multiple source constructs.
+    // TODO: FusedLocation,
+  };
+
+  /// Return the classification for this location.
+  Kind getKind() const { return kind; }
+
+  /// Print the location.
+  void print(raw_ostream &os) const;
+  void dump() const;
+
+protected:
+  explicit Location(Kind kind) : kind(kind) {}
+  ~Location() {}
+
+private:
+  /// Classification of the subclass, used for type checking.
+  Kind kind : 8;
+
+  Location(const Location &) = delete;
+  void operator=(const Location &) = delete;
+};
+
+inline raw_ostream &operator<<(raw_ostream &os, const Location &loc) {
+  loc.print(os);
+  return os;
+}
+
+/// Represents an unknown location.  This is always a singleton for a given
+/// MLIRContext.
+class UnknownLoc : public Location {
+public:
+  static UnknownLoc *get(MLIRContext *context);
+
+private:
+  explicit UnknownLoc() : Location(Kind::Unknown) {}
+};
+
+/// This class is used to represent a uniqued filename in an MLIRContext.  It is
+/// a simple wrapper around a const char* to uniqued string memory.
+class UniquedFilename {
+public:
+  /// Unique the specified filename and return a stable pointer owned by the
+  /// specified context.  The filename is not allowed to contain embedded ASCII
+  /// nul (\0) characters.
+  static UniquedFilename get(StringRef filename, MLIRContext *context);
+
+  StringRef getRef() const { return string; }
+  const char *data() const { return string; }
+
+private:
+  explicit UniquedFilename(const char *string) : string(string) {}
+  const char *string;
+};
+
+/// Represents a location derived from a file/line/column location.  The column
+/// and line may be zero to represent unknown column and/or unknown line/column
+/// information.
+class FileLineColLoc : public Location {
+public:
+  /// Return a uniqued FileLineCol location object.
+  static FileLineColLoc *get(UniquedFilename filename, unsigned line,
+                             unsigned column, MLIRContext *context);
+
+  StringRef getFilename() const { return filename.getRef(); }
+
+  unsigned getLine() const { return line; }
+  unsigned getColumn() const { return column; }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast.
+  static bool classof(const Location *loc) {
+    return loc->getKind() == Kind::FileLineCol;
+  }
+
+private:
+  FileLineColLoc(UniquedFilename filename, unsigned line, unsigned column)
+      : Location(Kind::FileLineCol), filename(filename), line(line),
+        column(column) {}
+  ~FileLineColLoc() = delete;
+
+  const UniquedFilename filename;
+  const unsigned line, column;
+};
+
+} // end namespace mlir
+
+#endif
diff --git a/include/mlir/IR/MLIRContext.h b/include/mlir/IR/MLIRContext.h
index d782be6..0ea78dd 100644
--- a/include/mlir/IR/MLIRContext.h
+++ b/include/mlir/IR/MLIRContext.h
@@ -24,7 +24,7 @@
 
 namespace mlir {
 class MLIRContextImpl;
-class Attribute;
+class Location;
 
 /// MLIRContext is the top-level object for a collection of MLIR modules.  It
 /// holds immortal uniqued objects like types, and the tables used to unique
@@ -58,7 +58,7 @@
   // notes will be dropped and errors will terminate the process with exit(1).
 
   using DiagnosticHandlerTy = std::function<void(
-      Attribute *location, StringRef message, DiagnosticKind kind)>;
+      Location *location, StringRef message, DiagnosticKind kind)>;
 
   /// Register a diagnostic handler with this LLVM context.  The handler is
   /// passed location information if present (nullptr if not) along with a
@@ -71,7 +71,7 @@
   /// This emits an diagnostic using the registered issue handle if present, or
   /// with the default behavior if not.  The MLIR compiler should not generally
   /// interact with this, it should use methods on Operation instead.
-  void emitDiagnostic(Attribute *location, const Twine &message,
+  void emitDiagnostic(Location *location, const Twine &message,
                       DiagnosticKind kind) const;
 
 private:
diff --git a/include/mlir/IR/Operation.h b/include/mlir/IR/Operation.h
index d5b2b25..f5e3b17 100644
--- a/include/mlir/IR/Operation.h
+++ b/include/mlir/IR/Operation.h
@@ -27,6 +27,7 @@
 class Attribute;
 class AttributeListStorage;
 class AbstractOperation;
+class Location;
 template <typename OpType> class ConstOpPointer;
 template <typename OpType> class OpPointer;
 template <typename ObjectType, typename ElementType> class OperandIterator;
@@ -46,7 +47,7 @@
 /// this in a collection.
 struct OperationState {
   MLIRContext *const context;
-  Attribute *location;
+  Location *location;
   Identifier name;
   SmallVector<SSAValue *, 4> operands;
   /// Types of the results of this operation.
@@ -54,14 +55,14 @@
   SmallVector<NamedAttribute, 4> attributes;
 
 public:
-  OperationState(MLIRContext *context, Attribute *location, StringRef name)
+  OperationState(MLIRContext *context, Location *location, StringRef name)
       : context(context), location(location),
         name(Identifier::get(name, context)) {}
 
-  OperationState(MLIRContext *context, Attribute *location, Identifier name)
+  OperationState(MLIRContext *context, Location *location, Identifier name)
       : context(context), location(location), name(name) {}
 
-  OperationState(MLIRContext *context, Attribute *location, StringRef name,
+  OperationState(MLIRContext *context, Location *location, StringRef name,
                  ArrayRef<SSAValue *> operands, ArrayRef<Type *> types,
                  ArrayRef<NamedAttribute> attributes = {})
       : context(context), location(location),
@@ -92,9 +93,8 @@
   /// Return the context this operation is associated with.
   MLIRContext *getContext() const;
 
-  /// The source location the operation was defined or derived from.  Note that
-  /// it is possible for this pointer to be null.
-  Attribute *getLoc() const;
+  /// The source location the operation was defined or derived from.
+  Location *getLoc() const;
 
   /// Return the function this operation is defined in.  This has a verbose
   /// name to avoid name lookup ambiguities.
diff --git a/include/mlir/IR/Statement.h b/include/mlir/IR/Statement.h
index d6d16e3..55a0aec 100644
--- a/include/mlir/IR/Statement.h
+++ b/include/mlir/IR/Statement.h
@@ -29,7 +29,7 @@
 #include "llvm/ADT/ilist_node.h"
 
 namespace mlir {
-class Attribute;
+class Location;
 class MLFunction;
 class StmtBlock;
 class ForStmt;
@@ -52,9 +52,8 @@
   /// Return the context this operation is associated with.
   MLIRContext *getContext() const;
 
-  /// The source location the operation was defined or derived from.  Note that
-  /// it is possible for this pointer to be null.
-  Attribute *getLoc() const { return location; }
+  /// The source location the operation was defined or derived from.
+  Location *getLoc() const { return location; }
 
   /// Remove this statement from its block and delete it.
   void eraseFromBlock();
@@ -156,7 +155,10 @@
   void emitNote(const Twine &message) const;
 
 protected:
-  Statement(Kind kind, Attribute *location) : kind(kind), location(location) {}
+  Statement(Kind kind, Location *location) : kind(kind), location(location) {
+    assert(location && "location should never be null");
+  }
+
   // Statements are deleted through the destroy() member because this class
   // does not have a virtual destructor.
   ~Statement();
@@ -168,7 +170,7 @@
 
   /// This holds information about the source location the operation was defined
   /// or derived from.
-  Attribute *location;
+  Location *location;
 
   // allow ilist_traits access to 'block' field.
   friend struct llvm::ilist_traits<Statement>;
diff --git a/include/mlir/IR/Statements.h b/include/mlir/IR/Statements.h
index 1aa6581..c5af5d5 100644
--- a/include/mlir/IR/Statements.h
+++ b/include/mlir/IR/Statements.h
@@ -40,7 +40,7 @@
       private llvm::TrailingObjects<OperationStmt, StmtOperand, StmtResult> {
 public:
   /// Create a new OperationStmt with the specific fields.
-  static OperationStmt *create(Attribute *location, Identifier name,
+  static OperationStmt *create(Location *location, Identifier name,
                                ArrayRef<MLValue *> operands,
                                ArrayRef<Type *> resultTypes,
                                ArrayRef<NamedAttribute> attributes,
@@ -180,7 +180,7 @@
 private:
   const unsigned numOperands, numResults;
 
-  OperationStmt(Attribute *location, Identifier name, unsigned numOperands,
+  OperationStmt(Location *location, Identifier name, unsigned numOperands,
                 unsigned numResults, ArrayRef<NamedAttribute> attributes,
                 MLIRContext *context);
   ~OperationStmt();
@@ -198,7 +198,7 @@
 /// For statement represents an affine loop nest.
 class ForStmt : public Statement, public MLValue, public StmtBlock {
 public:
-  static ForStmt *create(Attribute *location, ArrayRef<MLValue *> lbOperands,
+  static ForStmt *create(Location *location, ArrayRef<MLValue *> lbOperands,
                          AffineMap *lbMap, ArrayRef<MLValue *> ubOperands,
                          AffineMap *ubMap, int64_t step, MLIRContext *context);
 
@@ -336,7 +336,7 @@
   // Operands for the lower and upper bounds.
   std::vector<StmtOperand> operands;
 
-  explicit ForStmt(Attribute *location, unsigned numOperands, AffineMap *lbMap,
+  explicit ForStmt(Location *location, unsigned numOperands, AffineMap *lbMap,
                    AffineMap *ubMap, int64_t step, MLIRContext *context);
 };
 
@@ -412,7 +412,7 @@
 /// If statement restricts execution to a subset of the loop iteration space.
 class IfStmt : public Statement {
 public:
-  explicit IfStmt(Attribute *location, IntegerSet *condition);
+  explicit IfStmt(Location *location, IntegerSet *condition);
   ~IfStmt();
 
   IfClause *getThen() const { return thenClause; }
diff --git a/lib/IR/Builders.cpp b/lib/IR/Builders.cpp
index 376d54e..8d0f223 100644
--- a/lib/IR/Builders.cpp
+++ b/lib/IR/Builders.cpp
@@ -20,6 +20,7 @@
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/IntegerSet.h"
+#include "mlir/IR/Location.h"
 #include "mlir/IR/Module.h"
 #include "mlir/IR/Types.h"
 using namespace mlir;
@@ -33,6 +34,21 @@
 Module *Builder::createModule() { return new Module(context); }
 
 //===----------------------------------------------------------------------===//
+// Locations.
+//===----------------------------------------------------------------------===//
+
+UnknownLoc *Builder::getUnknownLoc() { return UnknownLoc::get(context); }
+
+UniquedFilename Builder::getUniquedFilename(StringRef filename) {
+  return UniquedFilename::get(filename, context);
+}
+
+FileLineColLoc *Builder::getFileLineColLoc(UniquedFilename filename,
+                                           unsigned line, unsigned column) {
+  return FileLineColLoc::get(filename, line, column, context);
+}
+
+//===----------------------------------------------------------------------===//
 // Types.
 //===----------------------------------------------------------------------===//
 
@@ -227,7 +243,7 @@
   return op;
 }
 
-ForStmt *MLFuncBuilder::createFor(Attribute *location,
+ForStmt *MLFuncBuilder::createFor(Location *location,
                                   ArrayRef<MLValue *> lbOperands,
                                   AffineMap *lbMap,
                                   ArrayRef<MLValue *> ubOperands,
@@ -238,7 +254,7 @@
   return stmt;
 }
 
-IfStmt *MLFuncBuilder::createIf(Attribute *location, IntegerSet *condition) {
+IfStmt *MLFuncBuilder::createIf(Location *location, IntegerSet *condition) {
   auto *stmt = new IfStmt(location, condition);
   block->getStatements().insert(insertPoint, stmt);
   return stmt;
diff --git a/lib/IR/Instructions.cpp b/lib/IR/Instructions.cpp
index bd48783..90a5016 100644
--- a/lib/IR/Instructions.cpp
+++ b/lib/IR/Instructions.cpp
@@ -146,8 +146,8 @@
 // OperationInst
 //===----------------------------------------------------------------------===//
 
-/// Create a new OperationInst with the specific fields.
-OperationInst *OperationInst::create(Attribute *location, Identifier name,
+/// Create a new OperationInst with the specified fields.
+OperationInst *OperationInst::create(Location *location, Identifier name,
                                      ArrayRef<CFGValue *> operands,
                                      ArrayRef<Type *> resultTypes,
                                      ArrayRef<NamedAttribute> attributes,
@@ -186,7 +186,7 @@
                 getContext());
 }
 
-OperationInst::OperationInst(Attribute *location, Identifier name,
+OperationInst::OperationInst(Location *location, Identifier name,
                              unsigned numOperands, unsigned numResults,
                              ArrayRef<NamedAttribute> attributes,
                              MLIRContext *context)
@@ -281,7 +281,7 @@
 //===----------------------------------------------------------------------===//
 
 /// Create a new OperationInst with the specific fields.
-ReturnInst *ReturnInst::create(Attribute *location,
+ReturnInst *ReturnInst::create(Location *location,
                                ArrayRef<CFGValue *> operands) {
   auto byteSize = totalSizeToAlloc<InstOperand>(operands.size());
   void *rawMem = malloc(byteSize);
@@ -296,7 +296,7 @@
   return inst;
 }
 
-ReturnInst::ReturnInst(Attribute *location, unsigned numOperands)
+ReturnInst::ReturnInst(Location *location, unsigned numOperands)
     : TerminatorInst(Kind::Return, location), numOperands(numOperands) {}
 
 void ReturnInst::destroy() {
@@ -314,7 +314,7 @@
 // BranchInst
 //===----------------------------------------------------------------------===//
 
-BranchInst::BranchInst(Attribute *location, BasicBlock *dest,
+BranchInst::BranchInst(Location *location, BasicBlock *dest,
                        ArrayRef<CFGValue *> operands)
     : TerminatorInst(Kind::Branch, location), dest(this, dest) {
   addOperands(operands);
@@ -338,7 +338,7 @@
 // CondBranchInst
 //===----------------------------------------------------------------------===//
 
-CondBranchInst::CondBranchInst(Attribute *location, CFGValue *condition,
+CondBranchInst::CondBranchInst(Location *location, CFGValue *condition,
                                BasicBlock *trueDest, BasicBlock *falseDest)
     : TerminatorInst(Kind::CondBranch, location),
       condition(condition), dests{{this}, {this}}, numTrueOperands(0) {
diff --git a/lib/IR/MLIRContext.cpp b/lib/IR/MLIRContext.cpp
index 024e1b6..46d0103 100644
--- a/lib/IR/MLIRContext.cpp
+++ b/lib/IR/MLIRContext.cpp
@@ -23,6 +23,7 @@
 #include "mlir/IR/Function.h"
 #include "mlir/IR/Identifier.h"
 #include "mlir/IR/IntegerSet.h"
+#include "mlir/IR/Location.h"
 #include "mlir/IR/OperationSet.h"
 #include "mlir/IR/StandardOps.h"
 #include "mlir/IR/Types.h"
@@ -182,12 +183,26 @@
 /// This class is completely private to this file, so everything is public.
 class MLIRContextImpl {
 public:
-  /// We put immortal objects into this allocator.
-  llvm::BumpPtrAllocator allocator;
-
   /// This is the set of all operations that are registered with the system.
   OperationSet operationSet;
 
+  /// We put location info into this allocator, since it is generally not
+  /// touched by compiler passes.
+  llvm::BumpPtrAllocator locationAllocator;
+
+  /// The singleton for UnknownLoc.
+  UnknownLoc *theUnknownLoc = nullptr;
+
+  /// These are filename locations uniqued into this MLIRContext.
+  llvm::StringMap<char, llvm::BumpPtrAllocator &> filenames;
+
+  /// FileLineColLoc uniquing.
+  DenseMap<std::tuple<const char *, unsigned, unsigned>, FileLineColLoc *>
+      fileLineColLocs;
+
+  /// We put immortal objects into this allocator.
+  llvm::BumpPtrAllocator allocator;
+
   /// This is the handler to use to report diagnostics, or null if not
   /// registered.
   MLIRContext::DiagnosticHandlerTy diagnosticHandler;
@@ -258,7 +273,7 @@
   DenseMap<const Function *, FunctionAttr *> functionAttrs;
 
 public:
-  MLIRContextImpl() : identifiers(allocator) {
+  MLIRContextImpl() : filenames(locationAllocator), identifiers(allocator) {
     registerStandardOperations(operationSet);
   }
 
@@ -293,8 +308,7 @@
 /// This emits a diagnostic using the registered issue handle if present, or
 /// with the default behavior if not.  The MLIR compiler should not generally
 /// interact with this, it should use methods on Operation instead.
-void MLIRContext::emitDiagnostic(Attribute *location,
-                                 const llvm::Twine &message,
+void MLIRContext::emitDiagnostic(Location *location, const llvm::Twine &message,
                                  DiagnosticKind kind) const {
   // If we had a handler registered, emit the diagnostic using it.
   auto handler = getImpl().diagnosticHandler;
@@ -305,6 +319,8 @@
   if (kind != DiagnosticKind::Error)
     return;
 
+  // TODO(clattner): can improve this now!
+
   // The default behavior for errors is to emit them to stderr and exit.
   llvm::errs() << message.str() << "\n";
   llvm::errs().flush();
@@ -338,6 +354,39 @@
 }
 
 //===----------------------------------------------------------------------===//
+// Location uniquing
+//===----------------------------------------------------------------------===//
+
+UnknownLoc *UnknownLoc::get(MLIRContext *context) {
+  auto &impl = context->getImpl();
+  if (auto *result = impl.theUnknownLoc)
+    return result;
+
+  impl.theUnknownLoc = impl.allocator.Allocate<UnknownLoc>();
+  new (impl.theUnknownLoc) UnknownLoc();
+  return impl.theUnknownLoc;
+}
+
+UniquedFilename UniquedFilename::get(StringRef filename, MLIRContext *context) {
+  auto &impl = context->getImpl();
+  auto it = impl.filenames.insert({filename, char()}).first;
+  return UniquedFilename(it->getKeyData());
+}
+
+FileLineColLoc *FileLineColLoc::get(UniquedFilename filename, unsigned line,
+                                    unsigned column, MLIRContext *context) {
+  auto &impl = context->getImpl();
+  auto &entry =
+      impl.fileLineColLocs[std::make_tuple(filename.data(), line, column)];
+  if (!entry) {
+    entry = impl.allocator.Allocate<FileLineColLoc>();
+    new (entry) FileLineColLoc(filename, line, column);
+  }
+
+  return entry;
+}
+
+//===----------------------------------------------------------------------===//
 // Type uniquing
 //===----------------------------------------------------------------------===//
 
diff --git a/lib/IR/Operation.cpp b/lib/IR/Operation.cpp
index 71167bd..f5d07d5 100644
--- a/lib/IR/Operation.cpp
+++ b/lib/IR/Operation.cpp
@@ -46,7 +46,7 @@
 
 /// The source location the operation was defined or derived from.  Note that
 /// it is possible for this pointer to be null.
-Attribute *Operation::getLoc() const {
+Location *Operation::getLoc() const {
   if (auto *inst = dyn_cast<OperationInst>(this))
     return inst->getLoc();
   return cast<OperationStmt>(this)->getLoc();
diff --git a/lib/IR/Statement.cpp b/lib/IR/Statement.cpp
index 3746f71..3f95a94 100644
--- a/lib/IR/Statement.cpp
+++ b/lib/IR/Statement.cpp
@@ -209,7 +209,7 @@
 //===----------------------------------------------------------------------===//
 
 /// Create a new OperationStmt with the specific fields.
-OperationStmt *OperationStmt::create(Attribute *location, Identifier name,
+OperationStmt *OperationStmt::create(Location *location, Identifier name,
                                      ArrayRef<MLValue *> operands,
                                      ArrayRef<Type *> resultTypes,
                                      ArrayRef<NamedAttribute> attributes,
@@ -233,7 +233,7 @@
   return stmt;
 }
 
-OperationStmt::OperationStmt(Attribute *location, Identifier name,
+OperationStmt::OperationStmt(Location *location, Identifier name,
                              unsigned numOperands, unsigned numResults,
                              ArrayRef<NamedAttribute> attributes,
                              MLIRContext *context)
@@ -275,7 +275,7 @@
 // ForStmt
 //===----------------------------------------------------------------------===//
 
-ForStmt *ForStmt::create(Attribute *location, ArrayRef<MLValue *> lbOperands,
+ForStmt *ForStmt::create(Location *location, ArrayRef<MLValue *> lbOperands,
                          AffineMap *lbMap, ArrayRef<MLValue *> ubOperands,
                          AffineMap *ubMap, int64_t step, MLIRContext *context) {
   assert(lbOperands.size() == lbMap->getNumOperands() &&
@@ -297,7 +297,7 @@
   return stmt;
 }
 
-ForStmt::ForStmt(Attribute *location, unsigned numOperands, AffineMap *lbMap,
+ForStmt::ForStmt(Location *location, unsigned numOperands, AffineMap *lbMap,
                  AffineMap *ubMap, int64_t step, MLIRContext *context)
     : Statement(Kind::For, location),
       MLValue(MLValueKind::ForStmt, Type::getAffineInt(context)),
@@ -357,7 +357,7 @@
 // IfStmt
 //===----------------------------------------------------------------------===//
 
-IfStmt::IfStmt(Attribute *location, IntegerSet *condition)
+IfStmt::IfStmt(Location *location, IntegerSet *condition)
     : Statement(Kind::If, location), thenClause(new IfClause(this)),
       elseClause(nullptr), condition(condition) {}
 
diff --git a/lib/Parser/Parser.cpp b/lib/Parser/Parser.cpp
index 756f25d..ebeb196 100644
--- a/lib/Parser/Parser.cpp
+++ b/lib/Parser/Parser.cpp
@@ -25,6 +25,7 @@
 #include "mlir/IR/AffineMap.h"
 #include "mlir/IR/Attributes.h"
 #include "mlir/IR/Builders.h"
+#include "mlir/IR/Location.h"
 #include "mlir/IR/MLFunction.h"
 #include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Module.h"
@@ -43,6 +44,14 @@
 /// bool value.  Failure is "true" in a boolean context.
 enum ParseResult { ParseSuccess, ParseFailure };
 
+/// Return a uniqued filename for the main file the specified SourceMgr is
+/// looking at.
+static UniquedFilename getUniquedFilename(llvm::SourceMgr &sourceMgr,
+                                          MLIRContext *context) {
+  auto *buffer = sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID());
+  return UniquedFilename::get(buffer->getBufferIdentifier(), context);
+}
+
 namespace {
 class Parser;
 
@@ -54,6 +63,7 @@
   ParserState(llvm::SourceMgr &sourceMgr, Module *module,
               SMDiagnosticHandlerTy errorReporter)
       : context(module->getContext()), module(module),
+        filename(getUniquedFilename(sourceMgr, context)),
         lex(sourceMgr, errorReporter), curToken(lex.lexToken()),
         errorReporter(errorReporter), operationSet(OperationSet::get(context)) {
   }
@@ -81,6 +91,9 @@
   // This is the module we are parsing into.
   Module *const module;
 
+  /// The filename to use for location generation.
+  UniquedFilename filename;
+
   // The lexer for the source file we're parsing.
   Lexer lex;
 
@@ -122,7 +135,7 @@
 
   /// Encode the specified source location information into an attribute for
   /// attachment to the IR.
-  Attribute *getEncodedSourceLocation(llvm::SMLoc loc);
+  Location *getEncodedSourceLocation(llvm::SMLoc loc);
 
   /// Emit an error and return failure.
   ParseResult emitError(const Twine &message) {
@@ -209,16 +222,13 @@
 
 /// Encode the specified source location information into an attribute for
 /// attachment to the IR.
-Attribute *Parser::getEncodedSourceLocation(llvm::SMLoc loc) {
-  // TODO(clattner): Switch to an more structured form that includes
-  // file/line/column instead of just byte offset in the file.  This will
-  // eliminate this block of low level code poking at the SourceMgr directly.
+Location *Parser::getEncodedSourceLocation(llvm::SMLoc loc) {
   auto &sourceMgr = getSourceMgr();
-  auto fileID = sourceMgr.FindBufferContainingLoc(loc);
+  auto lineAndColumn =
+      sourceMgr.getLineAndColumn(loc, sourceMgr.getMainFileID());
 
-  auto *srcBuffer = sourceMgr.getMemoryBuffer(fileID);
-  unsigned locationEncoding = loc.getPointer() - srcBuffer->getBufferStart();
-  return builder.getIntegerAttr(locationEncoding);
+  return FileLineColLoc::get(state.filename, lineAndColumn.first,
+                             lineAndColumn.second, getContext());
 }
 
 ParseResult Parser::emitError(SMLoc loc, const Twine &message) {
@@ -1389,11 +1399,9 @@
   // We create these placeholders as having an empty name, which we know cannot
   // be created through normal user input, allowing us to distinguish them.
   auto name = Identifier::get("placeholder", getContext());
-  auto *inst =
-      // FIXME(clattner): encode the location into the placeholder instead of
-      // into the forwardReferencePlaceholders map!
-      OperationInst::create(/*location=*/nullptr, name, /*operands=*/{}, type,
-                            /*attrs=*/{}, getContext());
+  auto *inst = OperationInst::create(getEncodedSourceLocation(loc), name,
+                                     /*operands=*/{}, type,
+                                     /*attributes=*/{}, getContext());
   forwardReferencePlaceholders[inst->getResult(0)] = loc;
   return inst->getResult(0);
 }
@@ -3038,11 +3046,8 @@
   auto existingContextHandler = context->getDiagnosticHandler();
 
   // Install a new handler that uses the error reporter.
-  context->registerDiagnosticHandler([&](Attribute *location, StringRef message,
+  context->registerDiagnosticHandler([&](Location *location, StringRef message,
                                          MLIRContext::DiagnosticKind kind) {
-    auto offset = cast<IntegerAttr>(location)->getValue();
-    auto *mainBuffer = sourceMgr.getMemoryBuffer(sourceMgr.getMainFileID());
-    auto ptr = mainBuffer->getBufferStart() + offset;
     SourceMgr::DiagKind diagKind;
     switch (kind) {
     case MLIRContext::DiagnosticKind::Error:
@@ -3055,8 +3060,20 @@
       diagKind = SourceMgr::DK_Note;
       break;
     }
-    errorReporter(
-        sourceMgr.GetMessage(SMLoc::getFromPointer(ptr), diagKind, message));
+
+    StringRef filename;
+    unsigned line = 0, column = 0;
+    if (auto fileLoc = dyn_cast<FileLineColLoc>(location)) {
+      filename = fileLoc->getFilename();
+      line = fileLoc->getLine();
+      column = fileLoc->getColumn();
+    }
+
+    auto diag = llvm::SMDiagnostic(sourceMgr, SMLoc(), filename, line, column,
+                                   diagKind, message, /*LineStr=*/StringRef(),
+                                   /*Ranges=*/{}, /*FixIts=*/{});
+
+    errorReporter(diag);
   });
 
   // This is the result module we are parsing into.