[llvm-commits] [llvm] r93535 - /llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp

[Chris Lattner]

Author: lattner
Date: Fri Jan 15 13:33:43 2010
New Revision: 93535

URL: http://llvm.org/viewvc/llvm-project?rev=93535&view=rev
Log:
add range information for mem X86Operand's, now all
X86Operand's have range info.

Modified:
    llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp

Modified: llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp?rev=93535&r1=93534&r2=93535&view=diff

==============================================================================
--- llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp (original)
+++ llvm/trunk/lib/Target/X86/AsmParser/X86AsmParser.cpp Fri Jan 15 13:33:43 2010
@@ -106,7 +106,7 @@
     } Mem;
   };
 
-  X86Operand(KindTy K, SMLoc Start = SMLoc(), SMLoc End = SMLoc())
+  X86Operand(KindTy K, SMLoc Start, SMLoc End)
     : Kind(K), StartLoc(Start), EndLoc(End) {}
   
   /// getStartLoc - Get the location of the first token of this operand.
@@ -222,14 +222,14 @@
 
   static X86Operand *CreateMem(unsigned SegReg, const MCExpr *Disp,
                                unsigned BaseReg, unsigned IndexReg,
-                               unsigned Scale) {
+                               unsigned Scale, SMLoc StartLoc, SMLoc EndLoc) {
     // We should never just have a displacement, that would be an immediate.
     assert((SegReg || BaseReg || IndexReg) && "Invalid memory operand!");
 
     // The scale should always be one of {1,2,4,8}.
     assert(((Scale == 1 || Scale == 2 || Scale == 4 || Scale == 8)) &&
            "Invalid scale!");
-    X86Operand *Res = new X86Operand(Memory);
+    X86Operand *Res = new X86Operand(Memory, StartLoc, EndLoc);
     Res->Mem.SegReg   = SegReg;
     Res->Mem.Disp     = Disp;
     Res->Mem.BaseReg  = BaseReg;
@@ -291,6 +291,8 @@
 
 /// ParseMemOperand: segment: disp(basereg, indexreg, scale)
 X86Operand *X86ATTAsmParser::ParseMemOperand() {
+  SMLoc MemStart = getLexer().getTok().getLoc();
+  
   // FIXME: If SegReg ':'  (e.g. %gs:), eat and remember.
   unsigned SegReg = 0;
   
@@ -301,7 +303,7 @@
   const MCExpr *Disp = MCConstantExpr::Create(0, getParser().getContext());
   if (getLexer().isNot(AsmToken::LParen)) {
     SMLoc ExprStart, ExprEnd;
-    if (getParser().ParseExpression(Disp, ExprStart, ExprEnd)) return 0;
+    if (getParser().ParseExpression(Disp, MemStart, ExprEnd)) return 0;
     
     // After parsing the base expression we could either have a parenthesized
     // memory address or not.  If not, return now.  If so, eat the (.
@@ -309,7 +311,7 @@
       // Unless we have a segment register, treat this as an immediate.
       if (SegReg == 0)
         return X86Operand::CreateImm(Disp, ExprStart, ExprEnd);
-      return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1);
+      return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, MemStart, ExprEnd);
     }
     
     // Eat the '('.
@@ -336,7 +338,7 @@
         // Unless we have a segment register, treat this as an immediate.
         if (SegReg == 0)
           return X86Operand::CreateImm(Disp, LParenLoc, ExprEnd);
-        return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1);
+        return X86Operand::CreateMem(SegReg, Disp, 0, 0, 1, MemStart, ExprEnd);
       }
       
       // Eat the '('.
@@ -410,9 +412,11 @@
     Error(getLexer().getTok().getLoc(), "unexpected token in memory operand");
     return 0;
   }
+  SMLoc MemEnd = getLexer().getTok().getLoc();
   getLexer().Lex(); // Eat the ')'.
   
-  return X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale);
+  return X86Operand::CreateMem(SegReg, Disp, BaseReg, IndexReg, Scale,
+                               MemStart, MemEnd);
 }
 
 bool X86ATTAsmParser::