cilkcc: Fix bug. Add examples

cilkcc/examples/e_counter.c

@@ -0,0 +1,12 @@
+#include "assert.h"
+
+int main() {
+  char *s = "the quick brown fox jumps over the lazy dog", *p = s;
+  int i = 0;
+  while (*p != 0) {
+    if (*p == 'e') i += 1;
+    p += 1;
+  }
+  assert(i == 3);
+  return 0;
+}

cilkcc/examples/strstr.c

@@ -0,0 +1,19 @@
+#include "assert.h"
+
+int find(char *s, char *q) {
+  int s_i = 0, q_i = 0;
+  while (s[s_i] != 0) {
+    if (q[q_i] == 0) return s_i-q_i;
+    if (s[s_i] == q[q_i]) q_i += 1;
+    else if (q_i > 0) q_i = 0;
+    s_i += 1;
+  }
+  return 0 - 1;
+}
+
+int main() {
+  char *s = "the quick brown fox jumps over the lazy dog";
+  int p = find(s, "brown");
+  assert(p == 10);
+  return 0;
+}

cilkcc/src/codegen.rs

@@ -201,6 +201,10 @@ impl<'a> FunctionCodeGenerator<'a> {
                 Ok((Value::new_imm_int32(*n as i32), Type::Int(Sign::Signed)))
             }
             ast::Kind::String(s) => self.generate_string(s),
+            ast::Kind::Char(c) => Ok((
+                Value::new_imm_int32(*c as u8 as i32),
+                Type::Int(Sign::Signed),
+            )),
             ast::Kind::ConstArray(ty, elems) => self.generate_const_array(ty, elems),
             ast::Kind::FieldRef(val, name) => self.generate_field_ref(val, name),
             ast::Kind::VariableDecl(ty, name, sclass, val) => {
@@ -587,6 +591,10 @@ impl<'a> FunctionCodeGenerator<'a> {
                 self.builder.build_icmp(ICmpKind::Eq, lhs, rhs),
                 Type::Int(Sign::Signed),
             )),
+            ast::BinaryOp::Ne => Ok((
+                self.builder.build_icmp(ICmpKind::Ne, lhs, rhs),
+                Type::Int(Sign::Signed),
+            )),
             ast::BinaryOp::Le => Ok((
                 self.builder.build_icmp(ICmpKind::Le, lhs, rhs),
                 Type::Int(Sign::Signed),

cilkcc/src/parser.rs

@@ -942,7 +942,7 @@ impl<'a> Parser<'a> {
         let mut lhs = self.read_relation()?;
         loop {
             if lexer!(self, skip_symbol(Symbol::Eq)) {
-                let rhs = self.read_primary()?;
+                let rhs = self.read_relation()?;
                 lhs = AST::new(
                     ast::Kind::BinaryOp(ast::BinaryOp::Eq, Box::new(lhs), Box::new(rhs)),
                     self.lexer.loc(),

src/codegen/common/machine/branch_folding.rs

@@ -212,6 +212,7 @@ impl BranchFolding {
                 }
 
                 if inst.opcode.is_conditional_jmp() {
+                    println!("{:?}", inst);
                     let dst = inst.get_jmp_dst().unwrap();
                     // If we jump to the next block conditionally, flip the jump condition.
                     if i + 1 < order.len() && dst == order[i + 1] {

src/codegen/x64/machine/inst.rs

@@ -75,6 +75,7 @@ impl MachineOpcode {
     pub fn flip_conditional_jmp(&self) -> Option<Self> {
         match self {
             MachineOpcode::JE => Some(Self::JNE),
+            MachineOpcode::JNE => Some(Self::JE),
             MachineOpcode::JL => Some(Self::JGE),
             MachineOpcode::JLE => Some(Self::JG),
             MachineOpcode::JG => Some(Self::JLE),
@@ -97,6 +98,7 @@ impl MachineInst {
         match self.opcode {
             MachineOpcode::JMP
             | MachineOpcode::JE
+            | MachineOpcode::JNE
             | MachineOpcode::JL
             | MachineOpcode::JLE
             | MachineOpcode::JG