WARNING! Access to this system is limited to authorised users only.
Unauthorised users may be subject to prosecution.
Unauthorised access to this system is a criminal offence under Australian law (Federal Crimes Act 1914 Part VIA)
It is a criminal offence to:
(1) Obtain access to data without authority. -Penalty 2 years imprisonment.
(2) Damage, delete, alter or insert data without authority. -Penalty 10 years imprisonment.
User activity is monitored and recorded. Anyone using this system expressly consents to such monitoring and recording.

To protect your data, the CISO officer has suggested users to enable 2FA as soon as possible.
Currently 2.7% of users enabled 2FA.

Commit c0089a9f authored by Isaac Oscar Gariano's avatar Isaac Oscar Gariano
Browse files

Forgot to push a file...

parent a428732b
// Copyright 2017 The Australian National University
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#![allow(dead_code)]
use compiler::CompilerPass;
use ast::ir::*;
use vm::VM;
use std::any::Any;
use std::path;
use std::io::prelude::*;
use std::fs::File;
pub const EMIT_MUIR : bool = true;
pub fn create_emit_directory(vm: &VM) {
use std::fs;
match fs::create_dir(&vm.vm_options.flag_aot_emit_dir) {
Ok(_) => {},
Err(_) => {}
}
}
fn create_emit_file(name: String, vm: &VM) -> File {
let mut file_path = path::PathBuf::new();
file_path.push(&vm.vm_options.flag_aot_emit_dir);
file_path.push(name);
match File::create(file_path.as_path()) {
Err(why) => panic!("couldn't create emit file {}: {}", file_path.to_str().unwrap(), why),
Ok(file) => file
}
}
pub struct DotGen {
name: &'static str,
suffix: &'static str,
}
impl DotGen {
pub fn new(suffix: &'static str) -> DotGen {
DotGen {
name: "DotGen",
suffix: suffix,
}
}
}
#[allow(dead_code)]
fn emit_muir(suffix: &str, func: &MuFunctionVersion, vm: &VM) {
let func_name = func.name();
// create emit directory
create_emit_directory(vm);
let mut file_path = path::PathBuf::new();
file_path.push(&vm.vm_options.flag_aot_emit_dir);
file_path.push(func_name.clone() + suffix + ".muir");
let mut file = match File::create(file_path.as_path()) {
Err(why) => panic!("couldn't create muir file {}: {}", file_path.to_str().unwrap(), why),
Ok(file) => file
};
write!(file, "{:?}", func).unwrap();
}
fn emit_muir_dot(suffix: &str, func: &MuFunctionVersion, vm: &VM) {
let func_name = func.name();
// create emit directory
create_emit_directory(vm);
let mut file_path = path::PathBuf::new();
file_path.push(&vm.vm_options.flag_aot_emit_dir);
file_path.push(func_name.clone() + suffix + ".dot");
let mut file = match File::create(file_path.as_path()) {
Err(why) => panic!("couldnt create muir dot {}: {}", file_path.to_str().unwrap(), why),
Ok(file) => file
};
emit_muir_dot_inner(&mut file, func_name.clone(), func.content.as_ref().unwrap());
}
fn emit_muir_dot_inner(file: &mut File,
f_name: String,
f_content: &FunctionContent) {
use utils::vec_utils;
// digraph func {
writeln!(file, "digraph {} {{", mangle_name(f_name)).unwrap();
// node shape: rect
writeln!(file, "node [shape=rect];").unwrap();
// every graph node (basic block)
for (id, block) in f_content.blocks.iter() {
let block_name = block.name();
// BBid [label = "name
write!(file, "BB{} [label = \"[{}]{} ", *id, *id, &block_name).unwrap();
let block_content = block.content.as_ref().unwrap();
// (args)
write!(file, "{}", vec_utils::as_str(&block_content.args)).unwrap();
if block_content.exn_arg.is_some() {
// [exc_arg]
write!(file, "[{}]", block_content.exn_arg.as_ref().unwrap()).unwrap();
}
write!(file, ":\\l\\l").unwrap();
// all the instructions
for inst in block_content.body.iter() {
write!(file, "{}\\l", inst).unwrap();
}
// "];
writeln!(file, "\"];").unwrap();
}
// every edge
for (id, block) in f_content.blocks.iter() {
use ast::inst::Instruction_::*;
let cur_block = *id;
// get last instruction
let last_inst = block.content.as_ref().unwrap().body.last().unwrap();
match last_inst.v {
TreeNode_::Instruction(ref inst) => {
let ref ops = inst.ops;
match inst.v {
Branch1(ref dest) => {
writeln!(file, "BB{} -> BB{} [label = \"{}\"];",
cur_block, dest.target, vec_utils::as_str(&dest.get_arguments(&ops))
).unwrap();
}
Branch2{ref true_dest, ref false_dest, ..} => {
writeln!(file, "BB{} -> BB{} [label = \"true: {}\"]",
cur_block, true_dest.target, vec_utils::as_str(&true_dest.get_arguments(&ops))
).unwrap();
writeln!(file, "BB{} -> BB{} [label = \"false: {}\"]",
cur_block, false_dest.target, vec_utils::as_str(&false_dest.get_arguments(&ops))
).unwrap();
}
Switch{ref default, ref branches, ..} => {
for &(op, ref dest) in branches.iter() {
writeln!(file, "BB{} -> BB{} [label = \"case {}: {}\"]",
cur_block, dest.target, ops[op], vec_utils::as_str(&dest.get_arguments(&ops))
).unwrap();
}
writeln!(file, "BB{} -> BB{} [label = \"default: {}\"]",
cur_block, default.target, vec_utils::as_str(&default.get_arguments(&ops))
).unwrap();
}
Call{ref resume, ..}
| CCall{ref resume, ..}
| SwapStack{ref resume, ..}
| ExnInstruction{ref resume, ..} => {
let ref normal = resume.normal_dest;
let ref exn = resume.exn_dest;
writeln!(file, "BB{} -> BB{} [label = \"normal: {}\"];",
cur_block, normal.target, vec_utils::as_str(&normal.get_arguments(&ops))
).unwrap();
writeln!(file, "BB{} -> BB{} [label = \"exception: {}\"];",
cur_block, exn.target, vec_utils::as_str(&exn.get_arguments(&ops))
).unwrap();
}
Watchpoint{ref id, ref disable_dest, ref resume, ..} if id.is_some() => {
let ref normal = resume.normal_dest;
let ref exn = resume.exn_dest;
if id.is_some() {
let disable_dest = disable_dest.as_ref().unwrap();
writeln!(file, "BB{} -> {} [label = \"disabled: {}\"];",
cur_block, disable_dest.target, vec_utils::as_str(&disable_dest.get_arguments(&ops))
).unwrap();
}
writeln!(file, "BB{} -> BB{} [label = \"normal: {}\"];",
cur_block, normal.target, vec_utils::as_str(&normal.get_arguments(&ops))
).unwrap();
writeln!(file, "BB{} -> BB{} [label = \"exception: {}\"];",
cur_block, exn.target, vec_utils::as_str(&exn.get_arguments(&ops))
).unwrap();
}
WPBranch{ref disable_dest, ref enable_dest, ..} => {
writeln!(file, "BB{} -> BB{} [label = \"disabled: {}\"];",
cur_block, disable_dest.target, vec_utils::as_str(&disable_dest.get_arguments(&ops))
).unwrap();
writeln!(file, "BB{} -> BB{} [label = \"enabled: {}\"];",
cur_block, enable_dest.target, vec_utils::as_str(&enable_dest.get_arguments(&ops))
).unwrap();
}
Return(_)
| Throw(_)
| ThreadExit
| TailCall(_) => {}
_ => {
panic!("unexpected terminating instruction: {}", inst);
}
}
},
TreeNode_::Value(_) => {
panic!("expected last tree node to be an instruction");
}
}
}
writeln!(file, "}}").unwrap();
}
impl CompilerPass for DotGen {
fn name(&self) -> &'static str {
self.name
}
fn as_any(&self) -> &Any {
self
}
fn visit_function(&mut self, vm: &VM, func: &mut MuFunctionVersion) {
if EMIT_MUIR {
emit_muir_dot(self.suffix, func, vm);
}
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment