diff --git a/ykrt/src/compile/jitc_yk/codegen/x64/mod.rs b/ykrt/src/compile/jitc_yk/codegen/x64/mod.rs
index 6eb49899a..343bc1608 100644
--- a/ykrt/src/compile/jitc_yk/codegen/x64/mod.rs
+++ b/ykrt/src/compile/jitc_yk/codegen/x64/mod.rs
@@ -1499,9 +1499,25 @@ impl<'a> Assemble<'a> {
             .collect::<Vec<_>>();
 
         // unwrap safe on account of linker symbol names not containing internal NULL bytes.
-        let va = symbol_to_ptr(self.m.func_decl(func_decl_idx).name())
-            .map_err(|e| CompilationError::General(e.to_string()))?;
-        self.emit_call(iidx, fty, Some(va), None, &args)
+        match self.m.func_decl(func_decl_idx).name() {
+            "llvm.assume" => Ok(()),
+            "llvm.lifetime.start.p0" => Ok(()),
+            "llvm.lifetime.end.p0" => Ok(()),
+            x if x.starts_with("llvm.ctpop") => {
+                let [op] = args.try_into().unwrap();
+                self.cg_ctpop(iidx, op);
+                Ok(())
+            }
+            x if x.starts_with("llvm.smax") => {
+                let [lhs_op, rhs_op] = args.try_into().unwrap();
+                self.cg_smax(iidx, lhs_op, rhs_op);
+                Ok(())
+            }
+            x => {
+                let va = symbol_to_ptr(x).map_err(|e| CompilationError::General(e.to_string()))?;
+                self.emit_call(iidx, fty, Some(va), None, &args)
+            }
+        }
     }
 
     /// Codegen a indirect call.
@@ -1681,6 +1697,41 @@ impl<'a> Assemble<'a> {
         }
     }
 
+    fn cg_ctpop(&mut self, iidx: InstIdx, op: Operand) {
+        let bitw = op.bitw(self.m);
+        let [in_reg, out_reg] = self.ra.assign_gp_regs(
+            &mut self.asm,
+            iidx,
+            [
+                RegConstraint::Input(op.clone()),
+                RegConstraint::OutputCanBeSameAsInput(op),
+            ],
+        );
+        match bitw {
+            32 => dynasm!(self.asm; popcnt Rd(out_reg.code()), Rd(in_reg.code())),
+            x => todo!("{x}"),
+        }
+    }
+
+    fn cg_smax(&mut self, iidx: InstIdx, lhs: Operand, rhs: Operand) {
+        assert_eq!(lhs.bitw(self.m), rhs.bitw(self.m));
+        let bitw = lhs.bitw(self.m);
+        let [lhs_reg, rhs_reg] = self.ra.assign_gp_regs(
+            &mut self.asm,
+            iidx,
+            [RegConstraint::InputOutput(lhs), RegConstraint::Input(rhs)],
+        );
+        match bitw {
+            64 => {
+                dynasm!(self.asm
+                    ; cmp Rq(lhs_reg.code()), Rq(rhs_reg.code())
+                    ; cmovl Rq(lhs_reg.code()), Rq(rhs_reg.code())
+                );
+            }
+            x => todo!("{x}"),
+        }
+    }
+
     /// Return the [VarLocation] an [Operand] relates to.
     fn op_to_var_location(&self, op: Operand) -> VarLocation {
         match op {
@@ -3865,6 +3916,74 @@ mod tests {
         );
     }
 
+    #[test]
+    fn cg_call_hints() {
+        codegen_and_test(
+            "
+             func_decl llvm.assume (i1)
+             func_decl llvm.lifetime.start.p0 (i64, ptr)
+             func_decl llvm.lifetime.end.p0 (i64, ptr)
+             entry:
+               %0: i1 = param 0
+               %1: ptr = param 1
+               call @llvm.assume(%0)
+               call @llvm.lifetime.start.p0(16i64, %1)
+               call @llvm.lifetime.end.p0(16i64, %1)
+               %5: ptr = ptr_add %1, 1
+               black_box %5
+            ",
+            "
+               ...
+               ; call @llvm.assume(%0)
+               ; call @llvm.lifetime.start.p0(16i64, %1)
+               ; call @llvm.lifetime.end.p0(16i64, %1)
+               ; %5: ...
+               ...
+            ",
+            false,
+        );
+    }
+
+    #[test]
+    fn cg_call_ctpop() {
+        codegen_and_test(
+            "
+             func_decl llvm.ctpop.i32 (i32) -> i32
+             entry:
+               %0: i32 = param 0
+               %1: i32 = call @llvm.ctpop.i32(%0)
+               black_box %1
+            ",
+            "
+               ...
+               ; %1: i32 = call @llvm.ctpop.i32(%0)
+               popcnt r.32._, r.32._
+            ",
+            false,
+        );
+    }
+
+    #[test]
+    fn cg_call_smax() {
+        codegen_and_test(
+            "
+             func_decl llvm.smax.i64 (i64, i64) -> i64
+             entry:
+               %0: i64 = param 0
+               %1: i64 = param 1
+               %2: i64 = call @llvm.smax.i64(%0, %1)
+               black_box %2
+            ",
+            "
+               ...
+               ; %2: i64 = call @llvm.smax.i64(%0, %1)
+               cmp r.64.a, r.64.b
+               cmovl r.64.a, r.64.b
+            ",
+            false,
+        );
+    }
+
     #[test]
     fn cg_eq() {
         codegen_and_test(
diff --git a/ykrt/src/compile/jitc_yk/jit_ir/jit_ir.l b/ykrt/src/compile/jitc_yk/jit_ir/jit_ir.l
index 4bce969fa..c1a2f736f 100644
--- a/ykrt/src/compile/jitc_yk/jit_ir/jit_ir.l
+++ b/ykrt/src/compile/jitc_yk/jit_ir/jit_ir.l
@@ -1,5 +1,5 @@
 %%
-@[a-zA-Z_.][a-zA-Z_0-9]* "GLOBAL"
+@[a-zA-Z_.][a-zA-Z_0-9.]* "GLOBAL"
 %[0-9]+ "LOCAL_OPERAND"
 i[0-9]+ "INT_TYPE"
 float "FLOAT_TYPE"
@@ -80,7 +80,7 @@ f_true "F_TRUE"
 urem "UREM"
 xor "XOR"
 [a-zA_Z_]+: "LABEL"
-[a-zA_Z_][a-zA_Z_0-9]* "ID"
+[a-zA_Z_][a-zA_Z_0-9.]* "ID"
 volatile "VOLATILE"
 \< "<"
 \> ">"