FactGenerator: Capture instr attr naming schemes (pt. 1)

Begin systematizing the names of attributes of instructions. This commit
endeavors not to rename anything that appears in the fact generator nor Datalog,
but merely to capture the existing system(s) of instruction attribute names.
This will make it more obvious which ones lie outside these conventions, and
make it easier to change them.

This commit ends at `trunc`, further commits will do the rest.

FactGenerator/include/predicates.inc

@@ -10,9 +10,11 @@
 #define PREDICATE(group, name, fname)
 #endif
 // The goal of the above TODO is to move most or all of the below declarations
-// from using PREDICATE to PREDICATE2 and PREDICATE_INSTR.
+// from using PREDICATE to PREDICATE2S? and PREDICATEIS?.
 #define PREDICATE2(group, name) PREDICATE(group, name, group ## _ ## name)
-#define PREDICATE_INSTR(group, name) PREDICATE(group, name, group ## _instr_ ## name)
+#define PREDICATE2S(group, name) PREDICATE(group, name, group ## name)
+#define PREDICATEI(group, name) PREDICATE(group, name, group ## _instr_ ## name)
+#define PREDICATEIS(group, name) PREDICATE(group, name, group ## instr_ ## name)
 
 GROUP_BEGIN(block)
 PREDICATE2(block, predecessor)
@@ -72,125 +74,127 @@ PREDICATE(instr, unreachable, unreachable_instr)
 GROUP_END(instr)
 
 GROUP_BEGIN(add)
-PREDICATE(add, instr, add_instr)
-PREDICATE(add, first_operand, add_instr_first_operand)
-PREDICATE(add, second_operand, add_instr_second_operand)
+PREDICATE2(add, instr)
+PREDICATEI(add, first_operand)
+PREDICATEI(add, second_operand)
 GROUP_END(add)
 
 GROUP_BEGIN(fadd)
-PREDICATE(fadd, instr, fadd_instr)
-PREDICATE(fadd, first_operand, fadd_instr_first_operand)
-PREDICATE(fadd, second_operand, fadd_instr_second_operand)
+PREDICATE2(fadd, instr)
+PREDICATEI(fadd, first_operand)
+PREDICATEI(fadd, second_operand)
 GROUP_END(fadd)
 
 GROUP_BEGIN(sub)
-PREDICATE(sub, instr, sub_instr)
-PREDICATE(sub, first_operand, sub_instr_first_operand)
-PREDICATE(sub, second_operand, sub_instr_second_operand)
+PREDICATE2(sub, instr)
+PREDICATEI(sub, first_operand)
+PREDICATEI(sub, second_operand)
 GROUP_END(sub)
 
 GROUP_BEGIN(fsub)
-PREDICATE(fsub, instr, fsub_instr)
-PREDICATE(fsub, first_operand, fsub_instr_first_operand)
-PREDICATE(fsub, second_operand, fsub_instr_second_operand)
+PREDICATE2(fsub, instr)
+PREDICATEI(fsub, first_operand)
+PREDICATEI(fsub, second_operand)
 GROUP_END(fsub)
 
 GROUP_BEGIN(mul)
-PREDICATE(mul, instr, mul_instr)
-PREDICATE(mul, first_operand, mul_instr_first_operand)
-PREDICATE(mul, second_operand, mul_instr_second_operand)
+PREDICATE2(mul, instr)
+PREDICATEI(mul, first_operand)
+PREDICATEI(mul, second_operand)
 GROUP_END(mul)
 
 GROUP_BEGIN(fmul)
-PREDICATE(fmul, instr, fmul_instr)
-PREDICATE(fmul, first_operand, fmul_instr_first_operand)
-PREDICATE(fmul, second_operand, fmul_instr_second_operand)
+PREDICATE2(fmul, instr)
+PREDICATEI(fmul, first_operand)
+PREDICATEI(fmul, second_operand)
 GROUP_END(fmul)
 
 GROUP_BEGIN(udiv)
-PREDICATE(udiv, instr, udiv_instr)
-PREDICATE(udiv, first_operand, udiv_instr_first_operand)
-PREDICATE(udiv, second_operand, udiv_instr_second_operand)
-GROUP_END(udiv)
+PREDICATE2(udiv, instr)
+PREDICATEI(udiv, first_operand)
+PREDICATEI(udiv, second_operand)
+GROUP_END(udv)
 
 GROUP_BEGIN(fdiv)
-PREDICATE(fdiv, instr, fdiv_instr)
-PREDICATE(fdiv, first_operand, fdiv_instr_first_operand)
-PREDICATE(fdiv, second_operand, fdiv_instr_second_operand)
+PREDICATE2(fdiv, instr)
+PREDICATEI(fdiv, first_operand)
+PREDICATEI(fdiv, second_operand)
 GROUP_END(fdiv)
 
 GROUP_BEGIN(sdiv)
-PREDICATE(sdiv, instr, sdiv_instr)
-PREDICATE(sdiv, first_operand, sdiv_instr_first_operand)
-PREDICATE(sdiv, second_operand, sdiv_instr_second_operand)
+PREDICATE2(sdiv, instr)
+PREDICATEI(sdiv, first_operand)
+PREDICATEI(sdiv, second_operand)
 GROUP_END(sdiv)
 
 GROUP_BEGIN(urem)
-PREDICATE(urem, instr, urem_instr)
-PREDICATE(urem, first_operand, urem_instr_first_operand)
-PREDICATE(urem, second_operand, urem_instr_second_operand)
+PREDICATE2(urem, instr)
+PREDICATEI(urem, first_operand)
+PREDICATEI(urem, second_operand)
 GROUP_END(urem)
 
 GROUP_BEGIN(srem)
-PREDICATE(srem, instr, srem_instr)
-PREDICATE(srem, first_operand, srem_instr_first_operand)
-PREDICATE(srem, second_operand, srem_instr_second_operand)
+PREDICATE2(srem, instr)
+PREDICATEI(srem, first_operand)
+PREDICATEI(srem, second_operand)
 GROUP_END(srem)
 
 GROUP_BEGIN(frem)
-PREDICATE(frem, instr, frem_instr)
-PREDICATE(frem, first_operand, frem_instr_first_operand)
-PREDICATE(frem, second_operand, frem_instr_second_operand)
+PREDICATE2(frem, instr)
+PREDICATEI(frem, first_operand)
+PREDICATEI(frem, second_operand)
 GROUP_END(frem)
 
 // Bitwise Binary Instrs
 
 GROUP_BEGIN(shl)
-PREDICATE(shl, instr, shl_instr)
-PREDICATE(shl, first_operand, shl_instr_first_operand)
-PREDICATE(shl, second_operand, shl_instr_second_operand)
+PREDICATE2(shl, instr)
+PREDICATEI(shl, first_operand)
+PREDICATEI(shl, second_operand)
 GROUP_END(shl)
 
 GROUP_BEGIN(lshr)
-PREDICATE(lshr, instr, lshr_instr)
-PREDICATE(lshr, first_operand, lshr_instr_first_operand)
-PREDICATE(lshr, second_operand, lshr_instr_second_operand)
+PREDICATE2(lshr, instr)
+PREDICATEI(lshr, first_operand)
+PREDICATEI(lshr, second_operand)
 GROUP_END(lshr)
 
 GROUP_BEGIN(ashr)
-PREDICATE(ashr, instr, ashr_instr)
-PREDICATE(ashr, first_operand, ashr_instr_first_operand)
-PREDICATE(ashr, second_operand, ashr_instr_second_operand)
+PREDICATE2(ashr, instr)
+PREDICATEI(ashr, first_operand)
+PREDICATEI(ashr, second_operand)
 GROUP_END(ashr)
 
 GROUP_BEGIN(and_)
-PREDICATE(and_, instr, and_instr)
-PREDICATE(and_, first_operand, and_instr_first_operand)
-PREDICATE(and_, second_operand, and_instr_second_operand)
+PREDICATE2S(and_, instr)
+PREDICATEIS(and_, first_operand)
+PREDICATEIS(and_, second_operand)
 GROUP_END(and_)
 
 GROUP_BEGIN(or_)
-PREDICATE(or_, instr, or_instr)
-PREDICATE(or_, first_operand, or_instr_first_operand)
-PREDICATE(or_, second_operand, or_instr_second_operand)
+PREDICATE2S(or_, instr)
+PREDICATEIS(or_, first_operand)
+PREDICATEIS(or_, second_operand)
 GROUP_END(or_)
 
 GROUP_BEGIN(xor_)
-PREDICATE(xor_, instr, xor_instr)
-PREDICATE(xor_, first_operand, xor_instr_first_operand)
-PREDICATE(xor_, second_operand, xor_instr_second_operand)
+PREDICATE2S(xor_, instr)
+PREDICATEIS(xor_, first_operand)
+PREDICATEIS(xor_, second_operand)
 GROUP_END(xor_)
 
 // Terminator Instrs
 
 GROUP_BEGIN(ret)
-PREDICATE(ret, instr, ret_instr)
+PREDICATE2(ret, instr)
+// TODO(lb):
 PREDICATE(ret, instr_void, void_ret_instr)
+// TODO(lb):
 PREDICATE(ret, operand, ret_instr_value)
 GROUP_END(ret)
 
 GROUP_BEGIN(br)
-PREDICATE(br, instr, br_instr)
+PREDICATE2(br, instr)
 PREDICATE(br, instr_cond, br_cond_instr)
 PREDICATE(br, condition, br_cond_instr_condition)
 PREDICATE(br, cond_iftrue, br_cond_instr_iftrue_label)
@@ -200,28 +204,30 @@ PREDICATE(br, uncond_dest, br_uncond_instr_dest_label)
 GROUP_END(br)
 
 GROUP_BEGIN(switch_)
-PREDICATE(switch_, instr, switch_instr)
-PREDICATE(switch_, operand, switch_instr_operand)
-PREDICATE(switch_, default_label, switch_instr_default_label)
+PREDICATE2S(switch_, instr)
+PREDICATEIS(switch_, operand)
+PREDICATEIS(switch_, default_label)
+// TODO(lb): Remove leading underscores
 PREDICATE(switch_, case_value, _switch_instr_case_value)
 PREDICATE(switch_, case_label, _switch_instr_case_label)
-PREDICATE(switch_, ncases, switch_instr_ncases)
+PREDICATEIS(switch_, ncases)
 GROUP_END(switch_)
 
 GROUP_BEGIN(indirectbr)
-PREDICATE(indirectbr, instr, indirectbr_instr)
-PREDICATE(indirectbr, address, indirectbr_instr_address)
-PREDICATE(indirectbr, label, indirectbr_instr_label)
-PREDICATE(indirectbr, nlabels, indirectbr_instr_nlabels)
+PREDICATE2(indirectbr, instr)
+PREDICATEI(indirectbr, address)
+PREDICATEI(indirectbr, label)
+PREDICATEI(indirectbr, nlabels)
 GROUP_END(indirectbr)
 
 GROUP_BEGIN(resume)
-PREDICATE(resume, instr, resume_instr)
-PREDICATE(resume, operand, resume_instr_operand)
+PREDICATE2(resume, instr)
+PREDICATEI(resume, operand)
 GROUP_END(resume)
 
 GROUP_BEGIN(invoke)
-PREDICATE(invoke, instr, invoke_instr)
+PREDICATE2(invoke, instr)
+// TODO(lb): Rename for consistency
 PREDICATE(invoke, instr_direct, direct_invoke_instr)
 PREDICATE(invoke, instr_indirect, indirect_invoke_instr)
 PREDICATE(invoke, function, invoke_instr_fn_operand)
@@ -237,19 +243,22 @@ GROUP_END(invoke)
 // Vector Operations
 
 GROUP_BEGIN(extract_element)
+// TODO(lb): Rename extract_element to extractelement
 PREDICATE(extract_element, instr, extractelement_instr)
 PREDICATE(extract_element, base, extractelement_instr_base)
 PREDICATE(extract_element, index, extractelement_instr_index)
 GROUP_END(extract_element)
 
 GROUP_BEGIN(insert_element)
+// TODO(lb): Rename insert_element to insertelement
 PREDICATE(insert_element, instr, insertelement_instr)
 PREDICATE(insert_element, base, insertelement_instr_base)
 PREDICATE(insert_element, index, insertelement_instr_index)
 PREDICATE(insert_element, value, insertelement_instr_value)
 GROUP_END(insert_element)
 
 GROUP_BEGIN(shuffle_vector)
+// TODO(lb): Rename shuffle_vector to shufflevector
 PREDICATE(shuffle_vector, instr, shufflevector_instr)
 PREDICATE(shuffle_vector, first_vector, shufflevector_instr_first_vector)
 PREDICATE(shuffle_vector, second_vector, shufflevector_instr_second_vector)
@@ -259,13 +268,15 @@ GROUP_END(shuffle_vector)
 // Aggregate Operations
 
 GROUP_BEGIN(extract_value)
+// TODO(lb): Rename extract_value to extractvalue
 PREDICATE(extract_value, instr, extractvalue_instr)
 PREDICATE(extract_value, base, extractvalue_instr_base)
 PREDICATE(extract_value, index, extractvalue_instr_index)
 PREDICATE(extract_value, nindices, extractvalue_instr_nindices)
 GROUP_END(extract_value)
 
 GROUP_BEGIN(insert_value)
+// TODO(lb): Rename insert_value to insertvalue
 PREDICATE(insert_value, instr, insertvalue_instr)
 PREDICATE(insert_value, base, insertvalue_instr_base)
 PREDICATE(insert_value, value, insertvalue_instr_value)
@@ -276,54 +287,59 @@ GROUP_END(insert_value)
 // Memory Operations
 
 GROUP_BEGIN(alloca)
-PREDICATE(alloca, instr, alloca_instr)
-PREDICATE(alloca, size, alloca_instr_size)
-PREDICATE(alloca, alignment, alloca_instr_alignment)
-PREDICATE(alloca, type, alloca_instr_type)
+PREDICATE2(alloca, instr)
+PREDICATEI(alloca, size)
+PREDICATEI(alloca, alignment)
+PREDICATEI(alloca, type)
 GROUP_END(alloca)
 
 GROUP_BEGIN(load)
-PREDICATE(load, instr, load_instr)
-PREDICATE(load, alignment, load_instr_alignment)
-PREDICATE(load, ordering, load_instr_ordering)
-PREDICATE(load, address, load_instr_address)
+PREDICATE2(load, instr)
+PREDICATEI(load, alignment)
+PREDICATEI(load, ordering)
+PREDICATEI(load, address)
+// TODO(lb):
 PREDICATE(load, isvolatile, load_instr_is_volatile)
 GROUP_END(load)
 
 GROUP_BEGIN(store)
-PREDICATE(store, instr, store_instr)
-PREDICATE(store, alignment, store_instr_alignment)
-PREDICATE(store, ordering, store_instr_ordering)
-PREDICATE(store, value, store_instr_value)
-PREDICATE(store, address, store_instr_address)
+PREDICATE2(store, instr)
+PREDICATEI(store, alignment)
+PREDICATEI(store, ordering)
+PREDICATEI(store, value)
+PREDICATEI(store, address)
+// TODO(lb):
 PREDICATE(store, isvolatile, store_instr_is_volatile)
 GROUP_END(store)
 
 GROUP_BEGIN(fence)
-PREDICATE(fence, instr, fence_instr)
-PREDICATE(fence, ordering, fence_instr_ordering)
+PREDICATE2(fence, instr)
+PREDICATEI(fence, ordering)
 GROUP_END(fence)
 
 GROUP_BEGIN(atomicrmw)
-PREDICATE(atomicrmw, instr, atomicrmw_instr)
-PREDICATE(atomicrmw, ordering, atomicrmw_instr_ordering)
-PREDICATE(atomicrmw, operation, atomicrmw_instr_operation)
-PREDICATE(atomicrmw, address, atomicrmw_instr_address)
-PREDICATE(atomicrmw, value, atomicrmw_instr_value)
+PREDICATE2(atomicrmw, instr)
+PREDICATEI(atomicrmw, ordering)
+PREDICATEI(atomicrmw, operation)
+PREDICATEI(atomicrmw, address)
+PREDICATEI(atomicrmw, value)
+// TODO(lb):
 PREDICATE(atomicrmw, isvolatile, atomicrmw_instr_is_volatile)
 GROUP_END(atomicrmw)
 
 GROUP_BEGIN(cmpxchg)
-PREDICATE(cmpxchg, instr, cmpxchg_instr)
-PREDICATE(cmpxchg, ordering, cmpxchg_instr_ordering)
-PREDICATE(cmpxchg, address, cmpxchg_instr_address)
-PREDICATE(cmpxchg, cmp_value, cmpxchg_instr_cmp_value)
-PREDICATE(cmpxchg, new_value, cmpxchg_instr_new_value)
-PREDICATE(cmpxchg, type, cmpxchg_instr_type)
+PREDICATE2(cmpxchg, instr)
+PREDICATEI(cmpxchg, ordering)
+PREDICATEI(cmpxchg, address)
+PREDICATEI(cmpxchg, cmp_value)
+PREDICATEI(cmpxchg, new_value)
+PREDICATEI(cmpxchg, type)
+// TODO(lb):
 PREDICATE(cmpxchg, isvolatile, cmpxchg_instr_is_volatile)
 GROUP_END(cmpxchg)
 
 GROUP_BEGIN(gep)
+// TODO(lb): Rename getelementptr to gep in Datalog
 PREDICATE(gep, instr, getelementptr_instr)
 PREDICATE(gep, base, getelementptr_instr_base)
 PREDICATE(gep, index, getelementptr_instr_index)
@@ -334,9 +350,9 @@ GROUP_END(gep)
 // Conversion Operations
 
 GROUP_BEGIN(trunc)
-PREDICATE(trunc, instr, trunc_instr)
-PREDICATE(trunc, from_operand, trunc_instr_from_operand)
-PREDICATE(trunc, to_type, trunc_instr_to_type)
+PREDICATE2(trunc, instr)
+PREDICATEI(trunc, from_operand)
+PREDICATEI(trunc, to_type)
 GROUP_END(trunc)
 
 GROUP_BEGIN(zext)

doc/dev.rst

@@ -53,7 +53,7 @@ space. This judgment is highly subjective, but must be made somehow.
 - ``global_var``: Global variable
 - ``expr``: Expression
 - ``func``: Function
-- ``gep``: ``getelementptr``
+- ``gep``: ``getelementptr`` (this is the only abbreviated opcode)
 - ``instr``: Instruction
 - ``int``: Integer
 - ``param``: Parameter