(
pair: Pair<'_, Rule>,
values: &mut PrimaryMap<Value, ValueData>,
groups: &mut PrimaryMap<ValueGroup, Vec<Value>>,
)
| 83 | } |
| 84 | |
| 85 | fn parse_value_declaration( |
| 86 | pair: Pair<'_, Rule>, |
| 87 | values: &mut PrimaryMap<Value, ValueData>, |
| 88 | groups: &mut PrimaryMap<ValueGroup, Vec<Value>>, |
| 89 | ) -> Result<()> { |
| 90 | let span = pair.as_span(); |
| 91 | let mut bank = None; |
| 92 | let mut remat = None; |
| 93 | let mut indirect_remat = None; |
| 94 | for pair in pair.into_inner() { |
| 95 | match pair.as_rule() { |
| 96 | Rule::value => { |
| 97 | parse_expected_entity(pair, values.next_key())?; |
| 98 | } |
| 99 | Rule::regbank => { |
| 100 | if bank.is_some() { |
| 101 | Err(custom_error(pair.as_span(), "duplicate attribute"))?; |
| 102 | } |
| 103 | bank = Some(parse_entity(pair)?); |
| 104 | } |
| 105 | Rule::remat => { |
| 106 | if remat.is_some() { |
| 107 | Err(custom_error(pair.as_span(), "duplicate attribute"))?; |
| 108 | } |
| 109 | let [cost, class] = extract(pair, [Rule::remat_cost, Rule::regclass]); |
| 110 | let cost = match cost.as_str() { |
| 111 | "cheaper_than_move" => RematCost::CheaperThanMove, |
| 112 | "cheaper_than_load" => RematCost::CheaperThanLoad, |
| 113 | _ => unreachable!(), |
| 114 | }; |
| 115 | let class = parse_entity(class)?; |
| 116 | remat = Some((cost, class)); |
| 117 | } |
| 118 | Rule::indirect_remat => { |
| 119 | if indirect_remat.is_some() { |
| 120 | Err(custom_error(pair.as_span(), "duplicate attribute"))?; |
| 121 | } |
| 122 | |
| 123 | let mut inner = pair.into_inner(); |
| 124 | let constraint = inner.next().unwrap(); |
| 125 | assert_eq!(constraint.as_rule(), Rule::constraint); |
| 126 | let constraint = parse_constraint(constraint)?; |
| 127 | |
| 128 | let mut inputs = inner.next().unwrap(); |
| 129 | let allow_destination_overlap = inputs.as_rule() != Rule::indirect_remat_no_overlap; |
| 130 | if !allow_destination_overlap { |
| 131 | inputs = inner.next().unwrap(); |
| 132 | }; |
| 133 | |
| 134 | assert_eq!(inputs.as_rule(), Rule::indirect_remat_input_list); |
| 135 | assert!(inner.next().is_none()); |
| 136 | let mut parsed_inputs: Vec<Operand> = vec![]; |
| 137 | for input in inputs.into_inner() { |
| 138 | parsed_inputs.push(parse_operand(input, groups)?); |
| 139 | } |
| 140 | |
| 141 | indirect_remat = Some(IndirectRematData { |
| 142 | constraint, |
no test coverage detected