Misc. preparations for multi-core support.

• Fix xdot[false].
• Basic operators in RT backend.
• CCP propagate dynamic constant constants.
• Add some debugging utility to hercules_rt.
• Add sub-edits to Forkify, ForkChunk, and ForkSplit.
• Return new fork-join node IDs from ForkSplit, and label those nodes in the pass manager.
• New fork-join test to be used in the future for developing multicore support.

hercules_cg/src/rt.rs

@@ -407,6 +407,78 @@ impl<'a> RTContext<'a> {
                     write!(block, ");\n")?;
                 }
             }
+            Node::Unary { op, input } => {
+                let block = &mut blocks.get_mut(&self.bbs.0[id.idx()]).unwrap();
+                match op {
+                    UnaryOperator::Not => write!(
+                        block,
+                        "                {} = !{};\n",
+                        self.get_value(id),
+                        self.get_value(input)
+                    )?,
+                    UnaryOperator::Neg => write!(
+                        block,
+                        "                {} = -{};\n",
+                        self.get_value(id),
+                        self.get_value(input)
+                    )?,
+                    UnaryOperator::Cast(ty) => write!(
+                        block,
+                        "                {} = {} as {};\n",
+                        self.get_value(id),
+                        self.get_value(input),
+                        self.get_type(ty)
+                    )?,
+                };
+            }
+            Node::Binary { op, left, right } => {
+                let block = &mut blocks.get_mut(&self.bbs.0[id.idx()]).unwrap();
+                let op = match op {
+                    BinaryOperator::Add => "+",
+                    BinaryOperator::Sub => "-",
+                    BinaryOperator::Mul => "*",
+                    BinaryOperator::Div => "/",
+                    BinaryOperator::Rem => "%",
+                    BinaryOperator::LT => "<",
+                    BinaryOperator::LTE => "<=",
+                    BinaryOperator::GT => ">",
+                    BinaryOperator::GTE => ">=",
+                    BinaryOperator::EQ => "==",
+                    BinaryOperator::NE => "!=",
+                    BinaryOperator::Or => "|",
+                    BinaryOperator::And => "&",
+                    BinaryOperator::Xor => "^",
+                    BinaryOperator::LSh => "<<",
+                    BinaryOperator::RSh => ">>",
+                };
+
+                write!(
+                    block,
+                    "                {} = {} {} {};\n",
+                    self.get_value(id),
+                    self.get_value(left),
+                    op,
+                    self.get_value(right)
+                )?;
+            }
+            Node::Ternary {
+                op,
+                first,
+                second,
+                third,
+            } => {
+                let block = &mut blocks.get_mut(&self.bbs.0[id.idx()]).unwrap();
+                match op {
+                    TernaryOperator::Select => write!(
+                        block,
+                        "                {} = if {} {{ {} }} else {{ {} }};\n",
+                        self.get_value(id),
+                        self.get_value(first),
+                        self.get_value(second),
+                        self.get_value(third),
+                    )?,
+                };
+            }
             Node::Read {
                 collect,
                 ref indices,