Date: Wed, 30 Jul 2014 17:40:55 GMT From: dpl@FreeBSD.org To: svn-soc-all@FreeBSD.org Subject: socsvn commit: r271612 - soc2014/dpl/netmap-ipfwjit/sys/netpfil/ipfw Message-ID: <201407301740.s6UHetSg091014@socsvn.freebsd.org>
next in thread | raw e-mail | index | archive | help
Author: dpl Date: Wed Jul 30 17:40:55 2014 New Revision: 271612 URL: http://svnweb.FreeBSD.org/socsvn/?view=rev&rev=271612 Log: Substitute function calls for stub loading. Modified: soc2014/dpl/netmap-ipfwjit/sys/netpfil/ipfw/jit.cc Modified: soc2014/dpl/netmap-ipfwjit/sys/netpfil/ipfw/jit.cc ============================================================================== --- soc2014/dpl/netmap-ipfwjit/sys/netpfil/ipfw/jit.cc Wed Jul 30 16:08:16 2014 (r271611) +++ soc2014/dpl/netmap-ipfwjit/sys/netpfil/ipfw/jit.cc Wed Jul 30 17:40:55 2014 (r271612) @@ -53,6 +53,48 @@ int loadStub(std::string funcname) { + /* + // Get the stub (prototype) for the cell function + F = Mod->getFunction("cell"); + // Set it to have private linkage, so that it can be removed after being + // inlined. + F->setLinkage(GlobalValue::PrivateLinkage); + + // Add an entry basic block to this function and set it + BasicBlock *entry = BasicBlock::Create(C, "entry", F); + B.SetInsertPoint(entry); + // Cache the type of registers + regTy = Type::getInt16Ty(C); + + // Collect the function parameters + auto args = F->arg_begin(); + oldGrid = args++; + newGrid = args++; + width = args++; + height = args++; + x = args++; + y = args++; + + // Create space on the stack for the local registers + for (int i=0 ; i<10 ; i++) + { + a[i] = B.CreateAlloca(regTy); + } + + // Create a space on the stack for the current value. This can be + // assigned to, and will be returned at the end. Store the value passed + // as a parameter in this. + v = B.CreateAlloca(regTy); + B.CreateStore(args++, v); + + // Create a load of pointers to the global registers. + Value *gArg = args; + for (int i=0 ; i<10 ; i++) + { + B.CreateStore(ConstantInt::get(regTy, 0), a[i]); + g[i] = B.CreateConstGEP1_32(gArg, i); + } + */ return (0); } @@ -128,248 +170,247 @@ switch (cmd->opcode) { case O_NOP: - rule_nop(&match); + comp.loadStub("nop"); break; case O_FORWARD_MAC: - rule_forward_mac(cmd->opcode); + comp.loadStub("forward_mac"); break; case O_GID: case O_UID: case O_JAIL: - rule_jail(&match, offset, proto, cmd, args, ucred_lookup, ucred_cache); + comp.loadStub("jail"); break; case O_RECV: - rule_recv(&match, cmd, m, chain, &tablearg); + comp.loadStub("recv"); break; case O_XMIT: - rule_xmit(&match, oif, cmd, chain, &tablearg); + comp.loadStub("xmit"); break; case O_VIA: - rule_via(&match, oif, m, cmd, chain, &tablearg); + comp.loadStub("via"); break; case O_MACADDR2: - rule_macaddr2(&match, args, cmd); + comp.loadStub("macaddr2"); break; case O_MAC_TYPE: - rule_mac_type(&match, args, cmd, cmdlen, etype); + comp.loadStub("mac_type"); break; case O_FRAG: - rule_frag(&match, offset); + comp.loadStub("frag"); break; case O_IN: - rule_in(&match, oif); + comp.loadStub("in"); break; case O_LAYER2: - rule_layer2(&match, args); + comp.loadStub("layer2"); break; case O_DIVERTED: - rule_diverted(&match, args, cmd); + comp.loadStub("diverted"); break; case O_PROTO: - rule_proto(&match, proto, cmd); + comp.loadStub("proto"); break; case O_IP_SRC: - rule_ip_src(&match, is_ipv4, cmd, &src_ip); + comp.loadStub("ip_src"); break; case O_IP_SRC_LOOKUP: case O_IP_DST_LOOKUP: - rule_ip_dst_lookup(&match, cmd, cmdlen, args, &tablearg, is_ipv4, is_ipv6, ip, &dst_ip, &src_ip, dst_port, src_port, offset, proto, ucred_lookup, ucred_cache, chain); + comp.loadStub("ip_dst_lookup"); break; case O_IP_SRC_MASK: case O_IP_DST_MASK: - rule_ip_dst_mask(&match, is_ipv4, cmd, cmdlen, &dst_ip, &src_ip); + comp.loadStub("ip_dst_mask"); break; case O_IP_SRC_ME: - rule_ip_src_me(&match, is_ipv4, is_ipv6, &src_ip, args); + comp.loadStub("ip_src_me"); #ifdef INET6 /* FALLTHROUGH */ case O_IP6_SRC_ME: - rule_ip6_src_me(&match, is_ipv6, args); + comp.loadStub("ip6_src_me"); #endif break; case O_IP_DST_SET: case O_IP_SRC_SET: - rule_ip_src_set(&match, is_ipv4, cmd, args); + comp.loadStub("ip_src_set"); break; case O_IP_DST: - rule_ip_dst(&match, is_ipv4, cmd, &dst_ip); + comp.loadStub("ip_dst"); break; case O_IP_DST_ME: - rule_ip_dst_me(&match, args, is_ipv4, is_ipv6, &dst_ip); + comp.loadStub("ip_dst_me"); #ifdef INET6 /* FALLTHROUGH */ case O_IP6_DST_ME: - rule_ip6_dst_me(&match, args, is_ipv6); + comp.loadStub("ip6_dst_me"); #endif break; case O_IP_SRCPORT: case O_IP_DSTPORT: - rule_ip_dstport(&match, proto, offset, cmd, cmdlen, dst_port, src_port); + comp.loadStub("ip_dstport"); break; case O_ICMPTYPE: - rule_icmptype(&match, offset, proto, ulp, cmd); + comp.loadStub("icmptype"); break; #ifdef INET6 case O_ICMP6TYPE: - rule_icmp6type(&match, offset, is_ipv6, proto, ulp, cmd); + comp.loadStub("icmp6type"); break; #endif /* INET6 */ case O_IPOPT: - rule_ipopt(&match, is_ipv4, ip, cmd); + comp.loadStub("ipopt"); break; case O_IPVER: - rule_ipver(&match, is_ipv4, cmd, ip); + comp.loadStub("ipver"); break; case O_IPID: case O_IPLEN: case O_IPTTL: - rule_ipttl(&match, is_ipv4, cmd, cmdlen, ip, iplen); + comp.loadStub("ipttl"); break; case O_IPPRECEDENCE: - rule_ipprecedence(&match, is_ipv4, cmd, ip); + comp.loadStub("ipprecedence"); break; case O_IPTOS: - rule_iptos(&match, is_ipv4, cmd, ip); + comp.loadStub("iptos"); break; case O_DSCP: - rule_dscp(&match, is_ipv4, is_ipv6, cmd, ip); + comp.loadStub("dscp"); break; case O_TCPDATALEN: - rule_tcpdatalen(&match, proto, offset, ulp, iplen, cmdlen, cmd, ip); + comp.loadStub("tcpdatalen"); break; case O_TCPFLAGS: - rule_tcpflags(&match, proto, offset, cmd, ulp); + comp.loadStub("tcpflags"); break; case O_TCPOPTS: - if (rule_tcpopts(&match, hlen, ulp, proto, offset, cmd, m, args)) - goto pullup_failed; + comp.loadStub("tcpopts"); break; case O_TCPSEQ: - rule_tcpseq(&match, proto, offset, cmd, ulp); + comp.loadStub("tcpseq"); break; case O_TCPACK: - rule_tcpack(&match, proto, offset, cmd, ulp); + comp.loadStub("tcpack"); break; case O_TCPWIN: - rule_tcpwin(&match, proto, offset, cmd, cmdlen, ulp); + comp.loadStub("tcpwin"); break; case O_ESTAB: - rule_estab(&match, proto, offset, ulp); + comp.loadStub("estab"); break; case O_ALTQ: - rule_altq(&match, cmd, m, ip); + comp.loadStub("altq"); break; case O_LOG: - rule_log(&match, f, hlen, args, m, oif, offset, ip6f_mf, tablearg, ip); + comp.loadStub("log"); break; case O_PROB: - rule_prob(&match, cmd); + comp.loadStub("prob"); break; case O_VERREVPATH: - rule_verrevpath(&match, oif, m, is_ipv6, args, &src_ip); + comp.loadStub("verrevpath"); break; case O_VERSRCREACH: - rule_versrcreach(&match, hlen, oif, is_ipv6, args, &src_ip); + comp.loadStub("versrcreach"); break; case O_ANTISPOOF: - rule_antispoof(&match, oif, hlen, is_ipv4, is_ipv6, &src_ip, args, m); + comp.loadStub("antispoof"); break; case O_IPSEC: #ifdef IPSEC - rule_ipsec(&match, m); + comp.loadStub("ipsec"); #endif /* otherwise no match */ break; #ifdef INET6 case O_IP6_SRC: - rule_ip6_src(&match, is_ipv6, args, cmd); + comp.loadStub("ip6_src"); break; case O_IP6_DST: - rule_ip6_dst(&match, is_ipv6, args, cmd); + comp.loadStub("ip6_dst"); break; case O_IP6_SRC_MASK: case O_IP6_DST_MASK: - rule_ip6_dst_mask(&match, args, cmd, cmdlen, is_ipv6); + comp.loadStub("ip6_dst_mask"); break; case O_FLOW6ID: - rule_flow6id(&match, is_ipv6, args, cmd); + comp.loadStub("flow6id"); break; case O_EXT_HDR: - rule_ext_hdr(&match, is_ipv6, ext_hd, cmd); + comp.loadStub("ext_hdr"); break; case O_IP6: - rule_ip6(&match, is_ipv6); + comp.loadStub("ip6"); break; #endif case O_IP4: - rule_ip4(&match, is_ipv4); + comp.loadStub("ip4"); break; case O_TAG: - rule_tag(&match, cmd, m, tablearg); + comp.loadStub("tag"); break; case O_FIB: /* try match the specified fib */ - rule_fib(&match, args, cmd); + comp.loadStub("fib"); break; case O_SOCKARG: - rule_sockarg(&match, is_ipv6, proto, &dst_ip, &src_ip, dst_port, src_port, args, &tablearg); + comp.loadStub("sockarg"); break; case O_TAGGED: - rule_tagged(&match, cmd, cmdlen, m, tablearg); + comp.loadStub("tagged"); break; /* @@ -415,83 +456,83 @@ */ case O_LIMIT: case O_KEEP_STATE: - rule_keep_state(&match, f, cmd, args, tablearg, &retval, &l, &done); + comp.loadStub("keep_state"); break; case O_PROBE_STATE: case O_CHECK_STATE: - rule_check_state(&match, &dyn_dir, q, args, proto, ulp, pktlen, f, &f_pos, chain, cmd, &cmdlen, &l); + comp.loadStub("check_state"); break; case O_ACCEPT: - rule_accept(&retval, &l, &done); + comp.loadStub("accept"); break; case O_PIPE: case O_QUEUE: - rule_queue(args, f_pos, chain, cmd, tablearg, &retval, &l, &done); + comp.loadStub("queue"); break; case O_DIVERT: case O_TEE: - rule_tee(&l, &done, &retval, cmd, args, f_pos, tablearg, chain); + comp.loadStub("tee"); break; case O_COUNT: - rule_count(&l, f, pktlen); + comp.loadStub("count"); break; case O_SKIPTO: - rule_skipto(&match, &l, cmd, &cmdlen, &skip_or, &f_pos, f, pktlen, chain, tablearg); + comp.loadStub("skipto"); continue; break; /* NOTREACHED */ case O_CALLRETURN: - rule_callreturn(cmd, m, f, chain, tablearg, pktlen, &skip_or, &cmdlen, &f_pos, &l); + comp.loadStub("callreturn"); continue; break; /* NOTREACHED */ case O_REJECT: - rule_reject(hlen, is_ipv4, offset, proto, ulp, m, &dst_ip, args, cmd, iplen, ip); + comp.loadStub("reject"); /* FALLTHROUGH */ #ifdef INET6 case O_UNREACH6: - rule_unreach6(hlen, is_ipv6, offset, proto, icmp6_type, m, args, cmd, ip); + comp.loadStub("unreach6"); /* FALLTHROUGH */ #endif case O_DENY: - rule_deny(&l, &done, &retval); + comp.loadStub("deny"); break; case O_FORWARD_IP: - rule_forward_ip(args, q, f, dyn_dir, cmd, tablearg, &retval, &l, &done); + comp.loadStub("forward_ip"); break; #ifdef INET6 case O_FORWARD_IP6: - rule_forward_ip6(args, q, f, dyn_dir, cmd, &retval, &l, &done); + comp.loadStub("forward_ip6"); break; #endif case O_NETGRAPH: case O_NGTEE: - rule_ngtee(args, f_pos, chain, cmd, tablearg, &retval, &l, &done); + comp.loadStub("ngtee"); break; case O_SETFIB: - rule_setfib(f, pktlen, tablearg, cmd, m, args, &l); + comp.loadStub("setfib"); break; case O_SETDSCP: - rule_setdscp(cmd, ip, is_ipv4, is_ipv6, tablearg, f, pktlen, &l); + comp.loadStub("setdscp"); break; case O_NAT: - rule_nat(args, f_pos, chain, cmd, m, tablearg, &retval, &done, &l); + comp.loadStub("nat"); break; case O_REASS: - rule_reass(f, f_pos, chain, pktlen, ip, args, m, &retval, &done, &l); + comp.loadStub("reass"); break; default: @@ -513,7 +554,6 @@ } } /* end of inner loop, scan opcodes */ -#undef PULLUP_LEN if (done) break; @@ -531,46 +571,5 @@ printf("ipfw: ouch!, skip past end of rules, denying packet\n"); } - /* - // Get the stub (prototype) for the cell function - F = Mod->getFunction("cell"); - // Set it to have private linkage, so that it can be removed after being - // inlined. - F->setLinkage(GlobalValue::PrivateLinkage); - // Add an entry basic block to this function and set it - BasicBlock *entry = BasicBlock::Create(C, "entry", F); - B.SetInsertPoint(entry); - // Cache the type of registers - regTy = Type::getInt16Ty(C); - - // Collect the function parameters - auto args = F->arg_begin(); - oldGrid = args++; - newGrid = args++; - width = args++; - height = args++; - x = args++; - y = args++; - - // Create space on the stack for the local registers - for (int i=0 ; i<10 ; i++) - { - a[i] = B.CreateAlloca(regTy); - } - // Create a space on the stack for the current value. This can be - // assigned to, and will be returned at the end. Store the value passed - // as a parameter in this. - v = B.CreateAlloca(regTy); - B.CreateStore(args++, v); - - // Create a load of pointers to the global registers. - Value *gArg = args; - for (int i=0 ; i<10 ; i++) - { - B.CreateStore(ConstantInt::get(regTy, 0), a[i]); - g[i] = B.CreateConstGEP1_32(gArg, i); - } - - */ return (0); }
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201407301740.s6UHetSg091014>