Move entry_block() into Layout.

The single entry block in a function is simply the first block in the layout.

Remove the 'entry' keyword from the textual IL, the lexer and parser.

src/libcretonne/cfg.rs

@@ -104,11 +104,8 @@ impl ControlFlowGraph {
         &self.data[ebb].successors
     }
 
-    pub fn postorder_ebbs(&self) -> Vec<Ebb> {
-        if self.len() < 1 {
-            return Vec::new();
-        }
-        let mut stack_a = vec![Ebb::with_number(0).unwrap()];
+    pub fn postorder_ebbs(&self, entry: Ebb) -> Vec<Ebb> {
+        let mut stack_a = vec![entry];
         let mut stack_b = Vec::new();
         while stack_a.len() > 0 {
             let cur = stack_a.pop().unwrap();
@@ -282,7 +279,7 @@ mod tests {
         func.layout.append_inst(jmp_ebb2_ebb5, ebb2);
 
         let cfg = ControlFlowGraph::new(&func);
-        assert_eq!(cfg.postorder_ebbs(),
+        assert_eq!(cfg.postorder_ebbs(func.layout.entry_block().unwrap()),
                    vec![ebb0, ebb2, ebb5, ebb4, ebb1, ebb3]);
     }
 
@@ -309,6 +306,7 @@ mod tests {
         func.layout.append_inst(jmp_ebb2_ebb3, ebb2);
 
         let cfg = ControlFlowGraph::new(&func);
-        assert_eq!(cfg.postorder_ebbs(), vec![ebb0, ebb1, ebb2, ebb3]);
+        assert_eq!(cfg.postorder_ebbs(func.layout.entry_block().unwrap()),
+                   vec![ebb0, ebb1, ebb2, ebb3]);
     }
 }

src/libcretonne/ir/layout.rs

@@ -108,6 +108,12 @@ impl Layout {
             next: self.first_ebb,
         }
     }
+
+    /// Get the function's entry block.
+    /// This is simply the first EBB in the layout order.
+    pub fn entry_block(&self) -> Option<Ebb> {
+        self.first_ebb
+    }
 }
 
 #[derive(Clone, Debug, Default)]
@@ -414,8 +420,11 @@ mod tests {
         let e0 = Ebb::new(0);
         let e1 = Ebb::new(1);
 
+        assert_eq!(layout.entry_block(), None);
         layout.append_ebb(e0);
+        assert_eq!(layout.entry_block(), Some(e0));
         layout.append_ebb(e1);
+        assert_eq!(layout.entry_block(), Some(e0));
 
         let i0 = Inst::new(0);
         let i1 = Inst::new(1);

src/libcretonne/ir/mod.rs

@@ -10,7 +10,7 @@ pub mod layout;
 
 use ir::types::{FunctionName, Signature};
 use entity_map::EntityRef;
-use ir::entities::{Ebb, NO_EBB, StackSlot};
+use ir::entities::StackSlot;
 use ir::dfg::DataFlowGraph;
 use ir::layout::Layout;
 use std::fmt::{self, Debug, Display, Formatter};
@@ -24,9 +24,6 @@ pub struct Function {
     /// Signature of this function.
     signature: Signature,
 
-    /// The entry block.
-    pub entry_block: Ebb,
-
     /// Stack slots allocated in this function.
     stack_slots: Vec<StackSlotData>,
 
@@ -43,7 +40,6 @@ impl Function {
         Function {
             name: name,
             signature: sig,
-            entry_block: NO_EBB,
             stack_slots: Vec::new(),
             dfg: DataFlowGraph::new(),
             layout: Layout::new(),

src/libreader/lexer.rs

@@ -32,7 +32,6 @@ pub enum Token<'a> {
     Equal, // '='
     Arrow, // '->'
     Function, // 'function'
-    Entry, // 'entry'
     Float(&'a str), // Floating point immediate
     Integer(&'a str), // Integer immediate
     Type(types::Type), // i32, f32, b32x4, ...
@@ -270,7 +269,6 @@ impl<'a> Lexer<'a> {
     fn keyword(text: &str) -> Option<Token<'a>> {
         match text {
             "function" => Some(Token::Function),
-            "entry" => Some(Token::Entry),
             _ => None,
         }
     }
@@ -444,7 +442,7 @@ mod tests {
 
     #[test]
     fn lex_identifiers() {
-        let mut lex = Lexer::new("v0 v00 vx01 ebb1234567890 ebb5234567890 entry v1x vx1 vxvx4 \
+        let mut lex = Lexer::new("v0 v00 vx01 ebb1234567890 ebb5234567890 v1x vx1 vxvx4 \
                                   function0 function b1 i32x4 f32x5");
         assert_eq!(lex.next(),
                    token(Token::Value(Value::direct_with_number(0).unwrap()), 1));
@@ -453,7 +451,6 @@ mod tests {
         assert_eq!(lex.next(),
                    token(Token::Ebb(Ebb::with_number(1234567890).unwrap()), 1));
         assert_eq!(lex.next(), token(Token::Identifier("ebb5234567890"), 1));
-        assert_eq!(lex.next(), token(Token::Entry, 1));
         assert_eq!(lex.next(), token(Token::Identifier("v1x"), 1));
         assert_eq!(lex.next(),
                    token(Token::Value(Value::table_with_number(1).unwrap()), 1));

src/libreader/parser.rs

@@ -15,7 +15,7 @@ use cretonne::ir::types::{Type, VOID, FunctionName, Signature, ArgumentType, Arg
 use cretonne::ir::immediates::{Imm64, Ieee32, Ieee64};
 use cretonne::ir::entities::*;
 use cretonne::ir::instructions::{Opcode, InstructionFormat, InstructionData, VariableArgs,
-                                   JumpData, BranchData, ReturnData};
+                                 JumpData, BranchData, ReturnData};
 use cretonne::ir::{Function, StackSlotData};
 
 pub use lexer::Location;
@@ -578,22 +578,14 @@ impl<'a> Parser<'a> {
     // Parse an extended basic block, add contents to `ctx`.
     //
     // extended-basic-block ::= * ebb-header { instruction }
-    // ebb-header           ::= ["entry"] Ebb(ebb) [ebb-args] ":"
+    // ebb-header           ::= Ebb(ebb) [ebb-args] ":"
     //
     fn parse_extended_basic_block(&mut self, ctx: &mut Context) -> Result<()> {
-        let is_entry = self.optional(Token::Entry);
         let ebb_num = try!(self.match_ebb("expected EBB header"));
         let ebb = try!(ctx.add_ebb(ebb_num, &self.loc));
 
-        if is_entry {
-            if ctx.function.entry_block != NO_EBB {
-                return err!(self.loc, "multiple entry blocks in function");
-            }
-            ctx.function.entry_block = ebb;
-        }
-
         if !self.optional(Token::Colon) {
-            // ebb-header ::= ["entry"] Ebb(ebb) [ * ebb-args ] ":"
+            // ebb-header ::= Ebb(ebb) [ * ebb-args ] ":"
             try!(self.parse_ebb_args(ctx, ebb));
             try!(self.match_token(Token::Colon, "expected ':' after EBB arguments"));
         }