Simplify operand types

ptx/src/ast.rs

@@ -614,15 +614,12 @@ pub struct CallInst<P: ArgParams> {
     pub uniform: bool,
     pub ret_params: Vec<P::Id>,
     pub func: P::Id,
-    pub param_list: Vec<P::SrcOperand>,
+    pub param_list: Vec<P::Operand>,
 }
 
 pub trait ArgParams {
     type Id;
-    type DstOperand;
+    type Operand;
-    type SrcOperand;
-    type DstOperandVec;
-    type SrcOperandVec;
 }
 
 pub struct ParsedArgParams<'a> {
@@ -631,10 +628,7 @@ pub struct ParsedArgParams<'a> {
 
 impl<'a> ArgParams for ParsedArgParams<'a> {
     type Id = &'a str;
-    type DstOperand = DstOperand<&'a str>;
+    type Operand = Operand<&'a str>;
-    type SrcOperand = SrcOperand<&'a str>;
-    type DstOperandVec = DstOperandVec<&'a str>;
-    type SrcOperandVec = SrcOperandVec<&'a str>;
 }
 
 pub struct Arg1<P: ArgParams> {
@@ -642,54 +636,54 @@ pub struct Arg1<P: ArgParams> {
 }
 
 pub struct Arg1Bar<P: ArgParams> {
-    pub src: P::SrcOperand,
+    pub src: P::Operand,
 }
 
 pub struct Arg2<P: ArgParams> {
-    pub dst: P::DstOperand,
+    pub dst: P::Operand,
-    pub src: P::SrcOperand,
+    pub src: P::Operand,
 }
 pub struct Arg2Ld<P: ArgParams> {
-    pub dst: P::DstOperandVec,
+    pub dst: P::Operand,
-    pub src: P::SrcOperand,
+    pub src: P::Operand,
 }
 
 pub struct Arg2St<P: ArgParams> {
-    pub src1: P::SrcOperand,
+    pub src1: P::Operand,
-    pub src2: P::SrcOperandVec,
+    pub src2: P::Operand,
 }
 
 pub struct Arg2Mov<P: ArgParams> {
-    pub dst: P::DstOperandVec,
+    pub dst: P::Operand,
-    pub src: P::SrcOperandVec,
+    pub src: P::Operand,
 }
 
 pub struct Arg3<P: ArgParams> {
-    pub dst: P::DstOperand,
+    pub dst: P::Operand,
-    pub src1: P::SrcOperand,
+    pub src1: P::Operand,
-    pub src2: P::SrcOperand,
+    pub src2: P::Operand,
 }
 
 pub struct Arg4<P: ArgParams> {
-    pub dst: P::DstOperand,
+    pub dst: P::Operand,
-    pub src1: P::SrcOperand,
+    pub src1: P::Operand,
-    pub src2: P::SrcOperand,
+    pub src2: P::Operand,
-    pub src3: P::SrcOperand,
+    pub src3: P::Operand,
 }
 
 pub struct Arg4Setp<P: ArgParams> {
     pub dst1: P::Id,
     pub dst2: Option<P::Id>,
-    pub src1: P::SrcOperand,
+    pub src1: P::Operand,
-    pub src2: P::SrcOperand,
+    pub src2: P::Operand,
 }
 
 pub struct Arg5Setp<P: ArgParams> {
     pub dst1: P::Id,
     pub dst2: Option<P::Id>,
-    pub src1: P::SrcOperand,
+    pub src1: P::Operand,
-    pub src2: P::SrcOperand,
+    pub src2: P::Operand,
-    pub src3: P::SrcOperand,
+    pub src3: P::Operand,
 }
 
 #[derive(Copy, Clone)]
@@ -700,30 +694,13 @@ pub enum ImmediateValue {
     F64(f64),
 }
 
-#[derive(Copy, Clone)]
-pub enum DstOperand<ID> {
-    Reg(ID),
-    VecMember(ID, u8),
-}
-
 #[derive(Clone)]
-pub enum DstOperandVec<Id> {
+pub enum Operand<Id> {
-    Normal(DstOperand<Id>),
-    Vector(Vec<Id>),
-}
-
-#[derive(Copy, Clone)]
-pub enum SrcOperand<Id> {
     Reg(Id),
     RegOffset(Id, i32),
     Imm(ImmediateValue),
     VecMember(Id, u8),
-}
+    VecPack(Vec<Id>),
-
-#[derive(Clone)]
-pub enum SrcOperandVec<Id> {
-    Normal(SrcOperand<Id>),
-    Vector(Vec<Id>),
 }
 
 pub enum VectorPrefix {

ptx/src/ptx.lalrpop

@@ -1177,7 +1177,7 @@ InstSt: ast::Instruction<ast::ParsedArgParams<'input>> = {
 };
 
 // https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#using-addresses-arrays-and-vectors
-MemoryOperand: ast::SrcOperand<&'input str> = {
+MemoryOperand: ast::Operand<&'input str> = {
     "[" <o:Operand> "]" => o
 }
 
@@ -1734,15 +1734,15 @@ ArithFloatMustRound: ast::ArithFloat = {
     },
 }
 
-Operand: ast::SrcOperand<&'input str> = {
+Operand: ast::Operand<&'input str> = {
-    <r:ExtendedID> => ast::SrcOperand::Reg(r),
+    <r:ExtendedID> => ast::Operand::Reg(r),
-    <r:ExtendedID> "+" <offset:S32Num> => ast::SrcOperand::RegOffset(r, offset),
+    <r:ExtendedID> "+" <offset:S32Num> => ast::Operand::RegOffset(r, offset),
-    <x:ImmediateValue> => ast::SrcOperand::Imm(x)
+    <x:ImmediateValue> => ast::Operand::Imm(x)
 };
 
-CallOperand: ast::SrcOperand<&'input str> = {
+CallOperand: ast::Operand<&'input str> = {
-    <r:ExtendedID> => ast::SrcOperand::Reg(r),
+    <r:ExtendedID> => ast::Operand::Reg(r),
-    <x:ImmediateValue> => ast::SrcOperand::Imm(x)
+    <x:ImmediateValue> => ast::Operand::Imm(x)
 };
 
 // TODO: start parsing whole constants sub-language:
@@ -1838,44 +1838,44 @@ Arg5Setp: ast::Arg5Setp<ast::ParsedArgParams<'input>> = {
     <dst1:ExtendedID> <dst2:OptionalDst?> "," <src1:Operand> "," <src2:Operand> "," "!"? <src3:Operand> => ast::Arg5Setp{<>}
 };
 
-ArgCall: (Vec<&'input str>, &'input str, Vec<ast::SrcOperand<&'input str>>) = {
+ArgCall: (Vec<&'input str>, &'input str, Vec<ast::Operand<&'input str>>) = {
     "(" <ret_params:Comma<ExtendedID>> ")" "," <func:ExtendedID> "," "(" <param_list:Comma<CallOperand>> ")" => {
         (ret_params, func, param_list)
     },
     <func:ExtendedID> "," "(" <param_list:Comma<CallOperand>> ")" => (Vec::new(), func, param_list),
-    <func:ExtendedID> => (Vec::new(), func, Vec::<ast::SrcOperand<_>>::new()),
+    <func:ExtendedID> => (Vec::new(), func, Vec::<ast::Operand<_>>::new()),
 };
 
 OptionalDst: &'input str = {
     "|" <dst2:ExtendedID> => dst2
 }
 
-SrcOperand: ast::SrcOperand<&'input str> = {
+SrcOperand: ast::Operand<&'input str> = {
-    <r:ExtendedID> => ast::SrcOperand::Reg(r),
+    <r:ExtendedID> => ast::Operand::Reg(r),
-    <r:ExtendedID> "+" <offset:S32Num> => ast::SrcOperand::RegOffset(r, offset),
+    <r:ExtendedID> "+" <offset:S32Num> => ast::Operand::RegOffset(r, offset),
-    <x:ImmediateValue> => ast::SrcOperand::Imm(x),
+    <x:ImmediateValue> => ast::Operand::Imm(x),
     <mem_op:MemberOperand> => {
         let (reg, idx) = mem_op;
-        ast::SrcOperand::VecMember(reg, idx)
+        ast::Operand::VecMember(reg, idx)
     }
 }
 
-SrcOperandVec: ast::SrcOperandVec<&'input str> = {
+SrcOperandVec: ast::Operand<&'input str> = {
-    <normal:SrcOperand> => ast::SrcOperandVec::Normal(normal),
+    <normal:SrcOperand> => normal,
-    <vec:VectorExtract> => ast::SrcOperandVec::Vector(vec),
+    <vec:VectorExtract> => ast::Operand::VecPack(vec),
 }
 
-DstOperand: ast::DstOperand<&'input str> = {
+DstOperand: ast::Operand<&'input str> = {
-    <r:ExtendedID> => ast::DstOperand::Reg(r),
+    <r:ExtendedID> => ast::Operand::Reg(r),
     <mem_op:MemberOperand> => {
         let (reg, idx) = mem_op;
-        ast::DstOperand::VecMember(reg, idx)
+        ast::Operand::VecMember(reg, idx)
     }
 }
 
-DstOperandVec: ast::DstOperandVec<&'input str> = {
+DstOperandVec: ast::Operand<&'input str> = {
-    <normal:DstOperand> => ast::DstOperandVec::Normal(normal),
+    <normal:DstOperand> => normal,
-    <vec:VectorExtract> => ast::DstOperandVec::Vector(vec),
+    <vec:VectorExtract> => ast::Operand::VecPack(vec),
 }
 
 VectorPrefix: u8 = {