prompt stringlengths 145 7.04k | completion stringlengths 70 6.01k | lang stringclasses 2
values | func_name stringlengths 1 6.74k | n_tokens int64 98 3.8k |
|---|---|---|---|---|
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movl %edi, -ADDR(%rbp)
movq %rsi, -ADDR(%rbp)
cmpl $ADDR, -ADDR(%rbp)
jl L002
jmp L003
leaq ADDR(%rip), %rdi # ADDR
leaq ADDR(%rip), %rsi # ADDR
movl $ADDR, %edx # imm = ADDR
leaq ADDR(%rip), %rcx # ADDR
callq L000
cmpl $ADD... | GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputEr... | C | glfwGetJoystickAxes | 1,100 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movl %edi, -ADDR(%rbp)
leaq -ADDR(%rbp), %rdi
xorl %esi, %esi
movl $ADDR, %edx
callq L000
movq $ADDR, -ADDR(%rbp)
movl -ADDR(%rbp), %edi
leaq -ADDR(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq L002
cmpl $ADDR, %eax
je L003
callq L001
addq $AD... | static void uv__signal_unregister_handler(int signum) {
/* When this function is called, the signal lock must be held. */
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_handler = SIG_DFL;
/* sigaction can only fail with EINVAL or EFAULT; an attempt to deregister a
* signal implies that it was suc... | C | uv__signal_unregister_handler | 328 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp # imm = ADDR
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq ADDR(%rdx), %rax
leaq ADDR(%rsp), %rcx
movq %rax, ADDR(%rcx)
movups (%rdx), %xmm0
movaps %xmm0, (%rcx)
leaq ADDR(%rsp), %rdi
movl $... | static void StringAppendV(string* dst, const char* format, va_list ap) {
// First try with a small fixed size buffer
char space[1024];
// It's possible for methods that use a va_list to invalidate
// the data in it upon use. The fix is to make a copy
// of the structure before using it and use that copy ins... | C++ | re2::StringAppendV(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, __va_list_tag*) | 1,089 |
# This is the assembly code:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq ADDR(%rdi), %rax
movl (%rax), %esi
callq L000
movl %eax, %ebp
movq ADDR(%rbx), %rax
movl ADDR(%rax), %esi
movq %rbx, %rdi
callq L000
movw $ADDR, ADDR(%rbx) # imm = ADDR
movw %bp, ADDR(%rbx)
movw %ax, ADDR(%rbx)
movq %rbx, %rdi
callq ... | static void LJ_FASTCALL recff_math_ldexp(jit_State *J, RecordFFData *rd)
{
TRef tr = lj_ir_tonum(J, J->base[0]);
#if LJ_TARGET_X86ORX64
TRef tr2 = lj_ir_tonum(J, J->base[1]);
#else
TRef tr2 = lj_opt_narrow_toint(J, J->base[1]);
#endif
J->base[0] = emitir(IRTN(IR_LDEXP), tr, tr2);
UNUSED(rd);
}
<｜end▁of▁senten... | C | recff_math_ldexp | 365 |
# This is the assembly code:
movl $ADDR, %eax # imm = ADDR
cmpq $ADDR, %rdx # imm = ADDR
ja L005
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp # imm = ADDR
movq %rdx, %r14
movq %rdi, %rbx
movq ADDR(%rdi), %r12
leaq (%r12,%rdx), %rcx
cmpq $ADDR, %rcx # imm... | int mbedtls_hmac_drbg_reseed( mbedtls_hmac_drbg_context *ctx,
const unsigned char *additional, size_t len )
{
unsigned char seed[MBEDTLS_HMAC_DRBG_MAX_SEED_INPUT];
size_t seedlen;
/* III. Check input length */
if( len > MBEDTLS_HMAC_DRBG_MAX_INPUT ||
ctx->entropy_len + len... | C | mbedtls_hmac_drbg_reseed | 883 |
# This is the assembly code:
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movq %rcx, %r14
movq %rdx, %rbx
testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
testq %r14, %r14
sete %dl
movl $ADDR, %eax
orb %cl, %dl
jne L000
movq %rsp, %rax
movq %rdi, (%rax)
addq %rdi, %rsi
movq %rsi, ADDR(%rax)
movl $ADDR, ADDR(%... | aom_codec_err_t aom_read_obu_header(uint8_t *buffer, size_t buffer_length,
size_t *consumed, ObuHeader *header,
int is_annexb) {
if (buffer_length < 1 || !consumed || !header) return AOM_CODEC_INVALID_PARAM;
// TODO(tomfinegan): Set the error ... | C | aom_read_obu_header | 498 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
testb %al, %al
je L000
movaps %xmm0, -ADDR(%rbp)
movaps %xmm1, -ADDR(%rbp)
movaps %xmm2, -ADDR(%rbp)
movaps %xmm3, -ADDR(%rbp)
movaps %xmm4, -ADDR(%rbp)
movaps %xmm5, -ADDR(%rbp)
movaps %xmm6, -ADDR(%rbp)
movaps %xmm7, -ADDR(%rbp)
movq %r9, -ADDR(... | int NIOFprintf(newtStream_t * stream, const char * format, ...)
{
va_list args;
int result;
va_start(args, format);
result = NIOVfprintf(stream, format, args);
va_end(args);
return result;
}
<｜end▁of▁sentence｜> | C | NIOFprintf | 465 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq ADDR(%rdi), %rax
movq ADDR(%rax), %r14
movq %r14, %rdi
callq L003
movq %rax, %r13
movq %r14, %rdi
callq L003
movq %rax, %r12
movq %r14, %rdi
callq L003
movq %rax, %r15
movzwl ADDR(%rbx), %eax
a... | static void gen_mul(DisasContext *ctx)
{
TCGContext *tcg_ctx = ctx->uc->tcg_ctx;
TCGv_i64 t0 = tcg_temp_new_i64(tcg_ctx);
TCGv_i64 t1 = tcg_temp_new_i64(tcg_ctx);
TCGv t2 = tcg_temp_new(tcg_ctx);
tcg_gen_extu_tl_i64(tcg_ctx, t0, cpu_gpr[rA(ctx->opcode)]);
tcg_gen_extu_tl_i64(tcg_ctx, t1, cpu_gpr... | C | gen_mul | 1,244 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq ADDR(%rsp), %rdi
callq L000
testq %r14, %r14
je L003
cmpb $ADDR, -ADDR(%r15,%r14)
jne L004
leaq ADDR(%rsp), %rax
movq %rax, (%rsp)
leaq ADDR(%rip), %rsi # ADDR
leaq ADDR(%ri... | int mbedtls_pk_parse_public_key( mbedtls_pk_context *ctx,
const unsigned char *key, size_t keylen )
{
int ret;
unsigned char *p;
#if defined(MBEDTLS_PEM_PARSE_C)
size_t len;
mbedtls_pem_context pem;
mbedtls_pem_init( &pem );
/* Avoid calling mbedtls_pem_read_buffer() o... | C | mbedtls_pk_parse_public_key | 825 |
# This is the assembly code:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq ADDR(%rsp), %rdi
movl $ADDR, (%rdi)
movl $ADDR, %esi
movl $ADDR, %edx
movq %rbx, %rcx
callq L000
movq ADDR(%r14), %rdi
movq ADDR(%r14), %rdx
movl $ADDR, %esi
movq %rbx, %rcx
callq L000
movq ADDR(%r14), %r8
cmpq %r8, %rax
... | void
lm_trie_quant_write_bin(lm_trie_quant_t * quant, FILE * fp)
{
/* Before it was quantization type */
int dummy = 1;
fwrite(&dummy, sizeof(dummy), 1, fp);
if (SWAP_LM_TRIE) {
size_t i;
for (i = 0; i < quant->nvalues; ++i) {
float32 value = quant->values[i];
SWA... | C | lm_trie_quant_write_bin | 501 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq L000
movq %r14, ADDR(%r15)
movq %rbx, ADDR(%r15)
movb $ADDR, ADDR(%r15)
movaps ADDR(%rip), %xmm0 # ADDR
movups %xmm0, ADDR(%r15)
leaq ADDR(%rip), %rax # ADDR
addq $ADDR, %rax
movq %rax, (%r15)
movl... | ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex)
: DeathTestImpl(a_statement, a_regex),
child_pid_(-1) {}
<｜end▁of▁sentence｜> | C++ | testing::internal::ForkingDeathTest::ForkingDeathTest(char const*, testing::internal::RE const*) | 263 |
# This is the assembly code:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq ADDR(%rip), %rcx # ADDR
movl $ADDR, %esi # imm = ADDR
movl $ADDR, %edx
callq L002
movl $ADDR, %ebx # imm = ADDR
cmpl $-ADDR, %eax
je L001
movq %rsp, %rsi
movq %r14, %rdi
callq L000
testl %eax, %eax
jne L001
movq (%rsp),... | int
archive_read_support_filter_xz(struct archive *_a)
{
struct archive_read *a = (struct archive_read *)_a;
struct archive_read_filter_bidder *bidder;
archive_check_magic(_a, ARCHIVE_READ_MAGIC,
ARCHIVE_STATE_NEW, "archive_read_support_filter_xz");
if (__archive_read_get_bidder(a, &bidder) != ARCHIVE_OK)
... | C | archive_read_support_filter_xz | 580 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq ADDR(%rdi), %rbx
movl ADDR(%rbx), %ebp
movl ADDR(%rbx), %r15d
movq ADDR(%rbx), %r12
movq ADDR(%rbx), %r14
movq ADDR(%rbx), %r13
leaq ADDR(%rsp), %rsi
movl $ADDR, (%rsi) # imm = ADDR
movq (%rbx), %rdx... | VECTORIZE int fft_segment_fwd(struct mixed_segment *segment){
struct fft_segment_data *data = (struct fft_segment_data *)segment->data;
uint32_t framesize = data->framesize;
uint32_t oversampling = data->oversampling;
float *restrict in_fifo = data->fifo;
float *restrict fft_workspace = data->fft_workspace;
... | C | fft_segment_fwd.avx2.0 | 3,569 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -ADDR(%rbp)
movl %esi, -ADDR(%rbp)
movl %edx, -ADDR(%rbp)
movl %ecx, -ADDR(%rbp)
movl %r8d, -ADDR(%rbp)
movl -ADDR(%rbp), %eax
shrl $ADDR, %eax
andl $ADDR, %eax
shll $ADDR, %eax
movl -ADDR(%rbp), %ecx
shrl $ADDR, %ecx
andl $ADDR, %ecx
shll $ADDR, %ecx
o... | static void fill_MPP_FMT_BGR444(RK_U8 *p, RK_U32 R, RK_U32 G, RK_U32 B, RK_U32 be)
{
// MPP_FMT_BGR444 = ffmpeg: bgr444be
// 16 bit pixel MSB --------> LSB
// (0000,bbbb,gggg,rrrr)
// big endian | byte 0 | byte 1 |
// little endian | byte 1 | byte 0 |
RK_U16 val ... | C | fill_MPP_FMT_BGR444 | 770 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movl %esi, -ADDR(%rbp)
movl %edx, -ADDR(%rbp)
movl %ecx, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq %rax, -ADDR(%rbp)
movl -ADDR(%rbp), %edi
movl -ADDR(%rbp), %esi
callq L000
movq -ADDR(%rbp), %rcx
addl -ADDR(%rbp), %eax
movl %... | uint32_t
CollationWeights::incWeightByOffset(uint32_t weight, int32_t length, int32_t offset) const {
for(;;) {
offset += getWeightByte(weight, length);
if((uint32_t)offset <= maxBytes[length]) {
return setWeightByte(weight, length, offset);
} else {
// Split the offs... | C++ | icu_63::CollationWeights::incWeightByOffset(unsigned int, int, int) const | 896 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movlps %xmm0, ADDR(%rsp)
movq ADDR(%rip), %r13 # ADDR
movq ADDR(%r13), %r15
testl %edx, %edx
je L005
xorl %eax, %eax
cmpq $ADDR, %r14
sbbq %rax, %rax
orq %r14, %rax
cmpq %rbx, %rax
jbe... | void ImGui::RenderText(ImVec2 pos, const char* text, const char* text_end, bool hide_text_after_hash)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
// Hide anything after a '##' string
const char* text_display_end;
if (hide_text_after_hash)
{
text_display_end = Fin... | C++ | ImGui::RenderText(ImVec2, char const*, char const*, bool) | 926 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %rcx, %rdx
jge L005
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
addq $ADDR, %r13
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq L010
cmpq %r15, %rax
jge L007
cmpq %rbx... | int64_t Metric::find_index_on_or_after_binary(TimePoint t, int64_t left, int64_t right, int64_t sz)
{
// left < right means right != 0
// assumes monotonicity ts(left) < ts(right)
// invariant ts(left) < t <= ts(right)
// right can be size() // out of range, but the pivot can never be
assert(left < ... | C++ | hta::storage::file::Metric::find_index_on_or_after_binary(hta::Clock::time_point, long, long, long) | 1,000 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movl %esi, -ADDR(%rbp)
movq %rdx, -ADDR(%rbp)
cmpq $ADDR, -ADDR(%rbp)
jne L002
movl $ADDR, -ADDR(%rbp) # imm = ADDR
jmp L008
movq -ADDR(%rbp), %rdi
movl -ADDR(%rbp), %esi
movq -ADDR(%rbp), %rdx
callq L001
cmpq $ADDR, %rax
jn... | static int
readline(char *line, int line_size, FILE * fp)
{
size_t len;
if(!line) {
return -1;
}
if(!fgets(line, line_size, fp)) {
return -1;
}
if(*line) {
len = strlen(line);
if(len > 0 && line[len - 1] == '\n') {
line[len - 1] = '\0';
}
... | C | readline | 776 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq L001
movq %rax, %r14
leaq ADDR(%rbx), %rdi
leaq ADDR(%rax), %rsi
callq L004
addq $ADDR, %rbx
leaq ADDR(%r14), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq L002
movq %r15, %rdi
callq L003
movq %r14, %rdi
popq %rbx
popq %r14... | void nn_xrep_rm (struct nn_sockbase *self, struct nn_pipe *pipe)
{
struct nn_xrep *xrep;
struct nn_xrep_data *data;
xrep = nn_cont (self, struct nn_xrep, sockbase);
data = nn_pipe_getdata (pipe);
nn_fq_rm (&xrep->inpipes, &data->initem);
nn_hash_erase (&xrep->outpipes, &data->outitem);
nn_... | C | nn_xrep_rm | 334 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movq %rdx, %r14
movq %rdi, %rbx
cmpq $ADDR, ADDR(%rsi)
je L003
leaq -ADDR(%rbp), %r15
movq %r15, %rdi
callq L007
leaq -ADDR(%rbp), %rdi
pushq $ADDR
popq %rdx
movq %r15, %rsi
callq L010
leaq -ADDR(%rbp), %rdi
leaq -... | FilePath FilePath::ConcatPaths(const FilePath& directory,
const FilePath& relative_path) {
if (directory.IsEmpty())
return relative_path;
const FilePath dir(directory.RemoveTrailingPathSeparator());
return FilePath(dir.string() + kPathSeparator + relative_path.string());
}
<｜end... | C++ | testing::internal::FilePath::ConcatPaths(testing::internal::FilePath const&, testing::internal::FilePath const&) | 555 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rsi, -ADDR(%rbp)
movq %rdx, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq -ADDR(%rbp), %rdx
movq %rdi, -ADDR(%rbp)
movq %rdx, -ADDR(%rbp)
movq %rax, -ADDR(%rbp)
movq %rcx, -ADDR(%rbp)
movq -ADDR(%rbp), %rcx
movq -ADDR(%rbp), %rax
movq %rax, -ADDR(... | Result HandleSehExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
#if GTEST_HAS_SEH
__try {
return (object->*method)();
} __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT
GetExceptionCode())) {
// We create the exception message on the h... | C++ | void testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) | 610 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $ADDR, %rsp # imm = ADDR
movl %esi, %r15d
movl %edi, %r12d
leaq ADDR(%rsp), %r14
movl $ADDR, (%r14)
movq ADDR(%rip), %rcx # ADDR
xorl %ebp, %ebp
xorl %eax, %eax
callq *ADDR(%rcx)
movl %eax, %ebx
movq ADDR(%rip), %rax... | RF_INTERNAL unsigned int rf_load_shader_program(unsigned int v_shader_id, unsigned int f_shader_id)
{
unsigned int program = 0;
int success = 0;
program = rf_gl.CreateProgram();
rf_gl.AttachShader(program, v_shader_id);
rf_gl.AttachShader(program, f_shader_id);
// NOTE: Default attribute shad... | C | rf_load_shader_program | 1,919 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movq %rsi, -ADDR(%rbp)
movq %rdx, -ADDR(%rbp)
movq %rcx, -ADDR(%rbp)
movl %r8d, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq %rax, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq ADDR(%rax), %rdi
movq -ADDR(%rbp), %rsi
movq -ADDR(%rbp), ... | static int
tlstran_listener_get(
void *arg, const char *name, void *buf, size_t *szp, nni_type t)
{
int rv;
tlstran_ep *ep = arg;
rv = nni_stream_listener_get(ep->listener, name, buf, szp, t);
if (rv == NNG_ENOTSUP) {
rv = nni_getopt(tlstran_ep_options, name, ep, buf, szp, t);
}
return (rv);
}
<｜en... | C | tlstran_listener_get | 514 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
pushq $ADDR
popq %rdi
callq L004
movq %rax, %rbx
movq %rsp, %r13
movq %r13, %rdi
callq L001
pushq $ADDR
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq L003
movq %rsp, %rd... | void cast_float16_to_float32(const Mat& src, Mat& dst, const Option& opt)
{
Layer* cast = create_layer(LayerType::Cast);
ParamDict pd;
pd.set(0, 2);
pd.set(1, 1);
cast->load_param(pd);
cast->create_pipeline(opt);
cast->forward(src, dst, opt);
cast->destroy_pipeline(opt);
delete... | C++ | ncnn::cast_float16_to_float32(ncnn::Mat const&, ncnn::Mat&, ncnn::Option const&) | 607 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq ADDR(%rsp), %rdx
pushq $ADDR
popq %rcx
callq L008
testl %eax, %eax
je L004
movl %eax, %ebp
addl $ADDR, %ebp # imm = ADDR
jmp L005
movq (%r14), %rax
addq ADDR(%rsp), %rax
m... | static int pk_get_rsapubkey( unsigned char **p,
const unsigned char *end,
mbedtls_rsa_context *rsa )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t len;
if( ( ret = mbedtls_asn1_get_tag( p, end, &len,
MBEDTLS_ASN1_CONSTRUCTED ... | C | pk_get_rsapubkey | 1,422 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movl %edi, -ADDR(%rbp)
movb %al, -ADDR(%rbp)
movl -ADDR(%rbp), %eax
addl $-ADDR, %eax
movl %eax, %ecx
movq %rcx, -ADDR(%rbp)
subl $ADDR, %eax
ja L023
movq -ADDR(%rbp), %rax
leaq ADDR(%rip), %rcx # ADDR
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
... | static enum http_host_state
http_parse_host_char_(enum http_host_state s, const char ch) {
switch(s) {
case s_http_userinfo:
case s_http_userinfo_start:
if (ch == '@') {
return s_http_host_start;
}
if (IS_USERINFO_CHAR(ch)) {
return s_http_userinfo;
}
... | C | http_parse_host_char_ | 2,249 |
# This is the assembly code:
pushq %rbx
cmpl $ADDR, ADDR(%rip) # ADDR
je L005
movq (%rdi), %rbx
movq %rbx, %rdi
callq L002
movl ADDR(%rbx), %eax
leal ADDR(%rax), %ecx
movl %ecx, ADDR(%rbx)
testl %eax, %eax
jne L004
leaq ADDR(%rbx), %rdi
callq L007
movq %rbx, %rdi
popq %rbx
jmp L003
callq L001
testl %eax, %eax
jne L... | void uv_sem_post(uv_sem_t* sem) {
if (platform_needs_custom_semaphore)
uv__custom_sem_post(sem);
else
uv__sem_post(sem);
}
<｜end▁of▁sentence｜> | C | uv_sem_post | 239 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq (%rdi), %rdi
movl $ADDR, %esi
movl $ADDR, %edx
callq L000
leal (%rbx,%r15), %ecx
movl %r15d, (%rax)
movl %r15d, ADDR(%rax)
movl %ecx, ADDR(%rax)
movb $ADDR, ADDR(%rax)
movq %r14, ADDR(%rax)
movq %rbx, ADD... | VerbatimBlockLineComment *Sema::actOnVerbatimBlockLine(SourceLocation Loc,
StringRef Text) {
return new (Allocator) VerbatimBlockLineComment(Loc, Text);
}
<｜end▁of▁sentence｜> | C++ | clang::comments::Sema::actOnVerbatimBlockLine(clang::SourceLocation, llvm::StringRef) | 254 |
# This is the assembly code:
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rax
movq %rdx, %rcx
movq %rsi, %rbx
movq %rdi, %r14
movq ADDR(%rsp), %rdx
testb $ADDR, %dl
jne L002
movq %rcx, %rdi
callq L006
leaq ADDR(%rip), %rsi # ADDR
movq %r14, %rdi
movl %eax, %edx
movq %rbx, %rcx
xorl %eax, %eax
addq $ADDR, %rsp
popq ... | static void scp_source_push_name(
ScpSource *scp, ptrlen pathname, struct fxp_attrs attrs, const char *wc)
{
if (!(attrs.flags & SSH_FILEXFER_ATTR_PERMISSIONS)) {
scp_source_err(scp, "unable to read file permissions for %.*s",
PTRLEN_PRINTF(pathname));
return;
}
if... | C | scp_source_push_name | 692 |
# This is the assembly code:
movq %rdi, -ADDR(%rsp)
movl %esi, -ADDR(%rsp)
movq -ADDR(%rsp), %rax
cmpl $ADDR, (%rax)
jne L000
movl -ADDR(%rsp), %ecx
movq -ADDR(%rsp), %rax
movl %ecx, (%rax)
jmp L002
movq -ADDR(%rsp), %rax
movl (%rax), %eax
cmpl -ADDR(%rsp), %eax
je L001
movl $ADDR, -ADDR(%rsp)
jmp L003
jmp L002
movl $A... | WEBP_NODISCARD static int CheckMemBufferMode(MemBuffer* const mem,
MemBufferMode expected) {
if (mem->mode == MEM_MODE_NONE) {
mem->mode = expected; // switch to the expected mode
} else if (mem->mode != expected) {
return 0; // we mixed the modes => e... | C | CheckMemBufferMode | 314 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
callq L007
movq %rax, (%rbx)
movq %r15, %rdi
callq L001
leaq ADDR(%rax), %r12
movq %r12, %rdi
callq L000
movq %rax, %r14
leaq ADDR(%rip), %rdx # ADDR
movq %rax, %rdi
movq %r12, ... | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | C++ | testing::internal::RE::Init(char const*) | 1,633 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
callq L001
movq %rax, %r14
movq %rax, %rdi
callq L002
testb %al, %al
je L008
movq %r14, %rdi
callq L004
movl %eax, %ebp
movq ADDR(%rbx), %rax
movl %ebp, %edi
callq *ADDR(%rax)
movq %r15, %rdi
movq %rax, %... | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
int32_t imm;
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned Reg = MCOperand_getReg(Op);
printRegName(MI->csh, O, Reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
if (MI->flat_insn->detail->arm.opera... | C | printOperand | 2,529 |
# This is the assembly code:
subq $ADDR, %rsp
movl %edi, ADDR(%rsp)
movb $ADDR, ADDR(%rsp)
leaq ADDR(%rsp), %rdi
movq %rdi, ADDR(%rsp)
callq L009
movq ADDR(%rsp), %rdx
leaq ADDR(%rip), %rsi # ADDR
leaq ADDR(%rsp), %rdi
callq L024
jmp L010
movl ADDR(%rsp), %esi
leaq ADDR(%rsp), %rdi
callq L000
jmp L011
leaq ADDR(%r... | void
testThrowErrnoExc(int err)
{
bool caught = false;
try
{
IEX_INTERNAL_NAMESPACE::throwErrnoExc("err", err);
}
catch (const T& e)
{
caught = true;
}
catch (const std::exception& e)
{
std::cerr << "testThrowErrnoExc: caught " << typeid(e).name()
... | C++ | void (anonymous namespace)::testThrowErrnoExc<Iex_3_2::EshutdownExc>(int) | 1,135 |
# This is the assembly code:
movzbl ADDR(%rdi), %eax
cmpl $ADDR, %eax
jb L000
jne L001
movzwl ADDR(%rdi), %eax
addl $-ADDR, %eax
cmpw $-ADDR, %ax
ja L001
movsd ADDR(%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb L001
movb $ADDR, %al
movsd ADDR(%rip), %xmm1 # ADDR
ucomisd %xmm0, %xmm1
jbe L001
retq
xorl %eax... | ON_SubDFromMeshParameters::ConvexCornerOption ON_SubDFromMeshParameters::GetConvexCornerOption() const
{
switch (m_convex_corner_option)
{
case ON_SubDFromMeshParameters::ConvexCornerOption::Unset:
case ON_SubDFromMeshParameters::ConvexCornerOption::None:
return m_convex_corner_option;
case ON_SubDFromMe... | C++ | ON_SubDFromMeshParameters::GetConvexCornerOption() const | 422 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
testq %rsi, %rsi
je L000
movq ADDR(%rsi), %rdi
callq L007
movq %rax, %r14
jmp L001
xorl %r14d, %r14d
movq %r14, %rdi
movl $ADDR, %esi
callq L005
movl %eax, %r15d
testl %eax, %eax
jns L002
movq %r14, %rdi
... | static __isl_give isl_basic_set *update_enforced(
__isl_take isl_basic_set *enforced, __isl_keep isl_ast_graft *graft,
int depth)
{
isl_size dim;
isl_basic_set *enforced_g;
enforced_g = isl_ast_graft_get_enforced(graft);
dim = isl_basic_set_dim(enforced_g, isl_dim_set);
if (dim < 0)
enforced_g = isl_basic_set... | C | update_enforced | 737 |
# This is the assembly code:
addl $ADDR, %edi # imm = ADDR
cmpl $ADDR, %edi
ja L000
movl %edi, %eax
leaq ADDR(%rip), %rcx # ADDR
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
leaq ADDR(%rip), %rax # ADDR
retq
# What is the source code?
| static const char* getEGLErrorString(EGLint error)
{
switch (error)
{
case EGL_SUCCESS:
return "Success";
case EGL_NOT_INITIALIZED:
return "EGL is not or could not be initialized";
case EGL_BAD_ACCESS:
return "EGL cannot access a requested resource";
... | C | getEGLErrorString | 553 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq ADDR(%rdi), %rax
leal ADDR(%rax), %ecx
movl %ecx, ADDR(%rdi)
cmpq $ADDR, %rax
jl L003
movb $-ADDR, ADDR(%r14,%rax)
movl ADDR(%r14), %eax
cmpl $ADDR, %eax
jg L001
leal ADDR(%rax), %ecx
movl %ecx, ADDR(%r1... | void
nni_sha1_final(nni_sha1_ctx *ctx, uint8_t digest[20])
{
nni_sha1_pad(ctx);
for (int i = 0; i < 5; i++) {
digest[i * 4] = (ctx->digest[i] >> 24) & 0xff;
digest[i * 4 + 1] = (ctx->digest[i] >> 16) & 0xff;
digest[i * 4 + 2] = (ctx->digest[i] >> 8) & 0xff;
digest[i * 4 + 3] = (ctx->digest[i] >> 0) & 0xff... | C | nni_sha1_final | 878 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movl %esi, -ADDR(%rbp)
movq %rdx, -ADDR(%rbp)
movl %ecx, -ADDR(%rbp)
movq %r8, -ADDR(%rbp)
cmpq $ADDR, -ADDR(%rbp)
jl L005
cmpq $ADDR, -ADDR(%rbp)
jle L003
movq -ADDR(%rbp), %rdi
movq -ADDR(%rbp), %rdx
leaq ADDR(%rip), %rsi ... | static void printAddress(MCInst *MI, unsigned Base, int64_t Disp, unsigned Index, SStream *O)
{
if (Disp >= 0) {
if (Disp > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, Disp);
else
SStream_concat(O, "%"PRIu64, Disp);
} else {
if (Disp < -HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -Disp);
else
... | C | printAddress | 2,438 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %r9, %r12
movq %r8, %rbp
movq %rcx, ADDR(%rsp)
movq %rdx, ADDR(%rsp)
movq %rsi, ADDR(%rsp)
movq %rdi, %r15
movslq ADDR(%rsp), %r13
pushq $ADDR
popq %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq L001
movq %r... | static sunbooleantype arkode_butcher_order6i(sunrealtype* b, sunrealtype* c1,
sunrealtype** A1, sunrealtype** A2,
sunrealtype* c2, sunrealtype* c3,
int s)
{
sunrealtype bcAAcc;
sunr... | C | arkode_butcher_order6i | 1,115 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movq %rsi, -ADDR(%rbp)
movq %rdx, -ADDR(%rbp)
movq %rcx, -ADDR(%rbp)
movl %r8d, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq (%rax), %rax
movq %rax, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq ADDR(%rax), %rax
movq %rax, -ADDR(%rbp)
... | CURLcode Curl_add_buffer_send(Curl_send_buffer **inp,
struct connectdata *conn,
/* add the number of sent bytes to this
counter */
curl_off_t *bytes_written,
/* how ... | C | Curl_add_buffer_send | 3,686 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq ADDR(%rax), %rax
movq %rax, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
cmpq $ADDR, ADDR(%rax)
je L003
movq -ADDR(%rbp), %rax
movq ADDR(%rax), %rax
movq -ADDR(%rbp), %rdi
movq -ADDR(%rbp), %rcx
movq ADDR(%... | static int
archive_write_client_free(struct archive_write_filter *f)
{
struct archive_write *a = (struct archive_write *)f->archive;
if (a->client_freer)
(*a->client_freer)(&a->archive, a->client_data);
a->client_data = NULL;
/* Clear passphrase. */
if (a->passphrase != NULL) {
memset(a->passphrase, 0, strle... | C | archive_write_client_free | 587 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movl %edx, %r15d
leal -ADDR(%r15), %eax
cmpl $ADDR, %eax
jae L003
leaq ADDR(%rip), %rdx # ADDR
movq %rsi, %r12
movq (%rsi), %r14
movq ADDR(%rsi), %rcx
movl %eax, %eax
leaq ADDR(%rsp), %r13
movq %rdi, %rbx
movslq (%r... | static op_t get_new_temp (c2m_ctx_t c2m_ctx, MIR_type_t t) {
gen_ctx_t gen_ctx = c2m_ctx->gen_ctx;
MIR_context_t ctx = c2m_ctx->ctx;
char reg_name[50];
MIR_reg_t reg;
assert (t == MIR_T_I64 || t == MIR_T_U64 || t == MIR_T_I32 || t == MIR_T_U32 || t == MIR_T_F
|| t == MIR_T_D || t == MIR_T_LD);
sp... | C | get_new_temp | 845 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq ADDR(%rdi), %rdx
testq %rdx, %rdx
je L008
movq %rdi, %rbx
leaq ADDR(%rdi), %rax
movq %rax, ADDR(%rsp)
movq ADDR(%rdi), %rax
movq ADDR(%rbx), %r15
movq %rax, %rcx
addq %r15, %rcx
je L008
xorl %ecx, %ecx
t... | static void CopyTempOutputBuffersToHostOutputBuffers( PaUtilBufferProcessor *bp)
{
unsigned long maxFramesToCopy;
PaUtilChannelDescriptor *hostOutputChannels;
unsigned int frameCount;
unsigned char *srcBytePtr;
unsigned int srcSampleStrideSamples; /* stride from one sample to the next within a chann... | C | CopyTempOutputBuffersToHostOutputBuffers | 1,591 |
# This is the assembly code:
pushq %rbx
movq %rdi, %rbx
movl ADDR(%rcx), %eax
cmpl $ADDR, %eax
je L001
cmpl $ADDR, %eax
jne L002
movq %rcx, %rax
jmp L003
xorl %eax, %eax
testq %rax, %rax
je L005
movq ADDR(%rdx), %rsi
movl ADDR(%rax), %edx
movq %rbx, %rdi
movq %r8, %rcx
callq L000
jmp L009
cmpl $ADDR, ADDR(%rcx)
jne L00... | static MachinePointerInfo InferPointerInfo(const MachinePointerInfo &Info,
SelectionDAG &DAG, SDValue Ptr,
int64_t Offset = 0) {
// If this is FI+Offset, we can model it.
if (const FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>... | C++ | InferPointerInfo(llvm::MachinePointerInfo const&, llvm::SelectionDAG&, llvm::SDValue, long) | 785 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
subq (%rsi), %rdx
callq L000
testl %eax, %eax
je L002
popq %rbx
popq %r14
popq %r15
retq
leaq ADDR(%r15), %rsi
subq (%r14), %rbx
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp... | int mbedtls_ecdh_read_params( mbedtls_ecdh_context *ctx,
const unsigned char **buf, const unsigned char *end )
{
int ret;
if( ( ret = mbedtls_ecp_tls_read_group( &ctx->grp, buf, end - *buf ) ) != 0 )
return( ret );
if( ( ret = mbedtls_ecp_tls_read_point( &ctx->grp, &ctx->Qp, ... | C | mbedtls_ecdh_read_params | 320 |
# This is the assembly code:
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq L000
cmpq %r14, ADDR(%rbx)
jne L008
movq %rbx, %rdi
movq %rax, %rsi
addq $ADDR, %rsp
popq %rbx
popq %r14
jmp L006
movq ADDR(%rip), %rdi # ADDR
leaq ADDR(%rip), %rsi # ADDR
callq L005
movq %rax, %r14
movq AD... | void end_kernel(std::uint64_t kernid) {
auto end_time = now();
auto expect_node = reinterpret_cast<StackNode*>(kernid);
if (expect_node != stack_frame) {
std::cerr << "Expected \"" << stack_frame->get_full_name()
<< "\" to end, got different kernel ID\n";
abort();
}
en... | C++ | KokkosTools::SpaceTimeStack::State::end_kernel(unsigned long) | 434 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movl ADDR(%rdi), %ebx
movq %rdi, ADDR(%rsp)
subl ADDR(%rdi), %ebx
movl %ebx, %edi
callq L004
movq %rax, ADDR(%rsp)
movl %ebx, %edi
callq L004
movq %rax, %r14
xorl %eax, %eax
leaq ADDR(%rsp), %r15
pushq $ADDR
... | Aig_Man_t * Iso_ManFilterPos_old( Aig_Man_t * pAig, int fVerbose )
{
int fVeryVerbose = 0;
Vec_Ptr_t * vParts, * vPerms, * vAigs;
Vec_Int_t * vPos, * vMap;
Aig_Man_t * pPart, * pTemp;
int i, k, nPos;
// derive AIG for each PO
nPos = Aig_ManCoNum(pAig) - Aig_ManRegNum(pAig);
vP... | C | Iso_ManFilterPos_old | 2,132 |
# This is the assembly code:
pushq %rbx
movq %rdi, %rbx
callq L001
movl $ADDR, %esi
movq %rbx, %rdi
popq %rbx
jmp L000
nop
# What is the source code?
| TEST(TestHarness_c, checkPointerText)
{
CHECK_EQUAL_C_POINTER_TEXT(NULLPTR, NULLPTR, "Text");
fixture->setTestFunction(failPointerTextMethod_);
fixture->runAllTests();
fixture->assertPrintContains("expected <0x0>\n\tbut was <0x1>");
fixture->assertPrintContains("arness_c");
fixture->assertPrint... | C++ | TEST_TestHarness_c_checkPointerText_Test::~TEST_TestHarness_c_checkPointerText_Test() | 194 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
xchgb %al, ADDR(%rdi)
movq %rcx, %rsi
callq L000
cmpb $ADDR, ADDR(%r14)
je L004
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq ... | std::ostream& fail(S text, T curr, Function* func) {
valid.store(false);
auto& stream = getStream(func);
if (quiet) {
return stream;
}
auto& ret = printFailureHeader(func);
ret << text << ", on \n";
return printModuleComponent(curr, ret, wasm);
}
<｜end▁of▁sentence｜> | C++ | std::ostream& wasm::ValidationInfo::fail<wasm::ArrayInitElem*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, wasm::ArrayInitElem*, wasm::Function*) | 432 |
# This is the assembly code:
subq $ADDR, %rsp
leaq ADDR(%rsp), %r10
movq %rcx, ADDR(%r10)
movq %r8, ADDR(%r10)
movq %r9, ADDR(%r10)
testb %al, %al
je L000
movaps %xmm0, ADDR(%rsp)
movaps %xmm1, ADDR(%rsp)
movaps %xmm2, ADDR(%rsp)
movaps %xmm3, ADDR(%rsp)
movaps %xmm4, ADDR(%rsp)
movaps %xmm5, ADDR(%rsp)
movaps %xmm6, A... | int cs_snprintf(char *buffer, size_t size, const char *fmt, ...)
{
int ret;
va_list ap;
va_start(ap, fmt);
ret = cs_vsnprintf(buffer, size, fmt, ap);
va_end(ap);
return ret;
}
<｜end▁of▁sentence｜> | C | cs_snprintf | 376 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %rcx, %r12
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *ADDR(%rax)
leaq ADDR(%rax), %rdi
leaq -ADDR(%rbp), %rsi
movw $ADDR, (%rsi)
movq %r12, %rdx
callq L... | void assignCustomProperty(std::istream& _in, BaseImporter& _bi, VertexHandle _vh, const std::string& _propName)
{
OpenMesh::VPropHandleT<T> prop;
if (!_bi.kernel()->get_property_handle(prop,_propName))
_bi.kernel()->add_property(prop,_propName);
T in;
_in >> in;
_bi.kernel()->property(prop,_vh) = in;
}
<｜... | C++ | void OpenMesh::IO::assignCustomProperty<unsigned short>(std::istream&, OpenMesh::IO::BaseImporter&, OpenMesh::VertexHandle, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 563 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %ebp
movl (%rdx), %eax
imull %ebp, %eax
testl %eax, %eax
js L003
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq L000
jmp L004
movq %r15, %rdi
movq %r14, %rsi
callq L002... | int mbedtls_mpi_add_mpi( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret, s = A->s;
if( A->s * B->s < 0 )
{
if( mbedtls_mpi_cmp_abs( A, B ) >= 0 )
{
MBEDTLS_MPI_CHK( mbedtls_mpi_sub_abs( X, A, B ) );
X->s = s;
}
else
{
... | C | mbedtls_mpi_add_mpi | 564 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp
movq %rdi, -ADDR(%rbp)
movq %rsi, -ADDR(%rbp)
cmpq $ADDR, -ADDR(%rbp)
je L012
cmpq $ADDR, -ADDR(%rbp)
jne L018
jmp L013
callq L010
movq %rax, -ADDR(%rbp)
cmpq $ADDR, -ADDR(%rbp)
je L016
movq -ADDR(%rbp), %rax
movq %rax, -ADDR(%rbp)
movq -ADDR(%rbp... | int x509_openssl_add_certificates(SSL_CTX* ssl_ctx, const char* certificates)
{
int result;
/*Codes_SRS_X509_OPENSSL_02_010: [ If ssl_ctx is NULL then x509_openssl_add_certificates shall fail and return a non-zero value. ]*/
/*Codes_SRS_X509_OPENSSL_02_011: [ If certificates is NULL then x509_openssl_add_c... | C | x509_openssl_add_certificates | 2,960 |
# This is the assembly code:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edx, %eax
andl $ADDR, %eax
cmpl $ADDR, %eax
sete %al
movl $ADDR, %esi
movl %edx, %r14d
andl %esi, %r14d
sete %cl
movl $ADDR, %ebp # imm = ADDR
cmpl %esi, %edx
ja L001
orb %cl, %al
je L001
movq %rbx, %rsi
movl $ADDR, %edx
callq L00... | int uv_tcp_init_ex(uv_loop_t* loop, uv_tcp_t* tcp, unsigned int flags) {
int domain;
/* Use the lower 8 bits for the domain */
domain = flags & 0xFF;
if (domain != AF_INET && domain != AF_INET6 && domain != AF_UNSPEC)
return -EINVAL;
if (flags & ~0xFF)
return -EINVAL;
uv__stream_init(loop, (uv_st... | C | uv_tcp_init_ex | 555 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movq %r8, %r15
movq %rsi, %r14
leaq ADDR(%rsp), %rax
movq %rax, -ADDR(%rax)
andq $ADDR, -ADDR(%rax)
movq %rdi, %rbx
movl %ecx, ADDR(%rsp)
movb $ADDR, (%rax)
testl %ecx, %ecx
je L003
leaq ADDR(%rip), %rax # ADDR
leaq ADDR(%rsp), %rdi
movq... | FilePath FilePath::MakeFileName(const FilePath& directory,
const FilePath& base_name,
int number,
const char* extension) {
std::string file;
if (number == 0) {
file = base_name.string() + "." + extension;
} else {
... | C++ | testing::internal::FilePath::MakeFileName(testing::internal::FilePath const&, testing::internal::FilePath const&, int, char const*) | 1,147 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq ADDR(%rdi), %r14
movq %r14, %rdi
callq L004
movl %eax, ADDR(%rbx)
movq ADDR(%rbx), %rdi
callq L005
movl %eax, ADDR(%rbx)
movslq ADDR(%rbx), %r12
pushq $ADDR
popq %rdi
pushq $ADDR
popq %rsi
call... | static int
archive_write_client_open(struct archive_write_filter *f)
{
struct archive_write *a = (struct archive_write *)f->archive;
struct archive_none *state;
void *buffer;
size_t buffer_size;
int ret;
f->bytes_per_block = archive_write_get_bytes_per_block(f->archive);
f->bytes_in_last_block =
archive_wr... | C | archive_write_client_open | 955 |
# This is the assembly code:
pushq %r14
pushq %rbx
pushq %rax
movq ADDR(%rdi), %r14
movq (%r14), %rbx
cmpq %rdx, %rbx
cmovaeq %rdx, %rbx
movq %rbx, %rdx
callq L000
subq %rbx, (%r14)
cltq
testl %eax, %eax
cmovsq %rax, %rbx
movq %rbx, %rax
addq $ADDR, %rsp
popq %rbx
popq %r14
retq
# What is the source code?
| static ssize_t
archive_write_binary_data(struct archive_write *a, const void *buff, size_t s)
{
struct cpio *cpio;
int ret;
cpio = (struct cpio *)a->format_data;
if (s > cpio->entry_bytes_remaining)
s = (size_t)cpio->entry_bytes_remaining;
ret = __archive_write_output(a, buff, s);
cpio->entry_bytes_remaining ... | C | archive_write_binary_data | 286 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $ADDR, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq ADDR(%rsp), %r14
movups %xmm0, ADDR(%r14)
movaps %xmm0, (%r14)
movq ADDR(%rdi), %r15
movq %r15, %rdi
callq L000
movq %rax, (%r14)
movq %r15, ADDR(%r14)
movq ADDR(%rbx), %rax
... | Result BinaryReaderIR::OnCallExpr(Index func_index) {
return AppendExpr(std::make_unique<CallExpr>(Var(func_index, GetLocation())));
}
<｜end▁of▁sentence｜> | C++ | wabt::(anonymous namespace)::BinaryReaderIR::OnCallExpr(unsigned int) | 624 |
# This is the assembly code:
movq %rdi, -ADDR(%rsp)
movq $ADDR, -ADDR(%rsp)
movq -ADDR(%rsp), %rax
shlq $ADDR, %rax
movq %rax, -ADDR(%rsp)
cmpq $ADDR, %rax
je L000
movq -ADDR(%rsp), %rax
subq $ADDR, %rax
movq %rax, -ADDR(%rsp)
movq -ADDR(%rsp), %rax
movq %rax, -ADDR(%rsp)
movq -ADDR(%rsp), %rax
shlq $ADDR, %rax
movq %r... | size_t FAST(u64CTZ)(register u64 w)
{
register size_t l = 64;
register u64 t;
if (t = w << 32)
l -= 32, w = t;
if (t = w << 16)
l -= 16, w = t;
if (t = w << 8)
l -= 8, w = t;
if (t = w << 4)
l -= 4, w = t;
if (t = w << 2)
l -= 2, w = t;
t = 0;
return ((u64)(w << 1)) ? l - 2 : l - (w ? 1 : 0);
}
<｜end... | C | u64CTZ_fast | 960 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %r8, %r13
movq %rcx, ADDR(%rsp)
movq %rdx, %r14
movq %rsi, ADDR(%rsp)
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, ADDR(%rsp)
movq ADDR(%rdi), %rax
movb ADDR(%rax), %r12b
cmpl $ADDR, ADDR(%r9)
je L01... | MachineBasicBlock::iterator ARMBaseInstrInfo::insertOutlinedCall(
Module &M, MachineBasicBlock &MBB, MachineBasicBlock::iterator &It,
MachineFunction &MF, outliner::Candidate &C) const {
MachineInstrBuilder MIB;
MachineBasicBlock::iterator CallPt;
unsigned Opc;
bool isThumb = Subtarget.isThumb();
// ... | C++ | llvm::ARMBaseInstrInfo::insertOutlinedCall(llvm::Module&, llvm::MachineBasicBlock&, llvm::MachineInstrBundleIterator<llvm::MachineInstr, false>&, llvm::MachineFunction&, llvm::outliner::Candidate&) const | 3,103 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -ADDR(%rbp)
cmpq $ADDR, -ADDR(%rbp)
je L000
movq -ADDR(%rbp), %rax
cmpl $ADDR, ADDR(%rax) # imm = ADDR
je L001
movl $ADDR, -ADDR(%rbp) # imm = ADDR
jmp L006
movl $ADDR, -ADDR(%rbp)
movl $ADDR, -ADDR(%rbp)
movl -ADDR(%rbp), %eax
movq -ADDR(%rbp), %rcx
cm... | int XMLNode_get_children_count(const XMLNode* node)
{
int i, n;
CHECK_NODE(node, -1);
for (i = n = 0; i < node->n_children; i++)
if (node->children[i]->active)
n++;
return n;
}
<｜end▁of▁sentence｜> | C | XMLNode_get_children_count | 473 |
# This is the assembly code:
pushq %rbx
movq %rdi, %rbx
leaq ADDR(%rip), %rsi # ADDR
callq L000
movl $ADDR, ADDR(%rbx)
leaq ADDR(%rip), %rcx # ADDR
movq %rcx, ADDR(%rbx)
popq %rbx
retq
# What is the source code?
| static int
grzip_bidder_init(struct archive_read_filter *self)
{
int r;
r = __archive_read_program(self, "grzip -d");
/* Note: We set the format here even if __archive_read_program()
* above fails. We do, after all, know what the format is
* even if we weren't able to read it. */
self->code = ARCHIVE_FILTER_G... | C | grzip_bidder_init | 216 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movzwl (%rsi), %edi
pushq $ADDR
popq %rsi
callq L008
movswq %ax, %rax
movl %eax, %eax
movq ADDR(%r15), %rcx
shlq $ADDR, %rax
movq ADDR(%rcx,%rax), %r12
movl %r12d, %r15d
movq %r14, %rdi
ca... | void AMDGPUInstPrinter::printSymbolicFormat(const MCInst *MI,
const MCSubtargetInfo &STI,
raw_ostream &O) {
using namespace llvm::AMDGPU::MTBUFFormat;
int OpNo =
AMDGPU::getNamedOperandIdx(MI->getOpcode(), AMDGPU::OpName::f... | C++ | llvm::AMDGPUInstPrinter::printSymbolicFormat(llvm::MCInst const*, llvm::MCSubtargetInfo const&, llvm::raw_ostream&) | 1,179 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
cmpl $ADDR, ADDR(%rip) # ADDR
sete %al
cmpl $ADDR, %edi
setae %cl
orb %al, %cl
jne L002
movl %ebx, %eax
leaq ADDR(%rip), %rcx # ADDR
movslq (%rcx,%rax,4), %r14
addq %rcx, %r14
callq L001
movq (%rax), %r15
callq L000
movq (%rax), %rdi
... | void
xmlCatalogSetDefaults(xmlCatalogAllow allow) {
if (xmlDebugCatalogs) {
switch (allow) {
case XML_CATA_ALLOW_NONE:
xmlGenericError(xmlGenericErrorContext,
"Disabling catalog usage\n");
break;
case XML_CATA_ALLOW_GLOBAL:
xmlGenericError(xmlGenericErrorContext,
"Allowing only global catalog... | C | xmlCatalogSetDefaults | 399 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp # imm = ADDR
movq %rdi, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq %rax, -ADDR(%rbp)
leaq -ADDR(%rbp), %rdi
movq %rdi, -ADDR(%rbp)
callq L003
movq -ADDR(%rbp), %rdx
leaq ADDR(%rip), %rsi # ADDR
leaq -ADDR(%rbp), %rdi
callq L006
jmp L014... | void
QPDFObjectHandle::coalesceContentStreams()
{
QPDFObjectHandle contents = this->getKey("/Contents");
if (contents.isStream()) {
QTC::TC("qpdf", "QPDFObjectHandle coalesce called on stream");
return;
} else if (!contents.isArray()) {
// /Contents is optional for pages, and some ve... | C++ | QPDFObjectHandle::coalesceContentStreams() | 2,710 |
# This is the assembly code:
pushq %rbx
movq %rdi, %rbx
leaq ADDR(%rip), %rax # ADDR
movq ADDR(%rax), %rdi
movl ADDR(%rax), %esi
callq *ADDR(%rax)
testq %rax, %rax
je L001
movq %rbx, %rdi
movq %rax, %rsi
callq L000
testl %eax, %eax
je L001
pushq $ADDR
popq %rax
jmp L002
xorl %eax, %eax
popq %rbx
retq
# What is th... | int _glfwPlatformExtensionSupported(const char* extension)
{
const char* extensions =
_glfw_glXQueryExtensionsString(_glfw.x11.display, _glfw.x11.screen);
if (extensions)
{
if (_glfwStringInExtensionString(extension, extensions))
return GL_TRUE;
}
return GL_FALSE;
}
<｜en... | C | glfwPlatformExtensionSupported | 240 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
cmpb $ADDR, ADDR(%rdi)
je L023
addq $ADDR, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
movq ADDR(%rdi), %rcx
movq ADDR(%rdi), %rax
cmpq ADDR(%rcx), %rax
je L025
cmpl ... | inline_t void Parser::ParsePropertyDeclaration(VisibilityType scope, bool readOnly)
{
if (m_error)
return;
if (m_currentSymbol == m_symbolList.end())
{
Error("Unexpected end of script when parsing property declaration");
return;
}
if (m_currentSymbol->type != SymbolType::NameValue)
{
Error("Un... | C++ | Jinx::Impl::Parser::ParsePropertyDeclaration(Jinx::Impl::VisibilityType, bool) | 2,434 |
# This is the assembly code:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp # imm = ADDR
leaq ADDR(%rip), %rax # ADDR
movl ADDR(%rax), %edi
leaq ADDR(%rsp), %rsi
movl $ADDR, %edx # imm = ADDR
callq L001
testq %rax, %rax
jle L012
movq %rax, %r13
movl $ADDR, %r... | void _glfwDetectJoystickConnectionLinux(void)
{
ssize_t offset = 0;
char buffer[16384];
const ssize_t size = read(_glfw.linjs.inotify, buffer, sizeof(buffer));
while (size > offset)
{
regmatch_t match;
const struct inotify_event* e = (struct inotify_event*) (buffer + offset);
... | C | glfwDetectJoystickConnectionLinux | 1,056 |
# This is the assembly code:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq ADDR(%rdi), %rcx
movq ADDR(%rdi), %rsi
addq %rcx, %rsi
incq %rcx
xorl %edx, %edx
movabsq $ADDR, %rdi # imm = ADDR
movzbl (%rsi,%rdx), %r8d
cmpq $ADDR, %r8
ja L002
je L003
btq %r8, %rdi
jb L016
leaq (%rcx,%rdx), %r8
movq %... | void FlagParser::parse_flag(const char *env_option_name) {
uptr name_start = pos_;
while (buf_[pos_] != 0 && buf_[pos_] != '=' && !is_space(buf_[pos_])) ++pos_;
if (buf_[pos_] != '=') {
if (env_option_name) {
Printf("%s: ERROR: expected '=' in %s\n", SanitizerToolName,
env_option_name);
... | C++ | _sanitizer::FlagParser::parse_flag(char const*) | 1,618 |
# This is the assembly code:
cmpb $ADDR, ADDR(%rdi)
jne L006
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %rdi, %rbx
callq L001
movq ADDR(%rip), %r14 # ADDR
movq %rbx, ADDR(%r14)
callq L001
movq ADDR(%rip), %rax # ADDR
movq ADDR(%rax), %r15
movq (%r15), %rax
movq %r15,... | void TestInfo::Run() {
if (!should_run_) return;
// Tells UnitTest where to store test result.
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->set_current_test_info(this);
TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater();
// Notifies the unit test even... | C++ | testing::TestInfo::Run() | 1,245 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp # imm = ADDR
movq %rdi, -ADDR(%rbp)
movq %rsi, -ADDR(%rbp)
movq -ADDR(%rbp), %rax
movq %rax, -ADDR(%rbp)
movq -ADDR(%rbp), %rsi
leaq -ADDR(%rbp), %rdi
movq %rdi, -ADDR(%rbp)
callq L040
movq -ADDR(%rbp), %rsi
leaq -ADDR(%rbp), %rdi
callq... | bool cmTargetTraceDependencies::IsUtility(std::string const& dep)
{
// Dependencies on targets (utilities) are supposed to be named by
// just the target name. However for compatibility we support
// naming the output file generated by the target (assuming there is
// no output-name property which old code wou... | C++ | cmTargetTraceDependencies::IsUtility(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | 2,389 |
# This is the assembly code:
pushq %rax
movq %rsi, %rdx
leaq ADDR(%rip), %rsi # ADDR
xorl %eax, %eax
callq L000
testl %eax, %eax
js L002
je L003
leaq ADDR(%rip), %rax # ADDR
jmp L005
leaq ADDR(%rip), %rdi # ADDR
jmp L004
leaq ADDR(%rip), %rdi # ADDR
xorl %eax, %eax
callq L001
leaq ADDR(%rip), %rax ... | const char* ScanInt(FILE* out, int* a) {
int status = fscanf(out, "%d", a);
if (status < 0) {
PrintWithoutBuffering("output too short -- ");
return Fail;
} else if (status < 1) {
PrintWithoutBuffering("bad output format -- ");
return Fail;
}
return Pass;
}
<｜end▁of▁se... | C | ScanInt | 246 |
# This is the assembly code:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq L000
testb %al, %al
je L001
movq %rbx, %rdi
callq L010
movq ADDR(%rbx), %rcx
cmpl $ADDR, %eax
jne L002
cmpq $ADDR, %rcx
jne L004
movq ADDR(%rbx), %rax
movq ADDR(%rax), %rax
jmp L003
movq %rbx, %rdi
movq %... | void visit(const T& expr) {
if constexpr (std::is_base_of_v<Expression, T>) {
if (ClockInference::isSampledValueFuncCall(expr)) {
auto& call = expr.template as<CallExpression>();
bool hasClock;
if (call.getKnownSystemName() == KnownSystemName::Past) {
... | C++ | void slang::analysis::SampledValueFuncVisitor::visit<slang::ast::StructuredAssignmentPatternExpression>(slang::ast::StructuredAssignmentPatternExpression const&) | 640 |
# This is the assembly code:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $ADDR, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, ADDR(%rsp)
movq %rsi, %rdi
callq L007
movq %rax, (%rbx)
movq %r15, %rdi
callq L001
leaq ADDR(%rax), %r12
movq %r12, %rdi
callq L000
movq %rax, %r14
leaq ADDR(%rip), %rdx # ADDR
movq ... | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | C++ | testing::internal::RE::Init(char const*) | 1,356 |
# This is the assembly code:
pushq %rbp
movq %rsp, %rbp
subq $ADDR, %rsp # imm = ADDR
movq %rdi, -ADDR(%rbp)
movq %rdi, %rax
movq %rax, -ADDR(%rbp)
movq %rdi, -ADDR(%rbp)
movq %rsi, -ADDR(%rbp)
movl $ADDR, -ADDR(%rbp) # imm = ADDR
movb $ADDR, -ADDR(%rbp)
callq L004
movq -ADDR(%rbp), %rsi
leaq ADDR(%rip), %... | static string ReadFileIntoString(const char* filename) {
const int kBufSize = 8092;
char buffer[kBufSize];
string s;
FILE* fp;
if ((errno = SafeFOpen(&fp, filename, "r")) != 0) PFATAL(filename);
size_t n;
while ( (n=fread(buffer, 1, kBufSize, fp)) > 0 ) {
if (ferror(fp)) PFATAL(filename);
s.appen... | C++ | gflags::(anonymous namespace)::ReadFileIntoString[abi:cxx11](char const*) | 965 |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 53