use crate::diag::Span;
#[derive(Clone, PartialEq, Debug)]
pub enum Ty {
Void,
Int(u32),
Half,
Float,
Double,
X86Fp80,
Fp128,
Ptr(Option<Box<Ty>>),
Array(u64, Box<Ty>),
Vector {
len: u64,
scalable: bool,
elem: Box<Ty>,
},
Struct {
fields: Vec<Ty>,
packed: bool,
},
Named(String),
Func {
ret: Box<Ty>,
params: Vec<Ty>,
varargs: bool,
},
Label,
Metadata,
Token,
Opaque,
}
impl Ty {
pub fn pointee_name(&self) -> Option<&str> {
match self {
Ty::Ptr(Some(inner)) => match inner.as_ref() {
Ty::Named(name) => Some(name),
_ => None,
},
_ => None,
}
}
}
#[derive(Clone, PartialEq, Debug)]
pub enum Value {
Local(String),
Global(String),
Int(i128),
Float(f64),
Bool(bool),
Null,
NoneValue,
Undef,
Poison,
ZeroInit,
Bytes(Vec<u8>),
Aggregate(Vec<TypedValue>),
ConstExpr(Box<ConstExpr>),
MetadataRef(String),
MetadataString(String),
BlockAddress,
}
#[derive(Clone, PartialEq, Debug)]
pub struct TypedValue {
pub ty: Ty,
pub value: Value,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub enum ConstExpr {
Cast {
op: CastOp,
operand: TypedValue,
to: Ty,
},
GetElementPtr {
inbounds: bool,
base_ty: Ty,
ptr: TypedValue,
indices: Vec<TypedValue>,
},
Binary {
op: BinOp,
lhs: TypedValue,
rhs: TypedValue,
},
}
macro_rules! keywords {
($name:ident { $($variant:ident = $text:literal),* $(,)? }) => {
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum $name {
$($variant),*
}
impl $name {
pub fn from_keyword(keyword: &str) -> Option<$name> {
match keyword {
$($text => Some($name::$variant),)*
_ => None,
}
}
pub fn keyword(self) -> &'static str {
match self {
$($name::$variant => $text),*
}
}
}
};
}
keywords!(BinOp {
Add = "add",
Sub = "sub",
Mul = "mul",
UDiv = "udiv",
SDiv = "sdiv",
URem = "urem",
SRem = "srem",
Shl = "shl",
LShr = "lshr",
AShr = "ashr",
And = "and",
Or = "or",
Xor = "xor",
FAdd = "fadd",
FSub = "fsub",
FMul = "fmul",
FDiv = "fdiv",
FRem = "frem",
});
impl BinOp {
pub fn is_float(self) -> bool {
matches!(
self,
BinOp::FAdd | BinOp::FSub | BinOp::FMul | BinOp::FDiv | BinOp::FRem
)
}
}
keywords!(CastOp {
Trunc = "trunc",
ZExt = "zext",
SExt = "sext",
FPTrunc = "fptrunc",
FPExt = "fpext",
FPToUI = "fptoui",
FPToSI = "fptosi",
UIToFP = "uitofp",
SIToFP = "sitofp",
PtrToInt = "ptrtoint",
IntToPtr = "inttoptr",
BitCast = "bitcast",
AddrSpaceCast = "addrspacecast",
});
keywords!(IntPredicate {
Eq = "eq",
Ne = "ne",
Ugt = "ugt",
Uge = "uge",
Ult = "ult",
Ule = "ule",
Sgt = "sgt",
Sge = "sge",
Slt = "slt",
Sle = "sle",
});
keywords!(FloatPredicate {
False = "false",
Oeq = "oeq",
Ogt = "ogt",
Oge = "oge",
Olt = "olt",
Ole = "ole",
One = "one",
Ord = "ord",
Ueq = "ueq",
Ugt = "ugt",
Uge = "uge",
Ult = "ult",
Ule = "ule",
Une = "une",
Uno = "uno",
True = "true",
});
#[derive(Clone, PartialEq, Debug)]
pub struct Argument {
pub ty: Ty,
pub attrs: Vec<String>,
pub value: Value,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct Call {
pub tail: bool,
pub ret_ty: Ty,
pub explicit_fn_ty: Option<Ty>,
pub callee: Value,
pub args: Vec<Argument>,
pub attr_groups: Vec<String>,
pub span: Span,
}
impl Call {
pub fn callee_name(&self) -> Option<&str> {
match &self.callee {
Value::Global(name) => Some(name),
_ => None,
}
}
}
#[derive(Clone, PartialEq, Debug)]
pub enum InstKind {
Call(Call),
Binary {
op: BinOp,
ty: Ty,
lhs: Value,
rhs: Value,
},
ICmp {
pred: IntPredicate,
ty: Ty,
lhs: Value,
rhs: Value,
},
FCmp {
pred: FloatPredicate,
ty: Ty,
lhs: Value,
rhs: Value,
},
Cast {
op: CastOp,
operand: TypedValue,
to: Ty,
},
Select {
cond: TypedValue,
if_true: TypedValue,
if_false: TypedValue,
},
Phi {
ty: Ty,
incoming: Vec<(Value, String)>,
},
Alloca {
ty: Ty,
count: Option<TypedValue>,
},
Load {
ty: Ty,
ptr: TypedValue,
},
Store {
value: TypedValue,
ptr: TypedValue,
},
GetElementPtr {
inbounds: bool,
base_ty: Ty,
ptr: TypedValue,
indices: Vec<TypedValue>,
},
ExtractValue {
aggregate: TypedValue,
indices: Vec<u64>,
},
InsertValue {
aggregate: TypedValue,
value: TypedValue,
indices: Vec<u64>,
},
Freeze(TypedValue),
Fence,
Unsupported {
opcode: String,
},
}
#[derive(Clone, PartialEq, Debug)]
pub struct Instruction {
pub result: Option<String>,
pub kind: InstKind,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub enum Terminator {
Ret(Option<TypedValue>),
Br {
target: String,
},
CondBr {
cond: TypedValue,
if_true: String,
if_false: String,
},
Switch {
scrutinee: TypedValue,
default: String,
cases: Vec<(TypedValue, String)>,
},
Unreachable,
}
#[derive(Clone, PartialEq, Debug)]
pub struct BasicBlock {
pub label: String,
pub instructions: Vec<Instruction>,
pub terminator: Terminator,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct Param {
pub ty: Ty,
pub name: Option<String>,
pub attrs: Vec<String>,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct FuncSig {
pub name: String,
pub ret_ty: Ty,
pub params: Vec<Param>,
pub varargs: bool,
pub attr_groups: Vec<String>,
pub attrs: Vec<Attribute>,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct Function {
pub sig: FuncSig,
pub blocks: Vec<BasicBlock>,
pub span: Span,
}
impl Function {
pub fn block(&self, label: &str) -> Option<&BasicBlock> {
self.blocks.iter().find(|b| b.label == label)
}
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum Attribute {
Flag(String),
KeyValue(String, String),
}
impl Attribute {
pub fn key(&self) -> &str {
match self {
Attribute::Flag(k) | Attribute::KeyValue(k, _) => k,
}
}
pub fn value(&self) -> Option<&str> {
match self {
Attribute::Flag(_) => None,
Attribute::KeyValue(_, v) => Some(v),
}
}
}
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AttrGroup {
pub id: String,
pub attrs: Vec<Attribute>,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct GlobalVar {
pub name: String,
pub ty: Ty,
pub initializer: Option<Value>,
pub is_constant: bool,
pub linkage: Vec<String>,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct TypeDef {
pub name: String,
pub ty: Ty,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub struct NamedMetadata {
pub name: String,
pub operands: Vec<String>,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug)]
pub enum MetadataNode {
Tuple(Vec<MetadataItem>),
Specialized { kind: String, body: String },
}
#[derive(Clone, PartialEq, Debug)]
pub enum MetadataItem {
Value(TypedValue),
Ref(String),
Str(String),
Node(Vec<MetadataItem>),
Null,
}
#[derive(Clone, PartialEq, Debug)]
pub struct MetadataDef {
pub id: String,
pub distinct: bool,
pub node: MetadataNode,
pub span: Span,
}
#[derive(Clone, PartialEq, Debug, Default)]
pub struct Module {
pub source_filename: Option<String>,
pub datalayout: Option<String>,
pub triple: Option<String>,
pub type_defs: Vec<TypeDef>,
pub globals: Vec<GlobalVar>,
pub declarations: Vec<FuncSig>,
pub functions: Vec<Function>,
pub attr_groups: Vec<AttrGroup>,
pub named_metadata: Vec<NamedMetadata>,
pub metadata: Vec<MetadataDef>,
}
impl Module {
pub fn function(&self, name: &str) -> Option<&Function> {
self.functions.iter().find(|f| f.sig.name == name)
}
pub fn attr_group(&self, id: &str) -> Option<&AttrGroup> {
self.attr_groups.iter().find(|g| g.id == id)
}
pub fn global(&self, name: &str) -> Option<&GlobalVar> {
self.globals.iter().find(|g| g.name == name)
}
pub fn metadata_def(&self, id: &str) -> Option<&MetadataDef> {
self.metadata.iter().find(|m| m.id == id)
}
pub fn named_metadata_node(&self, name: &str) -> Option<&NamedMetadata> {
self.named_metadata.iter().find(|n| n.name == name)
}
pub fn attributes_of<'a>(&'a self, sig: &'a FuncSig) -> Vec<&'a Attribute> {
let mut out: Vec<&Attribute> = sig.attrs.iter().collect();
for id in &sig.attr_groups {
if let Some(group) = self.attr_group(id) {
out.extend(group.attrs.iter());
}
}
out
}
pub fn entry_point(&self) -> Option<&Function> {
self.functions
.iter()
.find(|f| {
self.attributes_of(&f.sig)
.iter()
.any(|a| a.key() == "entry_point")
})
.or_else(|| self.function("main"))
}
}