id
int32 0
27.3k
| func
stringlengths 26
142k
| target
bool 2
classes | project
stringclasses 2
values | commit_id
stringlengths 40
40
| func_clean
stringlengths 26
131k
| vul_lines
dict | normalized_func
stringlengths 24
132k
| lines
listlengths 1
2.8k
| label
listlengths 1
2.8k
| line_no
listlengths 1
2.8k
|
|---|---|---|---|---|---|---|---|---|---|---|
12,717 | static int usb_qdev_init(DeviceState *qdev)
{
USBDevice *dev = USB_DEVICE(qdev);
int rc;
pstrcpy(dev->product_desc, sizeof(dev->product_desc),
usb_device_get_product_desc(dev));
dev->auto_attach = 1;
QLIST_INIT(&dev->strings);
usb_ep_init(dev);
rc = usb_claim_port(dev);
if (rc != 0) {
return rc;
}
rc = usb_device_init(dev);
if (rc != 0) {
usb_release_port(dev);
return rc;
}
if (dev->auto_attach) {
rc = usb_device_attach(dev);
if (rc != 0) {
usb_qdev_exit(qdev);
return rc;
}
}
return 0;
}
| false | qemu | 7d553f27fce284805d7f94603932045ee3bbb979 | static int usb_qdev_init(DeviceState *qdev)
{
USBDevice *dev = USB_DEVICE(qdev);
int rc;
pstrcpy(dev->product_desc, sizeof(dev->product_desc),
usb_device_get_product_desc(dev));
dev->auto_attach = 1;
QLIST_INIT(&dev->strings);
usb_ep_init(dev);
rc = usb_claim_port(dev);
if (rc != 0) {
return rc;
}
rc = usb_device_init(dev);
if (rc != 0) {
usb_release_port(dev);
return rc;
}
if (dev->auto_attach) {
rc = usb_device_attach(dev);
if (rc != 0) {
usb_qdev_exit(qdev);
return rc;
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(DeviceState *VAR_0)
{
USBDevice *dev = USB_DEVICE(VAR_0);
int VAR_1;
pstrcpy(dev->product_desc, sizeof(dev->product_desc),
usb_device_get_product_desc(dev));
dev->auto_attach = 1;
QLIST_INIT(&dev->strings);
usb_ep_init(dev);
VAR_1 = usb_claim_port(dev);
if (VAR_1 != 0) {
return VAR_1;
}
VAR_1 = usb_device_init(dev);
if (VAR_1 != 0) {
usb_release_port(dev);
return VAR_1;
}
if (dev->auto_attach) {
VAR_1 = usb_device_attach(dev);
if (VAR_1 != 0) {
usb_qdev_exit(VAR_0);
return VAR_1;
}
}
return 0;
}
| [
"static int FUNC_0(DeviceState *VAR_0)\n{",
"USBDevice *dev = USB_DEVICE(VAR_0);",
"int VAR_1;",
"pstrcpy(dev->product_desc, sizeof(dev->product_desc),\nusb_device_get_product_desc(dev));",
"dev->auto_attach = 1;",
"QLIST_INIT(&dev->strings);",
"usb_ep_init(dev);",
"VAR_1 = usb_claim_port(dev);",
"if (VAR_1 != 0) {",
"return VAR_1;",
"}",
"VAR_1 = usb_device_init(dev);",
"if (VAR_1 != 0) {",
"usb_release_port(dev);",
"return VAR_1;",
"}",
"if (dev->auto_attach) {",
"VAR_1 = usb_device_attach(dev);",
"if (VAR_1 != 0) {",
"usb_qdev_exit(VAR_0);",
"return VAR_1;",
"}",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
]
]
|
12,719 | static void free_test_data(test_data *data)
{
AcpiSdtTable *temp;
int i;
if (data->rsdt_tables_addr) {
g_free(data->rsdt_tables_addr);
}
for (i = 0; i < data->tables->len; ++i) {
temp = &g_array_index(data->tables, AcpiSdtTable, i);
if (temp->aml) {
g_free(temp->aml);
}
if (temp->aml_file) {
if (!temp->tmp_files_retain &&
g_strstr_len(temp->aml_file, -1, "aml-")) {
unlink(temp->aml_file);
}
g_free(temp->aml_file);
}
if (temp->asl) {
g_free(temp->asl);
}
if (temp->asl_file) {
if (!temp->tmp_files_retain) {
unlink(temp->asl_file);
}
g_free(temp->asl_file);
}
}
g_array_free(data->tables, false);
}
| false | qemu | ef1e1e0782e99c9dcf2b35e5310cdd8ca9211374 | static void free_test_data(test_data *data)
{
AcpiSdtTable *temp;
int i;
if (data->rsdt_tables_addr) {
g_free(data->rsdt_tables_addr);
}
for (i = 0; i < data->tables->len; ++i) {
temp = &g_array_index(data->tables, AcpiSdtTable, i);
if (temp->aml) {
g_free(temp->aml);
}
if (temp->aml_file) {
if (!temp->tmp_files_retain &&
g_strstr_len(temp->aml_file, -1, "aml-")) {
unlink(temp->aml_file);
}
g_free(temp->aml_file);
}
if (temp->asl) {
g_free(temp->asl);
}
if (temp->asl_file) {
if (!temp->tmp_files_retain) {
unlink(temp->asl_file);
}
g_free(temp->asl_file);
}
}
g_array_free(data->tables, false);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(test_data *VAR_0)
{
AcpiSdtTable *temp;
int VAR_1;
if (VAR_0->rsdt_tables_addr) {
g_free(VAR_0->rsdt_tables_addr);
}
for (VAR_1 = 0; VAR_1 < VAR_0->tables->len; ++VAR_1) {
temp = &g_array_index(VAR_0->tables, AcpiSdtTable, VAR_1);
if (temp->aml) {
g_free(temp->aml);
}
if (temp->aml_file) {
if (!temp->tmp_files_retain &&
g_strstr_len(temp->aml_file, -1, "aml-")) {
unlink(temp->aml_file);
}
g_free(temp->aml_file);
}
if (temp->asl) {
g_free(temp->asl);
}
if (temp->asl_file) {
if (!temp->tmp_files_retain) {
unlink(temp->asl_file);
}
g_free(temp->asl_file);
}
}
g_array_free(VAR_0->tables, false);
}
| [
"static void FUNC_0(test_data *VAR_0)\n{",
"AcpiSdtTable *temp;",
"int VAR_1;",
"if (VAR_0->rsdt_tables_addr) {",
"g_free(VAR_0->rsdt_tables_addr);",
"}",
"for (VAR_1 = 0; VAR_1 < VAR_0->tables->len; ++VAR_1) {",
"temp = &g_array_index(VAR_0->tables, AcpiSdtTable, VAR_1);",
"if (temp->aml) {",
"g_free(temp->aml);",
"}",
"if (temp->aml_file) {",
"if (!temp->tmp_files_retain &&\ng_strstr_len(temp->aml_file, -1, \"aml-\")) {",
"unlink(temp->aml_file);",
"}",
"g_free(temp->aml_file);",
"}",
"if (temp->asl) {",
"g_free(temp->asl);",
"}",
"if (temp->asl_file) {",
"if (!temp->tmp_files_retain) {",
"unlink(temp->asl_file);",
"}",
"g_free(temp->asl_file);",
"}",
"}",
"g_array_free(VAR_0->tables, false);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31,
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
]
]
|
12,720 | static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
QObject *obj;
obj = parse_object(ctxt, tokens, ap);
if (obj == NULL) {
obj = parse_array(ctxt, tokens, ap);
}
if (obj == NULL) {
obj = parse_escape(ctxt, tokens, ap);
}
if (obj == NULL) {
obj = parse_keyword(ctxt, tokens);
}
if (obj == NULL) {
obj = parse_literal(ctxt, tokens);
}
return obj;
}
| false | qemu | 65c0f1e9558c7c762cdb333406243fff1d687117 | static QObject *parse_value(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
QObject *obj;
obj = parse_object(ctxt, tokens, ap);
if (obj == NULL) {
obj = parse_array(ctxt, tokens, ap);
}
if (obj == NULL) {
obj = parse_escape(ctxt, tokens, ap);
}
if (obj == NULL) {
obj = parse_keyword(ctxt, tokens);
}
if (obj == NULL) {
obj = parse_literal(ctxt, tokens);
}
return obj;
}
| {
"code": [],
"line_no": []
} | static QObject *FUNC_0(JSONParserContext *ctxt, QList **tokens, va_list *ap)
{
QObject *obj;
obj = parse_object(ctxt, tokens, ap);
if (obj == NULL) {
obj = parse_array(ctxt, tokens, ap);
}
if (obj == NULL) {
obj = parse_escape(ctxt, tokens, ap);
}
if (obj == NULL) {
obj = parse_keyword(ctxt, tokens);
}
if (obj == NULL) {
obj = parse_literal(ctxt, tokens);
}
return obj;
}
| [
"static QObject *FUNC_0(JSONParserContext *ctxt, QList **tokens, va_list *ap)\n{",
"QObject *obj;",
"obj = parse_object(ctxt, tokens, ap);",
"if (obj == NULL) {",
"obj = parse_array(ctxt, tokens, ap);",
"}",
"if (obj == NULL) {",
"obj = parse_escape(ctxt, tokens, ap);",
"}",
"if (obj == NULL) {",
"obj = parse_keyword(ctxt, tokens);",
"}",
"if (obj == NULL) {",
"obj = parse_literal(ctxt, tokens);",
"}",
"return obj;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
]
]
|
12,721 | static void ich_ahci_register(void)
{
type_register_static(&ich_ahci_info);
type_register_static_alias(&ich_ahci_info, "ahci");
}
| false | qemu | 6acbe4c6f18e7de00481ff30574262b58526de45 | static void ich_ahci_register(void)
{
type_register_static(&ich_ahci_info);
type_register_static_alias(&ich_ahci_info, "ahci");
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
type_register_static(&ich_ahci_info);
type_register_static_alias(&ich_ahci_info, "ahci");
}
| [
"static void FUNC_0(void)\n{",
"type_register_static(&ich_ahci_info);",
"type_register_static_alias(&ich_ahci_info, \"ahci\");",
"}"
]
| [
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
]
]
|
12,722 | static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int is_write)
{
QCowAIOCB *acb;
acb = qemu_aio_get(&qcow_aio_pool, bs, cb, opaque);
if (!acb)
return NULL;
acb->hd_aiocb = NULL;
acb->sector_num = sector_num;
acb->qiov = qiov;
if (qiov->niov > 1) {
acb->buf = acb->orig_buf = qemu_blockalign(bs, qiov->size);
if (is_write)
qemu_iovec_to_buffer(qiov, acb->buf);
} else {
acb->buf = (uint8_t *)qiov->iov->iov_base;
}
acb->nb_sectors = nb_sectors;
acb->n = 0;
acb->cluster_offset = 0;
acb->l2meta.nb_clusters = 0;
LIST_INIT(&acb->l2meta.dependent_requests);
return acb;
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static QCowAIOCB *qcow_aio_setup(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int is_write)
{
QCowAIOCB *acb;
acb = qemu_aio_get(&qcow_aio_pool, bs, cb, opaque);
if (!acb)
return NULL;
acb->hd_aiocb = NULL;
acb->sector_num = sector_num;
acb->qiov = qiov;
if (qiov->niov > 1) {
acb->buf = acb->orig_buf = qemu_blockalign(bs, qiov->size);
if (is_write)
qemu_iovec_to_buffer(qiov, acb->buf);
} else {
acb->buf = (uint8_t *)qiov->iov->iov_base;
}
acb->nb_sectors = nb_sectors;
acb->n = 0;
acb->cluster_offset = 0;
acb->l2meta.nb_clusters = 0;
LIST_INIT(&acb->l2meta.dependent_requests);
return acb;
}
| {
"code": [],
"line_no": []
} | static QCowAIOCB *FUNC_0(BlockDriverState *bs,
int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque, int is_write)
{
QCowAIOCB *acb;
acb = qemu_aio_get(&qcow_aio_pool, bs, cb, opaque);
if (!acb)
return NULL;
acb->hd_aiocb = NULL;
acb->sector_num = sector_num;
acb->qiov = qiov;
if (qiov->niov > 1) {
acb->buf = acb->orig_buf = qemu_blockalign(bs, qiov->size);
if (is_write)
qemu_iovec_to_buffer(qiov, acb->buf);
} else {
acb->buf = (uint8_t *)qiov->iov->iov_base;
}
acb->nb_sectors = nb_sectors;
acb->n = 0;
acb->cluster_offset = 0;
acb->l2meta.nb_clusters = 0;
LIST_INIT(&acb->l2meta.dependent_requests);
return acb;
}
| [
"static QCowAIOCB *FUNC_0(BlockDriverState *bs,\nint64_t sector_num, QEMUIOVector *qiov, int nb_sectors,\nBlockDriverCompletionFunc *cb, void *opaque, int is_write)\n{",
"QCowAIOCB *acb;",
"acb = qemu_aio_get(&qcow_aio_pool, bs, cb, opaque);",
"if (!acb)\nreturn NULL;",
"acb->hd_aiocb = NULL;",
"acb->sector_num = sector_num;",
"acb->qiov = qiov;",
"if (qiov->niov > 1) {",
"acb->buf = acb->orig_buf = qemu_blockalign(bs, qiov->size);",
"if (is_write)\nqemu_iovec_to_buffer(qiov, acb->buf);",
"} else {",
"acb->buf = (uint8_t *)qiov->iov->iov_base;",
"}",
"acb->nb_sectors = nb_sectors;",
"acb->n = 0;",
"acb->cluster_offset = 0;",
"acb->l2meta.nb_clusters = 0;",
"LIST_INIT(&acb->l2meta.dependent_requests);",
"return acb;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
]
]
|
12,723 | static inline uint64_t vtd_iova_limit(VTDContextEntry *ce)
{
uint32_t ce_agaw = vtd_ce_get_agaw(ce);
return 1ULL << MIN(ce_agaw, VTD_MGAW);
}
| false | qemu | 37f51384ae05bd50f83308339dbffa3e78404874 | static inline uint64_t vtd_iova_limit(VTDContextEntry *ce)
{
uint32_t ce_agaw = vtd_ce_get_agaw(ce);
return 1ULL << MIN(ce_agaw, VTD_MGAW);
}
| {
"code": [],
"line_no": []
} | static inline uint64_t FUNC_0(VTDContextEntry *ce)
{
uint32_t ce_agaw = vtd_ce_get_agaw(ce);
return 1ULL << MIN(ce_agaw, VTD_MGAW);
}
| [
"static inline uint64_t FUNC_0(VTDContextEntry *ce)\n{",
"uint32_t ce_agaw = vtd_ce_get_agaw(ce);",
"return 1ULL << MIN(ce_agaw, VTD_MGAW);",
"}"
]
| [
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
]
]
|
12,725 | MigrationInfo *qmp_query_migrate(Error **errp)
{
MigrationInfo *info = g_malloc0(sizeof(*info));
MigrationState *s = migrate_get_current();
switch (s->state) {
case MIGRATION_STATUS_NONE:
/* no migration has happened ever */
break;
case MIGRATION_STATUS_SETUP:
info->has_status = true;
info->status = MIGRATION_STATUS_SETUP;
info->has_total_time = false;
break;
case MIGRATION_STATUS_ACTIVE:
case MIGRATION_STATUS_CANCELLING:
info->has_status = true;
info->status = MIGRATION_STATUS_ACTIVE;
info->has_total_time = true;
info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
- s->total_time;
info->has_expected_downtime = true;
info->expected_downtime = s->expected_downtime;
info->has_setup_time = true;
info->setup_time = s->setup_time;
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_bytes_transferred();
info->ram->remaining = ram_bytes_remaining();
info->ram->total = ram_bytes_total();
info->ram->duplicate = dup_mig_pages_transferred();
info->ram->skipped = skipped_mig_pages_transferred();
info->ram->normal = norm_mig_pages_transferred();
info->ram->normal_bytes = norm_mig_bytes_transferred();
info->ram->dirty_pages_rate = s->dirty_pages_rate;
info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count;
if (blk_mig_active()) {
info->has_disk = true;
info->disk = g_malloc0(sizeof(*info->disk));
info->disk->transferred = blk_mig_bytes_transferred();
info->disk->remaining = blk_mig_bytes_remaining();
info->disk->total = blk_mig_bytes_total();
}
get_xbzrle_cache_stats(info);
break;
case MIGRATION_STATUS_COMPLETED:
get_xbzrle_cache_stats(info);
info->has_status = true;
info->status = MIGRATION_STATUS_COMPLETED;
info->has_total_time = true;
info->total_time = s->total_time;
info->has_downtime = true;
info->downtime = s->downtime;
info->has_setup_time = true;
info->setup_time = s->setup_time;
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_bytes_transferred();
info->ram->remaining = 0;
info->ram->total = ram_bytes_total();
info->ram->duplicate = dup_mig_pages_transferred();
info->ram->skipped = skipped_mig_pages_transferred();
info->ram->normal = norm_mig_pages_transferred();
info->ram->normal_bytes = norm_mig_bytes_transferred();
info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count;
break;
case MIGRATION_STATUS_FAILED:
info->has_status = true;
info->status = MIGRATION_STATUS_FAILED;
break;
case MIGRATION_STATUS_CANCELLED:
info->has_status = true;
info->status = MIGRATION_STATUS_CANCELLED;
break;
}
return info;
}
| false | qemu | cde63fbed86e20dda98bf35025faedd994918f00 | MigrationInfo *qmp_query_migrate(Error **errp)
{
MigrationInfo *info = g_malloc0(sizeof(*info));
MigrationState *s = migrate_get_current();
switch (s->state) {
case MIGRATION_STATUS_NONE:
break;
case MIGRATION_STATUS_SETUP:
info->has_status = true;
info->status = MIGRATION_STATUS_SETUP;
info->has_total_time = false;
break;
case MIGRATION_STATUS_ACTIVE:
case MIGRATION_STATUS_CANCELLING:
info->has_status = true;
info->status = MIGRATION_STATUS_ACTIVE;
info->has_total_time = true;
info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
- s->total_time;
info->has_expected_downtime = true;
info->expected_downtime = s->expected_downtime;
info->has_setup_time = true;
info->setup_time = s->setup_time;
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_bytes_transferred();
info->ram->remaining = ram_bytes_remaining();
info->ram->total = ram_bytes_total();
info->ram->duplicate = dup_mig_pages_transferred();
info->ram->skipped = skipped_mig_pages_transferred();
info->ram->normal = norm_mig_pages_transferred();
info->ram->normal_bytes = norm_mig_bytes_transferred();
info->ram->dirty_pages_rate = s->dirty_pages_rate;
info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count;
if (blk_mig_active()) {
info->has_disk = true;
info->disk = g_malloc0(sizeof(*info->disk));
info->disk->transferred = blk_mig_bytes_transferred();
info->disk->remaining = blk_mig_bytes_remaining();
info->disk->total = blk_mig_bytes_total();
}
get_xbzrle_cache_stats(info);
break;
case MIGRATION_STATUS_COMPLETED:
get_xbzrle_cache_stats(info);
info->has_status = true;
info->status = MIGRATION_STATUS_COMPLETED;
info->has_total_time = true;
info->total_time = s->total_time;
info->has_downtime = true;
info->downtime = s->downtime;
info->has_setup_time = true;
info->setup_time = s->setup_time;
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_bytes_transferred();
info->ram->remaining = 0;
info->ram->total = ram_bytes_total();
info->ram->duplicate = dup_mig_pages_transferred();
info->ram->skipped = skipped_mig_pages_transferred();
info->ram->normal = norm_mig_pages_transferred();
info->ram->normal_bytes = norm_mig_bytes_transferred();
info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count;
break;
case MIGRATION_STATUS_FAILED:
info->has_status = true;
info->status = MIGRATION_STATUS_FAILED;
break;
case MIGRATION_STATUS_CANCELLED:
info->has_status = true;
info->status = MIGRATION_STATUS_CANCELLED;
break;
}
return info;
}
| {
"code": [],
"line_no": []
} | MigrationInfo *FUNC_0(Error **errp)
{
MigrationInfo *info = g_malloc0(sizeof(*info));
MigrationState *s = migrate_get_current();
switch (s->state) {
case MIGRATION_STATUS_NONE:
break;
case MIGRATION_STATUS_SETUP:
info->has_status = true;
info->status = MIGRATION_STATUS_SETUP;
info->has_total_time = false;
break;
case MIGRATION_STATUS_ACTIVE:
case MIGRATION_STATUS_CANCELLING:
info->has_status = true;
info->status = MIGRATION_STATUS_ACTIVE;
info->has_total_time = true;
info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)
- s->total_time;
info->has_expected_downtime = true;
info->expected_downtime = s->expected_downtime;
info->has_setup_time = true;
info->setup_time = s->setup_time;
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_bytes_transferred();
info->ram->remaining = ram_bytes_remaining();
info->ram->total = ram_bytes_total();
info->ram->duplicate = dup_mig_pages_transferred();
info->ram->skipped = skipped_mig_pages_transferred();
info->ram->normal = norm_mig_pages_transferred();
info->ram->normal_bytes = norm_mig_bytes_transferred();
info->ram->dirty_pages_rate = s->dirty_pages_rate;
info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count;
if (blk_mig_active()) {
info->has_disk = true;
info->disk = g_malloc0(sizeof(*info->disk));
info->disk->transferred = blk_mig_bytes_transferred();
info->disk->remaining = blk_mig_bytes_remaining();
info->disk->total = blk_mig_bytes_total();
}
get_xbzrle_cache_stats(info);
break;
case MIGRATION_STATUS_COMPLETED:
get_xbzrle_cache_stats(info);
info->has_status = true;
info->status = MIGRATION_STATUS_COMPLETED;
info->has_total_time = true;
info->total_time = s->total_time;
info->has_downtime = true;
info->downtime = s->downtime;
info->has_setup_time = true;
info->setup_time = s->setup_time;
info->has_ram = true;
info->ram = g_malloc0(sizeof(*info->ram));
info->ram->transferred = ram_bytes_transferred();
info->ram->remaining = 0;
info->ram->total = ram_bytes_total();
info->ram->duplicate = dup_mig_pages_transferred();
info->ram->skipped = skipped_mig_pages_transferred();
info->ram->normal = norm_mig_pages_transferred();
info->ram->normal_bytes = norm_mig_bytes_transferred();
info->ram->mbps = s->mbps;
info->ram->dirty_sync_count = s->dirty_sync_count;
break;
case MIGRATION_STATUS_FAILED:
info->has_status = true;
info->status = MIGRATION_STATUS_FAILED;
break;
case MIGRATION_STATUS_CANCELLED:
info->has_status = true;
info->status = MIGRATION_STATUS_CANCELLED;
break;
}
return info;
}
| [
"MigrationInfo *FUNC_0(Error **errp)\n{",
"MigrationInfo *info = g_malloc0(sizeof(*info));",
"MigrationState *s = migrate_get_current();",
"switch (s->state) {",
"case MIGRATION_STATUS_NONE:\nbreak;",
"case MIGRATION_STATUS_SETUP:\ninfo->has_status = true;",
"info->status = MIGRATION_STATUS_SETUP;",
"info->has_total_time = false;",
"break;",
"case MIGRATION_STATUS_ACTIVE:\ncase MIGRATION_STATUS_CANCELLING:\ninfo->has_status = true;",
"info->status = MIGRATION_STATUS_ACTIVE;",
"info->has_total_time = true;",
"info->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME)\n- s->total_time;",
"info->has_expected_downtime = true;",
"info->expected_downtime = s->expected_downtime;",
"info->has_setup_time = true;",
"info->setup_time = s->setup_time;",
"info->has_ram = true;",
"info->ram = g_malloc0(sizeof(*info->ram));",
"info->ram->transferred = ram_bytes_transferred();",
"info->ram->remaining = ram_bytes_remaining();",
"info->ram->total = ram_bytes_total();",
"info->ram->duplicate = dup_mig_pages_transferred();",
"info->ram->skipped = skipped_mig_pages_transferred();",
"info->ram->normal = norm_mig_pages_transferred();",
"info->ram->normal_bytes = norm_mig_bytes_transferred();",
"info->ram->dirty_pages_rate = s->dirty_pages_rate;",
"info->ram->mbps = s->mbps;",
"info->ram->dirty_sync_count = s->dirty_sync_count;",
"if (blk_mig_active()) {",
"info->has_disk = true;",
"info->disk = g_malloc0(sizeof(*info->disk));",
"info->disk->transferred = blk_mig_bytes_transferred();",
"info->disk->remaining = blk_mig_bytes_remaining();",
"info->disk->total = blk_mig_bytes_total();",
"}",
"get_xbzrle_cache_stats(info);",
"break;",
"case MIGRATION_STATUS_COMPLETED:\nget_xbzrle_cache_stats(info);",
"info->has_status = true;",
"info->status = MIGRATION_STATUS_COMPLETED;",
"info->has_total_time = true;",
"info->total_time = s->total_time;",
"info->has_downtime = true;",
"info->downtime = s->downtime;",
"info->has_setup_time = true;",
"info->setup_time = s->setup_time;",
"info->has_ram = true;",
"info->ram = g_malloc0(sizeof(*info->ram));",
"info->ram->transferred = ram_bytes_transferred();",
"info->ram->remaining = 0;",
"info->ram->total = ram_bytes_total();",
"info->ram->duplicate = dup_mig_pages_transferred();",
"info->ram->skipped = skipped_mig_pages_transferred();",
"info->ram->normal = norm_mig_pages_transferred();",
"info->ram->normal_bytes = norm_mig_bytes_transferred();",
"info->ram->mbps = s->mbps;",
"info->ram->dirty_sync_count = s->dirty_sync_count;",
"break;",
"case MIGRATION_STATUS_FAILED:\ninfo->has_status = true;",
"info->status = MIGRATION_STATUS_FAILED;",
"break;",
"case MIGRATION_STATUS_CANCELLED:\ninfo->has_status = true;",
"info->status = MIGRATION_STATUS_CANCELLED;",
"break;",
"}",
"return info;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29,
31,
33
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99,
101
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147,
149
],
[
151
],
[
153
],
[
155,
157
],
[
159
],
[
161
],
[
163
],
[
167
],
[
169
]
]
|
12,726 | static void do_sendkey(Monitor *mon, const QDict *qdict)
{
char keyname_buf[16];
char *separator;
int keyname_len, keycode, i, idx;
const char *keys = qdict_get_str(qdict, "keys");
int has_hold_time = qdict_haskey(qdict, "hold-time");
int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
if (nb_pending_keycodes > 0) {
qemu_del_timer(key_timer);
release_keys(NULL);
}
if (!has_hold_time)
hold_time = 100;
i = 0;
while (1) {
separator = strchr(keys, '-');
keyname_len = separator ? separator - keys : strlen(keys);
if (keyname_len > 0) {
pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
if (keyname_len > sizeof(keyname_buf) - 1) {
monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
return;
}
if (i == MAX_KEYCODES) {
monitor_printf(mon, "too many keys\n");
return;
}
/* Be compatible with old interface, convert user inputted "<" */
if (!strncmp(keyname_buf, "<", 1) && keyname_len == 1) {
pstrcpy(keyname_buf, sizeof(keyname_buf), "less");
keyname_len = 4;
}
keyname_buf[keyname_len] = 0;
idx = index_from_key(keyname_buf);
if (idx == Q_KEY_CODE_MAX) {
monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
return;
}
keycode = key_defs[idx];
if (keycode < 0) {
monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
return;
}
keycodes[i++] = keycode;
}
if (!separator)
break;
keys = separator + 1;
}
nb_pending_keycodes = i;
/* key down events */
for (i = 0; i < nb_pending_keycodes; i++) {
keycode = keycodes[i];
if (keycode & 0x80)
kbd_put_keycode(0xe0);
kbd_put_keycode(keycode & 0x7f);
}
/* delayed key up events */
qemu_mod_timer(key_timer, qemu_get_clock_ns(vm_clock) +
muldiv64(get_ticks_per_sec(), hold_time, 1000));
}
| false | qemu | e4c8f004c55d9da3eae3e14df740238bf805b5d6 | static void do_sendkey(Monitor *mon, const QDict *qdict)
{
char keyname_buf[16];
char *separator;
int keyname_len, keycode, i, idx;
const char *keys = qdict_get_str(qdict, "keys");
int has_hold_time = qdict_haskey(qdict, "hold-time");
int hold_time = qdict_get_try_int(qdict, "hold-time", -1);
if (nb_pending_keycodes > 0) {
qemu_del_timer(key_timer);
release_keys(NULL);
}
if (!has_hold_time)
hold_time = 100;
i = 0;
while (1) {
separator = strchr(keys, '-');
keyname_len = separator ? separator - keys : strlen(keys);
if (keyname_len > 0) {
pstrcpy(keyname_buf, sizeof(keyname_buf), keys);
if (keyname_len > sizeof(keyname_buf) - 1) {
monitor_printf(mon, "invalid key: '%s...'\n", keyname_buf);
return;
}
if (i == MAX_KEYCODES) {
monitor_printf(mon, "too many keys\n");
return;
}
if (!strncmp(keyname_buf, "<", 1) && keyname_len == 1) {
pstrcpy(keyname_buf, sizeof(keyname_buf), "less");
keyname_len = 4;
}
keyname_buf[keyname_len] = 0;
idx = index_from_key(keyname_buf);
if (idx == Q_KEY_CODE_MAX) {
monitor_printf(mon, "invalid parameter: %s\n", keyname_buf);
return;
}
keycode = key_defs[idx];
if (keycode < 0) {
monitor_printf(mon, "unknown key: '%s'\n", keyname_buf);
return;
}
keycodes[i++] = keycode;
}
if (!separator)
break;
keys = separator + 1;
}
nb_pending_keycodes = i;
for (i = 0; i < nb_pending_keycodes; i++) {
keycode = keycodes[i];
if (keycode & 0x80)
kbd_put_keycode(0xe0);
kbd_put_keycode(keycode & 0x7f);
}
qemu_mod_timer(key_timer, qemu_get_clock_ns(vm_clock) +
muldiv64(get_ticks_per_sec(), hold_time, 1000));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Monitor *VAR_0, const QDict *VAR_1)
{
char VAR_2[16];
char *VAR_3;
int VAR_4, VAR_5, VAR_6, VAR_7;
const char *VAR_8 = qdict_get_str(VAR_1, "VAR_8");
int VAR_9 = qdict_haskey(VAR_1, "hold-time");
int VAR_10 = qdict_get_try_int(VAR_1, "hold-time", -1);
if (nb_pending_keycodes > 0) {
qemu_del_timer(key_timer);
release_keys(NULL);
}
if (!VAR_9)
VAR_10 = 100;
VAR_6 = 0;
while (1) {
VAR_3 = strchr(VAR_8, '-');
VAR_4 = VAR_3 ? VAR_3 - VAR_8 : strlen(VAR_8);
if (VAR_4 > 0) {
pstrcpy(VAR_2, sizeof(VAR_2), VAR_8);
if (VAR_4 > sizeof(VAR_2) - 1) {
monitor_printf(VAR_0, "invalid key: '%s...'\n", VAR_2);
return;
}
if (VAR_6 == MAX_KEYCODES) {
monitor_printf(VAR_0, "too many VAR_8\n");
return;
}
if (!strncmp(VAR_2, "<", 1) && VAR_4 == 1) {
pstrcpy(VAR_2, sizeof(VAR_2), "less");
VAR_4 = 4;
}
VAR_2[VAR_4] = 0;
VAR_7 = index_from_key(VAR_2);
if (VAR_7 == Q_KEY_CODE_MAX) {
monitor_printf(VAR_0, "invalid parameter: %s\n", VAR_2);
return;
}
VAR_5 = key_defs[VAR_7];
if (VAR_5 < 0) {
monitor_printf(VAR_0, "unknown key: '%s'\n", VAR_2);
return;
}
keycodes[VAR_6++] = VAR_5;
}
if (!VAR_3)
break;
VAR_8 = VAR_3 + 1;
}
nb_pending_keycodes = VAR_6;
for (VAR_6 = 0; VAR_6 < nb_pending_keycodes; VAR_6++) {
VAR_5 = keycodes[VAR_6];
if (VAR_5 & 0x80)
kbd_put_keycode(0xe0);
kbd_put_keycode(VAR_5 & 0x7f);
}
qemu_mod_timer(key_timer, qemu_get_clock_ns(vm_clock) +
muldiv64(get_ticks_per_sec(), VAR_10, 1000));
}
| [
"static void FUNC_0(Monitor *VAR_0, const QDict *VAR_1)\n{",
"char VAR_2[16];",
"char *VAR_3;",
"int VAR_4, VAR_5, VAR_6, VAR_7;",
"const char *VAR_8 = qdict_get_str(VAR_1, \"VAR_8\");",
"int VAR_9 = qdict_haskey(VAR_1, \"hold-time\");",
"int VAR_10 = qdict_get_try_int(VAR_1, \"hold-time\", -1);",
"if (nb_pending_keycodes > 0) {",
"qemu_del_timer(key_timer);",
"release_keys(NULL);",
"}",
"if (!VAR_9)\nVAR_10 = 100;",
"VAR_6 = 0;",
"while (1) {",
"VAR_3 = strchr(VAR_8, '-');",
"VAR_4 = VAR_3 ? VAR_3 - VAR_8 : strlen(VAR_8);",
"if (VAR_4 > 0) {",
"pstrcpy(VAR_2, sizeof(VAR_2), VAR_8);",
"if (VAR_4 > sizeof(VAR_2) - 1) {",
"monitor_printf(VAR_0, \"invalid key: '%s...'\\n\", VAR_2);",
"return;",
"}",
"if (VAR_6 == MAX_KEYCODES) {",
"monitor_printf(VAR_0, \"too many VAR_8\\n\");",
"return;",
"}",
"if (!strncmp(VAR_2, \"<\", 1) && VAR_4 == 1) {",
"pstrcpy(VAR_2, sizeof(VAR_2), \"less\");",
"VAR_4 = 4;",
"}",
"VAR_2[VAR_4] = 0;",
"VAR_7 = index_from_key(VAR_2);",
"if (VAR_7 == Q_KEY_CODE_MAX) {",
"monitor_printf(VAR_0, \"invalid parameter: %s\\n\", VAR_2);",
"return;",
"}",
"VAR_5 = key_defs[VAR_7];",
"if (VAR_5 < 0) {",
"monitor_printf(VAR_0, \"unknown key: '%s'\\n\", VAR_2);",
"return;",
"}",
"keycodes[VAR_6++] = VAR_5;",
"}",
"if (!VAR_3)\nbreak;",
"VAR_8 = VAR_3 + 1;",
"}",
"nb_pending_keycodes = VAR_6;",
"for (VAR_6 = 0; VAR_6 < nb_pending_keycodes; VAR_6++) {",
"VAR_5 = keycodes[VAR_6];",
"if (VAR_5 & 0x80)\nkbd_put_keycode(0xe0);",
"kbd_put_keycode(VAR_5 & 0x7f);",
"}",
"qemu_mod_timer(key_timer, qemu_get_clock_ns(vm_clock) +\nmuldiv64(get_ticks_per_sec(), VAR_10, 1000));",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119,
121
],
[
123
],
[
125
],
[
129,
131
],
[
133
]
]
|
12,728 | static void qemu_rdma_dump_id(const char *who, struct ibv_context *verbs)
{
struct ibv_port_attr port;
if (ibv_query_port(verbs, 1, &port)) {
error_report("Failed to query port information");
return;
}
printf("%s RDMA Device opened: kernel name %s "
"uverbs device name %s, "
"infiniband_verbs class device path %s, "
"infiniband class device path %s, "
"transport: (%d) %s\n",
who,
verbs->device->name,
verbs->device->dev_name,
verbs->device->dev_path,
verbs->device->ibdev_path,
port.link_layer,
(port.link_layer == IBV_LINK_LAYER_INFINIBAND) ? "Infiniband" :
((port.link_layer == IBV_LINK_LAYER_ETHERNET)
? "Ethernet" : "Unknown"));
}
| false | qemu | 02942db7982541716131ca486ca0d59eae107553 | static void qemu_rdma_dump_id(const char *who, struct ibv_context *verbs)
{
struct ibv_port_attr port;
if (ibv_query_port(verbs, 1, &port)) {
error_report("Failed to query port information");
return;
}
printf("%s RDMA Device opened: kernel name %s "
"uverbs device name %s, "
"infiniband_verbs class device path %s, "
"infiniband class device path %s, "
"transport: (%d) %s\n",
who,
verbs->device->name,
verbs->device->dev_name,
verbs->device->dev_path,
verbs->device->ibdev_path,
port.link_layer,
(port.link_layer == IBV_LINK_LAYER_INFINIBAND) ? "Infiniband" :
((port.link_layer == IBV_LINK_LAYER_ETHERNET)
? "Ethernet" : "Unknown"));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(const char *VAR_0, struct ibv_context *VAR_1)
{
struct ibv_port_attr VAR_2;
if (ibv_query_port(VAR_1, 1, &VAR_2)) {
error_report("Failed to query VAR_2 information");
return;
}
printf("%s RDMA Device opened: kernel name %s "
"uverbs device name %s, "
"infiniband_verbs class device path %s, "
"infiniband class device path %s, "
"transport: (%d) %s\n",
VAR_0,
VAR_1->device->name,
VAR_1->device->dev_name,
VAR_1->device->dev_path,
VAR_1->device->ibdev_path,
VAR_2.link_layer,
(VAR_2.link_layer == IBV_LINK_LAYER_INFINIBAND) ? "Infiniband" :
((VAR_2.link_layer == IBV_LINK_LAYER_ETHERNET)
? "Ethernet" : "Unknown"));
}
| [
"static void FUNC_0(const char *VAR_0, struct ibv_context *VAR_1)\n{",
"struct ibv_port_attr VAR_2;",
"if (ibv_query_port(VAR_1, 1, &VAR_2)) {",
"error_report(\"Failed to query VAR_2 information\");",
"return;",
"}",
"printf(\"%s RDMA Device opened: kernel name %s \"\n\"uverbs device name %s, \"\n\"infiniband_verbs class device path %s, \"\n\"infiniband class device path %s, \"\n\"transport: (%d) %s\\n\",\nVAR_0,\nVAR_1->device->name,\nVAR_1->device->dev_name,\nVAR_1->device->dev_path,\nVAR_1->device->ibdev_path,\nVAR_2.link_layer,\n(VAR_2.link_layer == IBV_LINK_LAYER_INFINIBAND) ? \"Infiniband\" :\n((VAR_2.link_layer == IBV_LINK_LAYER_ETHERNET)\n? \"Ethernet\" : \"Unknown\"));",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19,
21,
23,
25,
27,
29,
31,
33,
35,
37,
39,
41,
43,
45
],
[
47
]
]
|
12,729 | void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src,
int stride, int height,
int log2_denom, int weight_dst,
int weight_src, int offset)
{
avc_biwgt_8width_msa(src, stride,
dst, stride,
height, log2_denom,
weight_src, weight_dst, offset);
}
| false | FFmpeg | bcd7bf7eeb09a395cc01698842d1b8be9af483fc | void ff_biweight_h264_pixels8_8_msa(uint8_t *dst, uint8_t *src,
int stride, int height,
int log2_denom, int weight_dst,
int weight_src, int offset)
{
avc_biwgt_8width_msa(src, stride,
dst, stride,
height, log2_denom,
weight_src, weight_dst, offset);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(uint8_t *VAR_0, uint8_t *VAR_1,
int VAR_2, int VAR_3,
int VAR_4, int VAR_5,
int VAR_6, int VAR_7)
{
avc_biwgt_8width_msa(VAR_1, VAR_2,
VAR_0, VAR_2,
VAR_3, VAR_4,
VAR_6, VAR_5, VAR_7);
}
| [
"void FUNC_0(uint8_t *VAR_0, uint8_t *VAR_1,\nint VAR_2, int VAR_3,\nint VAR_4, int VAR_5,\nint VAR_6, int VAR_7)\n{",
"avc_biwgt_8width_msa(VAR_1, VAR_2,\nVAR_0, VAR_2,\nVAR_3, VAR_4,\nVAR_6, VAR_5, VAR_7);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3,
5,
7,
9
],
[
11,
13,
15,
17
],
[
19
]
]
|
12,731 | static av_cold int raw_init_decoder(AVCodecContext *avctx)
{
RawVideoContext *context = avctx->priv_data;
const AVPixFmtDescriptor *desc;
ff_bswapdsp_init(&context->bbdsp);
if ( avctx->codec_tag == MKTAG('r','a','w',' ')
|| avctx->codec_tag == MKTAG('N','O','1','6'))
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,
avctx->bits_per_coded_sample);
else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
avctx->bits_per_coded_sample);
else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
avctx->pix_fmt = avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, avctx->codec_tag);
else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
avctx->bits_per_coded_sample);
desc = av_pix_fmt_desc_get(avctx->pix_fmt);
if (!desc) {
av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
return AVERROR(EINVAL);
}
if (desc->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL)) {
context->palette = av_buffer_alloc(AVPALETTE_SIZE);
if (!context->palette)
return AVERROR(ENOMEM);
if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
else
memset(context->palette->data, 0, AVPALETTE_SIZE);
}
if ((avctx->extradata_size >= 9 &&
!memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
avctx->codec_tag == MKTAG('c','y','u','v') ||
avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
avctx->codec_tag == MKTAG('W','R','A','W'))
context->flip = 1;
if (avctx->codec_tag == AV_RL32("yuv2") &&
avctx->pix_fmt == AV_PIX_FMT_YUYV422)
context->is_yuv2 = 1;
return 0;
}
| false | FFmpeg | fe7639b1c8be49ced7465c6a91a9008f406cc5ba | static av_cold int raw_init_decoder(AVCodecContext *avctx)
{
RawVideoContext *context = avctx->priv_data;
const AVPixFmtDescriptor *desc;
ff_bswapdsp_init(&context->bbdsp);
if ( avctx->codec_tag == MKTAG('r','a','w',' ')
|| avctx->codec_tag == MKTAG('N','O','1','6'))
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,
avctx->bits_per_coded_sample);
else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
avctx->bits_per_coded_sample);
else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
avctx->pix_fmt = avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, avctx->codec_tag);
else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
avctx->bits_per_coded_sample);
desc = av_pix_fmt_desc_get(avctx->pix_fmt);
if (!desc) {
av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
return AVERROR(EINVAL);
}
if (desc->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL)) {
context->palette = av_buffer_alloc(AVPALETTE_SIZE);
if (!context->palette)
return AVERROR(ENOMEM);
if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
else
memset(context->palette->data, 0, AVPALETTE_SIZE);
}
if ((avctx->extradata_size >= 9 &&
!memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
avctx->codec_tag == MKTAG('c','y','u','v') ||
avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
avctx->codec_tag == MKTAG('W','R','A','W'))
context->flip = 1;
if (avctx->codec_tag == AV_RL32("yuv2") &&
avctx->pix_fmt == AV_PIX_FMT_YUYV422)
context->is_yuv2 = 1;
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
RawVideoContext *context = avctx->priv_data;
const AVPixFmtDescriptor *VAR_0;
ff_bswapdsp_init(&context->bbdsp);
if ( avctx->codec_tag == MKTAG('r','a','w',' ')
|| avctx->codec_tag == MKTAG('N','O','1','6'))
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,
avctx->bits_per_coded_sample);
else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
avctx->bits_per_coded_sample);
else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
avctx->pix_fmt = avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, avctx->codec_tag);
else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
avctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,
avctx->bits_per_coded_sample);
VAR_0 = av_pix_fmt_desc_get(avctx->pix_fmt);
if (!VAR_0) {
av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
return AVERROR(EINVAL);
}
if (VAR_0->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL)) {
context->palette = av_buffer_alloc(AVPALETTE_SIZE);
if (!context->palette)
return AVERROR(ENOMEM);
if (VAR_0->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
else
memset(context->palette->data, 0, AVPALETTE_SIZE);
}
if ((avctx->extradata_size >= 9 &&
!memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
avctx->codec_tag == MKTAG('c','y','u','v') ||
avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
avctx->codec_tag == MKTAG('W','R','A','W'))
context->flip = 1;
if (avctx->codec_tag == AV_RL32("yuv2") &&
avctx->pix_fmt == AV_PIX_FMT_YUYV422)
context->is_yuv2 = 1;
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"RawVideoContext *context = avctx->priv_data;",
"const AVPixFmtDescriptor *VAR_0;",
"ff_bswapdsp_init(&context->bbdsp);",
"if ( avctx->codec_tag == MKTAG('r','a','w',' ')\n|| avctx->codec_tag == MKTAG('N','O','1','6'))\navctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_mov,\navctx->bits_per_coded_sample);",
"else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))\navctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,\navctx->bits_per_coded_sample);",
"else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))\navctx->pix_fmt = avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, avctx->codec_tag);",
"else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)\navctx->pix_fmt = avpriv_find_pix_fmt(avpriv_pix_fmt_bps_avi,\navctx->bits_per_coded_sample);",
"VAR_0 = av_pix_fmt_desc_get(avctx->pix_fmt);",
"if (!VAR_0) {",
"av_log(avctx, AV_LOG_ERROR, \"Invalid pixel format.\\n\");",
"return AVERROR(EINVAL);",
"}",
"if (VAR_0->flags & (AV_PIX_FMT_FLAG_PAL | AV_PIX_FMT_FLAG_PSEUDOPAL)) {",
"context->palette = av_buffer_alloc(AVPALETTE_SIZE);",
"if (!context->palette)\nreturn AVERROR(ENOMEM);",
"if (VAR_0->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)\navpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);",
"else\nmemset(context->palette->data, 0, AVPALETTE_SIZE);",
"}",
"if ((avctx->extradata_size >= 9 &&\n!memcmp(avctx->extradata + avctx->extradata_size - 9, \"BottomUp\", 9)) ||\navctx->codec_tag == MKTAG('c','y','u','v') ||\navctx->codec_tag == MKTAG(3, 0, 0, 0) ||\navctx->codec_tag == MKTAG('W','R','A','W'))\ncontext->flip = 1;",
"if (avctx->codec_tag == AV_RL32(\"yuv2\") &&\navctx->pix_fmt == AV_PIX_FMT_YUYV422)\ncontext->is_yuv2 = 1;",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15,
17,
19,
21
],
[
23,
25,
27
],
[
29,
31
],
[
33,
35,
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57,
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
73,
75,
77,
79,
81,
83
],
[
87,
89,
91
],
[
95
],
[
97
]
]
|
12,732 | static void gen_rfe(DisasContext *s, TCGv_i32 pc, TCGv_i32 cpsr)
{
gen_set_cpsr(cpsr, CPSR_ERET_MASK);
tcg_temp_free_i32(cpsr);
store_reg(s, 15, pc);
s->is_jmp = DISAS_JUMP;
}
| false | qemu | 235ea1f5c89abf30e452539b973b0dbe43d3fe2b | static void gen_rfe(DisasContext *s, TCGv_i32 pc, TCGv_i32 cpsr)
{
gen_set_cpsr(cpsr, CPSR_ERET_MASK);
tcg_temp_free_i32(cpsr);
store_reg(s, 15, pc);
s->is_jmp = DISAS_JUMP;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, TCGv_i32 VAR_1, TCGv_i32 VAR_2)
{
gen_set_cpsr(VAR_2, CPSR_ERET_MASK);
tcg_temp_free_i32(VAR_2);
store_reg(VAR_0, 15, VAR_1);
VAR_0->is_jmp = DISAS_JUMP;
}
| [
"static void FUNC_0(DisasContext *VAR_0, TCGv_i32 VAR_1, TCGv_i32 VAR_2)\n{",
"gen_set_cpsr(VAR_2, CPSR_ERET_MASK);",
"tcg_temp_free_i32(VAR_2);",
"store_reg(VAR_0, 15, VAR_1);",
"VAR_0->is_jmp = DISAS_JUMP;",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
]
|
12,733 | void bdrv_drain_all_end(void)
{
BlockDriverState *bs;
BdrvNextIterator it;
BlockJob *job = NULL;
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
AioContext *aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
aio_enable_external(aio_context);
bdrv_io_unplugged_end(bs);
bdrv_parent_drained_end(bs);
aio_context_release(aio_context);
}
while ((job = block_job_next(job))) {
AioContext *aio_context = blk_get_aio_context(job->blk);
aio_context_acquire(aio_context);
block_job_resume(job);
aio_context_release(aio_context);
}
}
| false | qemu | 8f90b5e91df59fde0dfecc6738ff39f3edf14be5 | void bdrv_drain_all_end(void)
{
BlockDriverState *bs;
BdrvNextIterator it;
BlockJob *job = NULL;
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
AioContext *aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
aio_enable_external(aio_context);
bdrv_io_unplugged_end(bs);
bdrv_parent_drained_end(bs);
aio_context_release(aio_context);
}
while ((job = block_job_next(job))) {
AioContext *aio_context = blk_get_aio_context(job->blk);
aio_context_acquire(aio_context);
block_job_resume(job);
aio_context_release(aio_context);
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(void)
{
BlockDriverState *bs;
BdrvNextIterator it;
BlockJob *job = NULL;
for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
AioContext *aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
aio_enable_external(aio_context);
bdrv_io_unplugged_end(bs);
bdrv_parent_drained_end(bs);
aio_context_release(aio_context);
}
while ((job = block_job_next(job))) {
AioContext *aio_context = blk_get_aio_context(job->blk);
aio_context_acquire(aio_context);
block_job_resume(job);
aio_context_release(aio_context);
}
}
| [
"void FUNC_0(void)\n{",
"BlockDriverState *bs;",
"BdrvNextIterator it;",
"BlockJob *job = NULL;",
"for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {",
"AioContext *aio_context = bdrv_get_aio_context(bs);",
"aio_context_acquire(aio_context);",
"aio_enable_external(aio_context);",
"bdrv_io_unplugged_end(bs);",
"bdrv_parent_drained_end(bs);",
"aio_context_release(aio_context);",
"}",
"while ((job = block_job_next(job))) {",
"AioContext *aio_context = blk_get_aio_context(job->blk);",
"aio_context_acquire(aio_context);",
"block_job_resume(job);",
"aio_context_release(aio_context);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
]
]
|
12,734 | int qemu_set_fd_handler(int fd,
IOHandler *fd_read,
IOHandler *fd_write,
void *opaque)
{
return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
}
| false | qemu | 6484e422479c93f28e3f8a68258b0eacd3b31e6d | int qemu_set_fd_handler(int fd,
IOHandler *fd_read,
IOHandler *fd_write,
void *opaque)
{
return qemu_set_fd_handler2(fd, NULL, fd_read, fd_write, opaque);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(int VAR_0,
IOHandler *VAR_1,
IOHandler *VAR_2,
void *VAR_3)
{
return qemu_set_fd_handler2(VAR_0, NULL, VAR_1, VAR_2, VAR_3);
}
| [
"int FUNC_0(int VAR_0,\nIOHandler *VAR_1,\nIOHandler *VAR_2,\nvoid *VAR_3)\n{",
"return qemu_set_fd_handler2(VAR_0, NULL, VAR_1, VAR_2, VAR_3);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
]
]
|
12,735 | int float32_lt( float32 a, float32 b STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) {
float_raise( float_flag_invalid STATUS_VAR);
return 0;
}
aSign = extractFloat32Sign( a );
bSign = extractFloat32Sign( b );
if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
return ( a != b ) && ( aSign ^ ( a < b ) );
}
| false | qemu | f090c9d4ad5812fb92843d6470a1111c15190c4c | int float32_lt( float32 a, float32 b STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat32Exp( a ) == 0xFF ) && extractFloat32Frac( a ) )
|| ( ( extractFloat32Exp( b ) == 0xFF ) && extractFloat32Frac( b ) )
) {
float_raise( float_flag_invalid STATUS_VAR);
return 0;
}
aSign = extractFloat32Sign( a );
bSign = extractFloat32Sign( b );
if ( aSign != bSign ) return aSign && ( (bits32) ( ( a | b )<<1 ) != 0 );
return ( a != b ) && ( aSign ^ ( a < b ) );
}
| {
"code": [],
"line_no": []
} | int FUNC_0( float32 VAR_0, float32 VAR_1 STATUS_PARAM )
{
flag aSign, bSign;
if ( ( ( extractFloat32Exp( VAR_0 ) == 0xFF ) && extractFloat32Frac( VAR_0 ) )
|| ( ( extractFloat32Exp( VAR_1 ) == 0xFF ) && extractFloat32Frac( VAR_1 ) )
) {
float_raise( float_flag_invalid STATUS_VAR);
return 0;
}
aSign = extractFloat32Sign( VAR_0 );
bSign = extractFloat32Sign( VAR_1 );
if ( aSign != bSign ) return aSign && ( (bits32) ( ( VAR_0 | VAR_1 )<<1 ) != 0 );
return ( VAR_0 != VAR_1 ) && ( aSign ^ ( VAR_0 < VAR_1 ) );
}
| [
"int FUNC_0( float32 VAR_0, float32 VAR_1 STATUS_PARAM )\n{",
"flag aSign, bSign;",
"if ( ( ( extractFloat32Exp( VAR_0 ) == 0xFF ) && extractFloat32Frac( VAR_0 ) )\n|| ( ( extractFloat32Exp( VAR_1 ) == 0xFF ) && extractFloat32Frac( VAR_1 ) )\n) {",
"float_raise( float_flag_invalid STATUS_VAR);",
"return 0;",
"}",
"aSign = extractFloat32Sign( VAR_0 );",
"bSign = extractFloat32Sign( VAR_1 );",
"if ( aSign != bSign ) return aSign && ( (bits32) ( ( VAR_0 | VAR_1 )<<1 ) != 0 );",
"return ( VAR_0 != VAR_1 ) && ( aSign ^ ( VAR_0 < VAR_1 ) );",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9,
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
]
]
|
12,736 | build_spcr(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info)
{
AcpiSerialPortConsoleRedirection *spcr;
const MemMapEntry *uart_memmap = &guest_info->memmap[VIRT_UART];
int irq = guest_info->irqmap[VIRT_UART] + ARM_SPI_BASE;
spcr = acpi_data_push(table_data, sizeof(*spcr));
spcr->interface_type = 0x3; /* ARM PL011 UART */
spcr->base_address.space_id = AML_SYSTEM_MEMORY;
spcr->base_address.bit_width = 8;
spcr->base_address.bit_offset = 0;
spcr->base_address.access_width = 1;
spcr->base_address.address = cpu_to_le64(uart_memmap->base);
spcr->interrupt_types = (1 << 3); /* Bit[3] ARMH GIC interrupt */
spcr->gsi = cpu_to_le32(irq); /* Global System Interrupt */
spcr->baud = 3; /* Baud Rate: 3 = 9600 */
spcr->parity = 0; /* No Parity */
spcr->stopbits = 1; /* 1 Stop bit */
spcr->flowctrl = (1 << 1); /* Bit[1] = RTS/CTS hardware flow control */
spcr->term_type = 0; /* Terminal Type: 0 = VT100 */
spcr->pci_device_id = 0xffff; /* PCI Device ID: not a PCI device */
spcr->pci_vendor_id = 0xffff; /* PCI Vendor ID: not a PCI device */
build_header(linker, table_data, (void *)spcr, "SPCR", sizeof(*spcr), 2,
NULL);
}
| false | qemu | 37ad223c515da2fe9f1c679768cb5ccaa42e57e1 | build_spcr(GArray *table_data, GArray *linker, VirtGuestInfo *guest_info)
{
AcpiSerialPortConsoleRedirection *spcr;
const MemMapEntry *uart_memmap = &guest_info->memmap[VIRT_UART];
int irq = guest_info->irqmap[VIRT_UART] + ARM_SPI_BASE;
spcr = acpi_data_push(table_data, sizeof(*spcr));
spcr->interface_type = 0x3;
spcr->base_address.space_id = AML_SYSTEM_MEMORY;
spcr->base_address.bit_width = 8;
spcr->base_address.bit_offset = 0;
spcr->base_address.access_width = 1;
spcr->base_address.address = cpu_to_le64(uart_memmap->base);
spcr->interrupt_types = (1 << 3);
spcr->gsi = cpu_to_le32(irq);
spcr->baud = 3;
spcr->parity = 0;
spcr->stopbits = 1;
spcr->flowctrl = (1 << 1);
spcr->term_type = 0;
spcr->pci_device_id = 0xffff;
spcr->pci_vendor_id = 0xffff;
build_header(linker, table_data, (void *)spcr, "SPCR", sizeof(*spcr), 2,
NULL);
}
| {
"code": [],
"line_no": []
} | FUNC_0(GArray *VAR_0, GArray *VAR_1, VirtGuestInfo *VAR_2)
{
AcpiSerialPortConsoleRedirection *spcr;
const MemMapEntry *VAR_3 = &VAR_2->memmap[VIRT_UART];
int VAR_4 = VAR_2->irqmap[VIRT_UART] + ARM_SPI_BASE;
spcr = acpi_data_push(VAR_0, sizeof(*spcr));
spcr->interface_type = 0x3;
spcr->base_address.space_id = AML_SYSTEM_MEMORY;
spcr->base_address.bit_width = 8;
spcr->base_address.bit_offset = 0;
spcr->base_address.access_width = 1;
spcr->base_address.address = cpu_to_le64(VAR_3->base);
spcr->interrupt_types = (1 << 3);
spcr->gsi = cpu_to_le32(VAR_4);
spcr->baud = 3;
spcr->parity = 0;
spcr->stopbits = 1;
spcr->flowctrl = (1 << 1);
spcr->term_type = 0;
spcr->pci_device_id = 0xffff;
spcr->pci_vendor_id = 0xffff;
build_header(VAR_1, VAR_0, (void *)spcr, "SPCR", sizeof(*spcr), 2,
NULL);
}
| [
"FUNC_0(GArray *VAR_0, GArray *VAR_1, VirtGuestInfo *VAR_2)\n{",
"AcpiSerialPortConsoleRedirection *spcr;",
"const MemMapEntry *VAR_3 = &VAR_2->memmap[VIRT_UART];",
"int VAR_4 = VAR_2->irqmap[VIRT_UART] + ARM_SPI_BASE;",
"spcr = acpi_data_push(VAR_0, sizeof(*spcr));",
"spcr->interface_type = 0x3;",
"spcr->base_address.space_id = AML_SYSTEM_MEMORY;",
"spcr->base_address.bit_width = 8;",
"spcr->base_address.bit_offset = 0;",
"spcr->base_address.access_width = 1;",
"spcr->base_address.address = cpu_to_le64(VAR_3->base);",
"spcr->interrupt_types = (1 << 3);",
"spcr->gsi = cpu_to_le32(VAR_4);",
"spcr->baud = 3;",
"spcr->parity = 0;",
"spcr->stopbits = 1;",
"spcr->flowctrl = (1 << 1);",
"spcr->term_type = 0;",
"spcr->pci_device_id = 0xffff;",
"spcr->pci_vendor_id = 0xffff;",
"build_header(VAR_1, VAR_0, (void *)spcr, \"SPCR\", sizeof(*spcr), 2,\nNULL);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
57,
59
],
[
61
]
]
|
12,737 | static SocketAddressLegacy *sd_server_config(QDict *options, Error **errp)
{
QDict *server = NULL;
QObject *crumpled_server = NULL;
Visitor *iv = NULL;
SocketAddress *saddr_flat = NULL;
SocketAddressLegacy *saddr = NULL;
Error *local_err = NULL;
qdict_extract_subqdict(options, &server, "server.");
crumpled_server = qdict_crumple(server, errp);
if (!crumpled_server) {
goto done;
}
/*
* FIXME .numeric, .to, .ipv4 or .ipv6 don't work with -drive
* server.type=inet. .to doesn't matter, it's ignored anyway.
* That's because when @options come from -blockdev or
* blockdev_add, members are typed according to the QAPI schema,
* but when they come from -drive, they're all QString. The
* visitor expects the former.
*/
iv = qobject_input_visitor_new(crumpled_server);
visit_type_SocketAddress(iv, NULL, &saddr_flat, &local_err);
if (local_err) {
error_propagate(errp, local_err);
goto done;
}
saddr = socket_address_crumple(saddr_flat);
done:
qapi_free_SocketAddress(saddr_flat);
visit_free(iv);
qobject_decref(crumpled_server);
QDECREF(server);
return saddr;
}
| false | qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | static SocketAddressLegacy *sd_server_config(QDict *options, Error **errp)
{
QDict *server = NULL;
QObject *crumpled_server = NULL;
Visitor *iv = NULL;
SocketAddress *saddr_flat = NULL;
SocketAddressLegacy *saddr = NULL;
Error *local_err = NULL;
qdict_extract_subqdict(options, &server, "server.");
crumpled_server = qdict_crumple(server, errp);
if (!crumpled_server) {
goto done;
}
iv = qobject_input_visitor_new(crumpled_server);
visit_type_SocketAddress(iv, NULL, &saddr_flat, &local_err);
if (local_err) {
error_propagate(errp, local_err);
goto done;
}
saddr = socket_address_crumple(saddr_flat);
done:
qapi_free_SocketAddress(saddr_flat);
visit_free(iv);
qobject_decref(crumpled_server);
QDECREF(server);
return saddr;
}
| {
"code": [],
"line_no": []
} | static SocketAddressLegacy *FUNC_0(QDict *options, Error **errp)
{
QDict *server = NULL;
QObject *crumpled_server = NULL;
Visitor *iv = NULL;
SocketAddress *saddr_flat = NULL;
SocketAddressLegacy *saddr = NULL;
Error *local_err = NULL;
qdict_extract_subqdict(options, &server, "server.");
crumpled_server = qdict_crumple(server, errp);
if (!crumpled_server) {
goto done;
}
iv = qobject_input_visitor_new(crumpled_server);
visit_type_SocketAddress(iv, NULL, &saddr_flat, &local_err);
if (local_err) {
error_propagate(errp, local_err);
goto done;
}
saddr = socket_address_crumple(saddr_flat);
done:
qapi_free_SocketAddress(saddr_flat);
visit_free(iv);
qobject_decref(crumpled_server);
QDECREF(server);
return saddr;
}
| [
"static SocketAddressLegacy *FUNC_0(QDict *options, Error **errp)\n{",
"QDict *server = NULL;",
"QObject *crumpled_server = NULL;",
"Visitor *iv = NULL;",
"SocketAddress *saddr_flat = NULL;",
"SocketAddressLegacy *saddr = NULL;",
"Error *local_err = NULL;",
"qdict_extract_subqdict(options, &server, \"server.\");",
"crumpled_server = qdict_crumple(server, errp);",
"if (!crumpled_server) {",
"goto done;",
"}",
"iv = qobject_input_visitor_new(crumpled_server);",
"visit_type_SocketAddress(iv, NULL, &saddr_flat, &local_err);",
"if (local_err) {",
"error_propagate(errp, local_err);",
"goto done;",
"}",
"saddr = socket_address_crumple(saddr_flat);",
"done:\nqapi_free_SocketAddress(saddr_flat);",
"visit_free(iv);",
"qobject_decref(crumpled_server);",
"QDECREF(server);",
"return saddr;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
67,
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
]
]
|
12,738 | static void tosa_init(ram_addr_t ram_size, int vga_ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
struct pxa2xx_state_s *cpu;
struct tc6393xb_s *tmio;
struct scoop_info_s *scp0, *scp1;
if (ram_size < (TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE + TC6393XB_RAM)) {
fprintf(stderr, "This platform requires %i bytes of memory\n",
TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE);
exit(1);
}
if (!cpu_model)
cpu_model = "pxa255";
cpu = pxa255_init(tosa_binfo.ram_size);
cpu_register_physical_memory(0, TOSA_ROM,
qemu_ram_alloc(TOSA_ROM) | IO_MEM_ROM);
tmio = tc6393xb_init(0x10000000,
pxa2xx_gpio_in_get(cpu->gpio)[TOSA_GPIO_TC6393XB_INT]);
scp0 = scoop_init(cpu, 0, 0x08800000);
scp1 = scoop_init(cpu, 1, 0x14800040);
tosa_gpio_setup(cpu, scp0, scp1, tmio);
tosa_microdrive_attach(cpu);
tosa_tg_init(cpu);
/* Setup initial (reset) machine state */
cpu->env->regs[15] = tosa_binfo.loader_start;
tosa_binfo.kernel_filename = kernel_filename;
tosa_binfo.kernel_cmdline = kernel_cmdline;
tosa_binfo.initrd_filename = initrd_filename;
tosa_binfo.board_id = 0x208;
arm_load_kernel(cpu->env, &tosa_binfo);
sl_bootparam_write(SL_PXA_PARAM_BASE);
}
| false | qemu | a0b753dfd3920df146a5f4d05e442e3c522900c7 | static void tosa_init(ram_addr_t ram_size, int vga_ram_size,
const char *boot_device,
const char *kernel_filename, const char *kernel_cmdline,
const char *initrd_filename, const char *cpu_model)
{
struct pxa2xx_state_s *cpu;
struct tc6393xb_s *tmio;
struct scoop_info_s *scp0, *scp1;
if (ram_size < (TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE + TC6393XB_RAM)) {
fprintf(stderr, "This platform requires %i bytes of memory\n",
TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE);
exit(1);
}
if (!cpu_model)
cpu_model = "pxa255";
cpu = pxa255_init(tosa_binfo.ram_size);
cpu_register_physical_memory(0, TOSA_ROM,
qemu_ram_alloc(TOSA_ROM) | IO_MEM_ROM);
tmio = tc6393xb_init(0x10000000,
pxa2xx_gpio_in_get(cpu->gpio)[TOSA_GPIO_TC6393XB_INT]);
scp0 = scoop_init(cpu, 0, 0x08800000);
scp1 = scoop_init(cpu, 1, 0x14800040);
tosa_gpio_setup(cpu, scp0, scp1, tmio);
tosa_microdrive_attach(cpu);
tosa_tg_init(cpu);
cpu->env->regs[15] = tosa_binfo.loader_start;
tosa_binfo.kernel_filename = kernel_filename;
tosa_binfo.kernel_cmdline = kernel_cmdline;
tosa_binfo.initrd_filename = initrd_filename;
tosa_binfo.board_id = 0x208;
arm_load_kernel(cpu->env, &tosa_binfo);
sl_bootparam_write(SL_PXA_PARAM_BASE);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(ram_addr_t VAR_0, int VAR_1,
const char *VAR_2,
const char *VAR_3, const char *VAR_4,
const char *VAR_5, const char *VAR_6)
{
struct pxa2xx_state_s *VAR_7;
struct tc6393xb_s *VAR_8;
struct scoop_info_s *VAR_9, *VAR_10;
if (VAR_0 < (TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE + TC6393XB_RAM)) {
fprintf(stderr, "This platform requires %i bytes of memory\n",
TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE);
exit(1);
}
if (!VAR_6)
VAR_6 = "pxa255";
VAR_7 = pxa255_init(tosa_binfo.VAR_0);
cpu_register_physical_memory(0, TOSA_ROM,
qemu_ram_alloc(TOSA_ROM) | IO_MEM_ROM);
VAR_8 = tc6393xb_init(0x10000000,
pxa2xx_gpio_in_get(VAR_7->gpio)[TOSA_GPIO_TC6393XB_INT]);
VAR_9 = scoop_init(VAR_7, 0, 0x08800000);
VAR_10 = scoop_init(VAR_7, 1, 0x14800040);
tosa_gpio_setup(VAR_7, VAR_9, VAR_10, VAR_8);
tosa_microdrive_attach(VAR_7);
tosa_tg_init(VAR_7);
VAR_7->env->regs[15] = tosa_binfo.loader_start;
tosa_binfo.VAR_3 = VAR_3;
tosa_binfo.VAR_4 = VAR_4;
tosa_binfo.VAR_5 = VAR_5;
tosa_binfo.board_id = 0x208;
arm_load_kernel(VAR_7->env, &tosa_binfo);
sl_bootparam_write(SL_PXA_PARAM_BASE);
}
| [
"static void FUNC_0(ram_addr_t VAR_0, int VAR_1,\nconst char *VAR_2,\nconst char *VAR_3, const char *VAR_4,\nconst char *VAR_5, const char *VAR_6)\n{",
"struct pxa2xx_state_s *VAR_7;",
"struct tc6393xb_s *VAR_8;",
"struct scoop_info_s *VAR_9, *VAR_10;",
"if (VAR_0 < (TOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE + TC6393XB_RAM)) {",
"fprintf(stderr, \"This platform requires %i bytes of memory\\n\",\nTOSA_RAM + TOSA_ROM + PXA2XX_INTERNAL_SIZE);",
"exit(1);",
"}",
"if (!VAR_6)\nVAR_6 = \"pxa255\";",
"VAR_7 = pxa255_init(tosa_binfo.VAR_0);",
"cpu_register_physical_memory(0, TOSA_ROM,\nqemu_ram_alloc(TOSA_ROM) | IO_MEM_ROM);",
"VAR_8 = tc6393xb_init(0x10000000,\npxa2xx_gpio_in_get(VAR_7->gpio)[TOSA_GPIO_TC6393XB_INT]);",
"VAR_9 = scoop_init(VAR_7, 0, 0x08800000);",
"VAR_10 = scoop_init(VAR_7, 1, 0x14800040);",
"tosa_gpio_setup(VAR_7, VAR_9, VAR_10, VAR_8);",
"tosa_microdrive_attach(VAR_7);",
"tosa_tg_init(VAR_7);",
"VAR_7->env->regs[15] = tosa_binfo.loader_start;",
"tosa_binfo.VAR_3 = VAR_3;",
"tosa_binfo.VAR_4 = VAR_4;",
"tosa_binfo.VAR_5 = VAR_5;",
"tosa_binfo.board_id = 0x208;",
"arm_load_kernel(VAR_7->env, &tosa_binfo);",
"sl_bootparam_write(SL_PXA_PARAM_BASE);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
31,
33
],
[
37
],
[
41,
43
],
[
47,
49
],
[
53
],
[
55
],
[
59
],
[
63
],
[
67
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
]
]
|
12,739 | static inline uint8_t fat_chksum(const direntry_t* entry)
{
uint8_t chksum=0;
int i;
for(i=0;i<11;i++) {
unsigned char c;
c = (i < 8) ? entry->name[i] : entry->extension[i-8];
chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0)) + c;
}
return chksum;
}
| false | qemu | f671d173c7e1da555b693e8b14f3ed0852601809 | static inline uint8_t fat_chksum(const direntry_t* entry)
{
uint8_t chksum=0;
int i;
for(i=0;i<11;i++) {
unsigned char c;
c = (i < 8) ? entry->name[i] : entry->extension[i-8];
chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0)) + c;
}
return chksum;
}
| {
"code": [],
"line_no": []
} | static inline uint8_t FUNC_0(const direntry_t* entry)
{
uint8_t chksum=0;
int VAR_0;
for(VAR_0=0;VAR_0<11;VAR_0++) {
unsigned char VAR_1;
VAR_1 = (VAR_0 < 8) ? entry->name[VAR_0] : entry->extension[VAR_0-8];
chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0)) + VAR_1;
}
return chksum;
}
| [
"static inline uint8_t FUNC_0(const direntry_t* entry)\n{",
"uint8_t chksum=0;",
"int VAR_0;",
"for(VAR_0=0;VAR_0<11;VAR_0++) {",
"unsigned char VAR_1;",
"VAR_1 = (VAR_0 < 8) ? entry->name[VAR_0] : entry->extension[VAR_0-8];",
"chksum=(((chksum&0xfe)>>1)|((chksum&0x01)?0x80:0)) + VAR_1;",
"}",
"return chksum;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
]
]
|
12,740 | static void event_notifier_ready(EventNotifier *notifier)
{
ThreadPool *pool = container_of(notifier, ThreadPool, notifier);
ThreadPoolElement *elem, *next;
event_notifier_test_and_clear(notifier);
restart:
QLIST_FOREACH_SAFE(elem, &pool->head, all, next) {
if (elem->state != THREAD_CANCELED && elem->state != THREAD_DONE) {
continue;
}
if (elem->state == THREAD_DONE) {
trace_thread_pool_complete(pool, elem, elem->common.opaque,
elem->ret);
}
if (elem->state == THREAD_DONE && elem->common.cb) {
QLIST_REMOVE(elem, all);
/* Read state before ret. */
smp_rmb();
elem->common.cb(elem->common.opaque, elem->ret);
qemu_aio_release(elem);
goto restart;
} else {
/* remove the request */
QLIST_REMOVE(elem, all);
qemu_aio_release(elem);
}
}
}
| false | qemu | c2e50e3d11a0bf4c973cc30478c1af0f2d5f8e81 | static void event_notifier_ready(EventNotifier *notifier)
{
ThreadPool *pool = container_of(notifier, ThreadPool, notifier);
ThreadPoolElement *elem, *next;
event_notifier_test_and_clear(notifier);
restart:
QLIST_FOREACH_SAFE(elem, &pool->head, all, next) {
if (elem->state != THREAD_CANCELED && elem->state != THREAD_DONE) {
continue;
}
if (elem->state == THREAD_DONE) {
trace_thread_pool_complete(pool, elem, elem->common.opaque,
elem->ret);
}
if (elem->state == THREAD_DONE && elem->common.cb) {
QLIST_REMOVE(elem, all);
smp_rmb();
elem->common.cb(elem->common.opaque, elem->ret);
qemu_aio_release(elem);
goto restart;
} else {
QLIST_REMOVE(elem, all);
qemu_aio_release(elem);
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(EventNotifier *VAR_0)
{
ThreadPool *pool = container_of(VAR_0, ThreadPool, VAR_0);
ThreadPoolElement *elem, *next;
event_notifier_test_and_clear(VAR_0);
restart:
QLIST_FOREACH_SAFE(elem, &pool->head, all, next) {
if (elem->state != THREAD_CANCELED && elem->state != THREAD_DONE) {
continue;
}
if (elem->state == THREAD_DONE) {
trace_thread_pool_complete(pool, elem, elem->common.opaque,
elem->ret);
}
if (elem->state == THREAD_DONE && elem->common.cb) {
QLIST_REMOVE(elem, all);
smp_rmb();
elem->common.cb(elem->common.opaque, elem->ret);
qemu_aio_release(elem);
goto restart;
} else {
QLIST_REMOVE(elem, all);
qemu_aio_release(elem);
}
}
}
| [
"static void FUNC_0(EventNotifier *VAR_0)\n{",
"ThreadPool *pool = container_of(VAR_0, ThreadPool, VAR_0);",
"ThreadPoolElement *elem, *next;",
"event_notifier_test_and_clear(VAR_0);",
"restart:\nQLIST_FOREACH_SAFE(elem, &pool->head, all, next) {",
"if (elem->state != THREAD_CANCELED && elem->state != THREAD_DONE) {",
"continue;",
"}",
"if (elem->state == THREAD_DONE) {",
"trace_thread_pool_complete(pool, elem, elem->common.opaque,\nelem->ret);",
"}",
"if (elem->state == THREAD_DONE && elem->common.cb) {",
"QLIST_REMOVE(elem, all);",
"smp_rmb();",
"elem->common.cb(elem->common.opaque, elem->ret);",
"qemu_aio_release(elem);",
"goto restart;",
"} else {",
"QLIST_REMOVE(elem, all);",
"qemu_aio_release(elem);",
"}",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
]
]
|
12,742 | static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
GXFContext *gxf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st = s->streams[pkt->stream_index];
int64_t pos = avio_tell(pb);
int padding = 0;
int packet_start_offset = avio_tell(pb) / 1024;
gxf_write_packet_header(pb, PKT_MEDIA);
if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4) /* MPEG-2 frames must be padded */
padding = 4 - pkt->size % 4;
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
gxf_write_media_preamble(s, pkt, pkt->size + padding);
avio_write(pb, pkt->data, pkt->size);
gxf_write_padding(pb, padding);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (!(gxf->flt_entries_nb % 500)) {
int err;
if ((err = av_reallocp_array(&gxf->flt_entries,
gxf->flt_entries_nb + 500,
sizeof(*gxf->flt_entries))) < 0) {
gxf->flt_entries_nb = 0;
av_log(s, AV_LOG_ERROR, "could not reallocate flt entries\n");
return err;
}
}
gxf->flt_entries[gxf->flt_entries_nb++] = packet_start_offset;
gxf->nb_fields += 2; // count fields
}
updatePacketSize(pb, pos);
gxf->packet_count++;
if (gxf->packet_count == 100) {
gxf_write_map_packet(s, 0);
gxf->packet_count = 0;
}
return 0;
}
| false | FFmpeg | a6ca08f1af31badb7fef93bc1cbfa78bffae6be7 | static int gxf_write_packet(AVFormatContext *s, AVPacket *pkt)
{
GXFContext *gxf = s->priv_data;
AVIOContext *pb = s->pb;
AVStream *st = s->streams[pkt->stream_index];
int64_t pos = avio_tell(pb);
int padding = 0;
int packet_start_offset = avio_tell(pb) / 1024;
gxf_write_packet_header(pb, PKT_MEDIA);
if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && pkt->size % 4)
padding = 4 - pkt->size % 4;
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
padding = GXF_AUDIO_PACKET_SIZE - pkt->size;
gxf_write_media_preamble(s, pkt, pkt->size + padding);
avio_write(pb, pkt->data, pkt->size);
gxf_write_padding(pb, padding);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (!(gxf->flt_entries_nb % 500)) {
int err;
if ((err = av_reallocp_array(&gxf->flt_entries,
gxf->flt_entries_nb + 500,
sizeof(*gxf->flt_entries))) < 0) {
gxf->flt_entries_nb = 0;
av_log(s, AV_LOG_ERROR, "could not reallocate flt entries\n");
return err;
}
}
gxf->flt_entries[gxf->flt_entries_nb++] = packet_start_offset;
gxf->nb_fields += 2;
}
updatePacketSize(pb, pos);
gxf->packet_count++;
if (gxf->packet_count == 100) {
gxf_write_map_packet(s, 0);
gxf->packet_count = 0;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
GXFContext *gxf = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
AVStream *st = VAR_0->streams[VAR_1->stream_index];
int64_t pos = avio_tell(pb);
int VAR_2 = 0;
int VAR_3 = avio_tell(pb) / 1024;
gxf_write_packet_header(pb, PKT_MEDIA);
if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && VAR_1->size % 4)
VAR_2 = 4 - VAR_1->size % 4;
else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
VAR_2 = GXF_AUDIO_PACKET_SIZE - VAR_1->size;
gxf_write_media_preamble(VAR_0, VAR_1, VAR_1->size + VAR_2);
avio_write(pb, VAR_1->data, VAR_1->size);
gxf_write_padding(pb, VAR_2);
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
if (!(gxf->flt_entries_nb % 500)) {
int VAR_4;
if ((VAR_4 = av_reallocp_array(&gxf->flt_entries,
gxf->flt_entries_nb + 500,
sizeof(*gxf->flt_entries))) < 0) {
gxf->flt_entries_nb = 0;
av_log(VAR_0, AV_LOG_ERROR, "could not reallocate flt entries\n");
return VAR_4;
}
}
gxf->flt_entries[gxf->flt_entries_nb++] = VAR_3;
gxf->nb_fields += 2;
}
updatePacketSize(pb, pos);
gxf->packet_count++;
if (gxf->packet_count == 100) {
gxf_write_map_packet(VAR_0, 0);
gxf->packet_count = 0;
}
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"GXFContext *gxf = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"AVStream *st = VAR_0->streams[VAR_1->stream_index];",
"int64_t pos = avio_tell(pb);",
"int VAR_2 = 0;",
"int VAR_3 = avio_tell(pb) / 1024;",
"gxf_write_packet_header(pb, PKT_MEDIA);",
"if (st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO && VAR_1->size % 4)\nVAR_2 = 4 - VAR_1->size % 4;",
"else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO)\nVAR_2 = GXF_AUDIO_PACKET_SIZE - VAR_1->size;",
"gxf_write_media_preamble(VAR_0, VAR_1, VAR_1->size + VAR_2);",
"avio_write(pb, VAR_1->data, VAR_1->size);",
"gxf_write_padding(pb, VAR_2);",
"if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {",
"if (!(gxf->flt_entries_nb % 500)) {",
"int VAR_4;",
"if ((VAR_4 = av_reallocp_array(&gxf->flt_entries,\ngxf->flt_entries_nb + 500,\nsizeof(*gxf->flt_entries))) < 0) {",
"gxf->flt_entries_nb = 0;",
"av_log(VAR_0, AV_LOG_ERROR, \"could not reallocate flt entries\\n\");",
"return VAR_4;",
"}",
"}",
"gxf->flt_entries[gxf->flt_entries_nb++] = VAR_3;",
"gxf->nb_fields += 2;",
"}",
"updatePacketSize(pb, pos);",
"gxf->packet_count++;",
"if (gxf->packet_count == 100) {",
"gxf_write_map_packet(VAR_0, 0);",
"gxf->packet_count = 0;",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43,
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
]
]
|
12,743 | static CharDriverState *qmp_chardev_open_parallel(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
ChardevHostdev *parallel = backend->u.parallel;
int fd;
fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
if (fd < 0) {
return NULL;
}
return qemu_chr_open_pp_fd(fd, errp);
}
| false | qemu | d0d7708ba29cbcc343364a46bff981e0ff88366f | static CharDriverState *qmp_chardev_open_parallel(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
ChardevHostdev *parallel = backend->u.parallel;
int fd;
fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
if (fd < 0) {
return NULL;
}
return qemu_chr_open_pp_fd(fd, errp);
}
| {
"code": [],
"line_no": []
} | static CharDriverState *FUNC_0(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
ChardevHostdev *parallel = backend->u.parallel;
int VAR_0;
VAR_0 = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);
if (VAR_0 < 0) {
return NULL;
}
return qemu_chr_open_pp_fd(VAR_0, errp);
}
| [
"static CharDriverState *FUNC_0(const char *id,\nChardevBackend *backend,\nChardevReturn *ret,\nError **errp)\n{",
"ChardevHostdev *parallel = backend->u.parallel;",
"int VAR_0;",
"VAR_0 = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp);",
"if (VAR_0 < 0) {",
"return NULL;",
"}",
"return qemu_chr_open_pp_fd(VAR_0, errp);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
]
]
|
12,744 | void qemu_peer_using_vnet_hdr(NetClientState *nc, bool enable)
{
if (!nc->peer || !nc->peer->info->using_vnet_hdr) {
return;
}
nc->peer->info->using_vnet_hdr(nc->peer, enable);
}
| false | qemu | d6085e3ace20bc9b0fa625d8d79b22668710e217 | void qemu_peer_using_vnet_hdr(NetClientState *nc, bool enable)
{
if (!nc->peer || !nc->peer->info->using_vnet_hdr) {
return;
}
nc->peer->info->using_vnet_hdr(nc->peer, enable);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(NetClientState *VAR_0, bool VAR_1)
{
if (!VAR_0->peer || !VAR_0->peer->info->using_vnet_hdr) {
return;
}
VAR_0->peer->info->using_vnet_hdr(VAR_0->peer, VAR_1);
}
| [
"void FUNC_0(NetClientState *VAR_0, bool VAR_1)\n{",
"if (!VAR_0->peer || !VAR_0->peer->info->using_vnet_hdr) {",
"return;",
"}",
"VAR_0->peer->info->using_vnet_hdr(VAR_0->peer, VAR_1);",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
]
]
|
12,746 | static int scsi_block_initfn(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
int sg_version;
int rc;
if (!s->qdev.conf.bs) {
error_report("drive property not set");
return -1;
}
/* check we are using a driver managing SG_IO (version 3 and after) */
rc = bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERSION_NUM, &sg_version);
if (rc < 0) {
error_report("cannot get SG_IO version number: %s. "
"Is this a SCSI device?",
strerror(-rc));
return -1;
}
if (sg_version < 30000) {
error_report("scsi generic interface too old");
return -1;
}
/* get device type from INQUIRY data */
rc = get_device_type(s);
if (rc < 0) {
error_report("INQUIRY failed");
return -1;
}
/* Make a guess for the block size, we'll fix it when the guest sends.
* READ CAPACITY. If they don't, they likely would assume these sizes
* anyway. (TODO: check in /sys).
*/
if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) {
s->qdev.blocksize = 2048;
} else {
s->qdev.blocksize = 512;
}
/* Makes the scsi-block device not removable by using HMP and QMP eject
* command.
*/
s->features |= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS);
return scsi_initfn(&s->qdev);
}
| false | qemu | a818a4b69d47ca3826dee36878074395aeac2083 | static int scsi_block_initfn(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
int sg_version;
int rc;
if (!s->qdev.conf.bs) {
error_report("drive property not set");
return -1;
}
rc = bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERSION_NUM, &sg_version);
if (rc < 0) {
error_report("cannot get SG_IO version number: %s. "
"Is this a SCSI device?",
strerror(-rc));
return -1;
}
if (sg_version < 30000) {
error_report("scsi generic interface too old");
return -1;
}
rc = get_device_type(s);
if (rc < 0) {
error_report("INQUIRY failed");
return -1;
}
if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) {
s->qdev.blocksize = 2048;
} else {
s->qdev.blocksize = 512;
}
s->features |= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS);
return scsi_initfn(&s->qdev);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(SCSIDevice *VAR_0)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0);
int VAR_1;
int VAR_2;
if (!s->qdev.conf.bs) {
error_report("drive property not set");
return -1;
}
VAR_2 = bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERSION_NUM, &VAR_1);
if (VAR_2 < 0) {
error_report("cannot get SG_IO version number: %s. "
"Is this a SCSI device?",
strerror(-VAR_2));
return -1;
}
if (VAR_1 < 30000) {
error_report("scsi generic interface too old");
return -1;
}
VAR_2 = get_device_type(s);
if (VAR_2 < 0) {
error_report("INQUIRY failed");
return -1;
}
if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) {
s->qdev.blocksize = 2048;
} else {
s->qdev.blocksize = 512;
}
s->features |= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS);
return scsi_initfn(&s->qdev);
}
| [
"static int FUNC_0(SCSIDevice *VAR_0)\n{",
"SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0);",
"int VAR_1;",
"int VAR_2;",
"if (!s->qdev.conf.bs) {",
"error_report(\"drive property not set\");",
"return -1;",
"}",
"VAR_2 = bdrv_ioctl(s->qdev.conf.bs, SG_GET_VERSION_NUM, &VAR_1);",
"if (VAR_2 < 0) {",
"error_report(\"cannot get SG_IO version number: %s. \"\n\"Is this a SCSI device?\",\nstrerror(-VAR_2));",
"return -1;",
"}",
"if (VAR_1 < 30000) {",
"error_report(\"scsi generic interface too old\");",
"return -1;",
"}",
"VAR_2 = get_device_type(s);",
"if (VAR_2 < 0) {",
"error_report(\"INQUIRY failed\");",
"return -1;",
"}",
"if (s->qdev.type == TYPE_ROM || s->qdev.type == TYPE_WORM) {",
"s->qdev.blocksize = 2048;",
"} else {",
"s->qdev.blocksize = 512;",
"}",
"s->features |= (1 << SCSI_DISK_F_NO_REMOVABLE_DEVOPS);",
"return scsi_initfn(&s->qdev);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29,
31,
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
89
],
[
93
],
[
95
]
]
|
12,747 | static int vga_initfn(ISADevice *dev)
{
ISACirrusVGAState *d = DO_UPCAST(ISACirrusVGAState, dev, dev);
VGACommonState *s = &d->cirrus_vga.vga;
vga_common_init(s);
cirrus_init_common(&d->cirrus_vga, CIRRUS_ID_CLGD5430, 0,
isa_address_space(dev), isa_address_space_io(dev));
s->con = graphic_console_init(s->update, s->invalidate,
s->screen_dump, s->text_update,
s);
rom_add_vga(VGABIOS_CIRRUS_FILENAME);
/* XXX ISA-LFB support */
/* FIXME not qdev yet */
return 0;
}
| false | qemu | 2c62f08ddbf3fa80dc7202eb9a2ea60ae44e2cc5 | static int vga_initfn(ISADevice *dev)
{
ISACirrusVGAState *d = DO_UPCAST(ISACirrusVGAState, dev, dev);
VGACommonState *s = &d->cirrus_vga.vga;
vga_common_init(s);
cirrus_init_common(&d->cirrus_vga, CIRRUS_ID_CLGD5430, 0,
isa_address_space(dev), isa_address_space_io(dev));
s->con = graphic_console_init(s->update, s->invalidate,
s->screen_dump, s->text_update,
s);
rom_add_vga(VGABIOS_CIRRUS_FILENAME);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(ISADevice *VAR_0)
{
ISACirrusVGAState *d = DO_UPCAST(ISACirrusVGAState, VAR_0, VAR_0);
VGACommonState *s = &d->cirrus_vga.vga;
vga_common_init(s);
cirrus_init_common(&d->cirrus_vga, CIRRUS_ID_CLGD5430, 0,
isa_address_space(VAR_0), isa_address_space_io(VAR_0));
s->con = graphic_console_init(s->update, s->invalidate,
s->screen_dump, s->text_update,
s);
rom_add_vga(VGABIOS_CIRRUS_FILENAME);
return 0;
}
| [
"static int FUNC_0(ISADevice *VAR_0)\n{",
"ISACirrusVGAState *d = DO_UPCAST(ISACirrusVGAState, VAR_0, VAR_0);",
"VGACommonState *s = &d->cirrus_vga.vga;",
"vga_common_init(s);",
"cirrus_init_common(&d->cirrus_vga, CIRRUS_ID_CLGD5430, 0,\nisa_address_space(VAR_0), isa_address_space_io(VAR_0));",
"s->con = graphic_console_init(s->update, s->invalidate,\ns->screen_dump, s->text_update,\ns);",
"rom_add_vga(VGABIOS_CIRRUS_FILENAME);",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15
],
[
17,
19,
21
],
[
23
],
[
29
],
[
31
]
]
|
12,748 | void memory_region_register_iommu_notifier(MemoryRegion *mr, Notifier *n)
{
if (mr->iommu_ops->notify_started &&
QLIST_EMPTY(&mr->iommu_notify.notifiers)) {
mr->iommu_ops->notify_started(mr);
}
notifier_list_add(&mr->iommu_notify, n);
}
| false | qemu | cdb3081269347fd9271fd1b7a9df312e2953bdd9 | void memory_region_register_iommu_notifier(MemoryRegion *mr, Notifier *n)
{
if (mr->iommu_ops->notify_started &&
QLIST_EMPTY(&mr->iommu_notify.notifiers)) {
mr->iommu_ops->notify_started(mr);
}
notifier_list_add(&mr->iommu_notify, n);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(MemoryRegion *VAR_0, Notifier *VAR_1)
{
if (VAR_0->iommu_ops->notify_started &&
QLIST_EMPTY(&VAR_0->iommu_notify.notifiers)) {
VAR_0->iommu_ops->notify_started(VAR_0);
}
notifier_list_add(&VAR_0->iommu_notify, VAR_1);
}
| [
"void FUNC_0(MemoryRegion *VAR_0, Notifier *VAR_1)\n{",
"if (VAR_0->iommu_ops->notify_started &&\nQLIST_EMPTY(&VAR_0->iommu_notify.notifiers)) {",
"VAR_0->iommu_ops->notify_started(VAR_0);",
"}",
"notifier_list_add(&VAR_0->iommu_notify, VAR_1);",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
]
]
|
12,749 | static void pc_init1(MachineState *machine)
{
PCMachineState *pc_machine = PC_MACHINE(machine);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int i;
ram_addr_t below_4g_mem_size, above_4g_mem_size;
PCIBus *pci_bus;
ISABus *isa_bus;
PCII440FXState *i440fx_state;
int piix3_devfn = -1;
qemu_irq *cpu_irq;
qemu_irq *gsi;
qemu_irq *i8259;
qemu_irq *smi_irq;
GSIState *gsi_state;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
BusState *idebus[MAX_IDE_BUS];
ISADevice *rtc_state;
ISADevice *floppy;
MemoryRegion *ram_memory;
MemoryRegion *pci_memory;
MemoryRegion *rom_memory;
DeviceState *icc_bridge;
FWCfgState *fw_cfg = NULL;
PcGuestInfo *guest_info;
ram_addr_t lowmem;
/* Check whether RAM fits below 4G (leaving 1/2 GByte for IO memory).
* If it doesn't, we need to split it in chunks below and above 4G.
* In any case, try to make sure that guest addresses aligned at
* 1G boundaries get mapped to host addresses aligned at 1G boundaries.
* For old machine types, use whatever split we used historically to avoid
* breaking migration.
*/
if (machine->ram_size >= 0xe0000000) {
lowmem = gigabyte_align ? 0xc0000000 : 0xe0000000;
} else {
lowmem = 0xe0000000;
}
/* Handle the machine opt max-ram-below-4g. It is basically doing
* min(qemu limit, user limit).
*/
if (lowmem > pc_machine->max_ram_below_4g) {
lowmem = pc_machine->max_ram_below_4g;
if (machine->ram_size - lowmem > lowmem &&
lowmem & ((1ULL << 30) - 1)) {
error_report("Warning: Large machine and max_ram_below_4g(%"PRIu64
") not a multiple of 1G; possible bad performance.",
pc_machine->max_ram_below_4g);
}
}
if (machine->ram_size >= lowmem) {
above_4g_mem_size = machine->ram_size - lowmem;
below_4g_mem_size = lowmem;
} else {
above_4g_mem_size = 0;
below_4g_mem_size = machine->ram_size;
}
if (xen_enabled() && xen_hvm_init(&below_4g_mem_size, &above_4g_mem_size,
&ram_memory) != 0) {
fprintf(stderr, "xen hardware virtual machine initialisation failed\n");
exit(1);
}
icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE);
object_property_add_child(qdev_get_machine(), "icc-bridge",
OBJECT(icc_bridge), NULL);
pc_cpus_init(machine->cpu_model, icc_bridge);
if (kvm_enabled() && kvmclock_enabled) {
kvmclock_create();
}
if (pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
memory_region_init(pci_memory, NULL, "pci", UINT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size);
guest_info->has_acpi_build = has_acpi_build;
guest_info->legacy_acpi_table_size = legacy_acpi_table_size;
guest_info->isapc_ram_fw = !pci_enabled;
guest_info->has_reserved_memory = has_reserved_memory;
guest_info->rsdp_in_ram = rsdp_in_ram;
if (smbios_defaults) {
MachineClass *mc = MACHINE_GET_CLASS(machine);
/* These values are guest ABI, do not change */
smbios_set_defaults("QEMU", "Standard PC (i440FX + PIIX, 1996)",
mc->name, smbios_legacy_mode, smbios_uuid_encoded);
}
/* allocate ram and load rom/bios */
if (!xen_enabled()) {
fw_cfg = pc_memory_init(machine, system_memory,
below_4g_mem_size, above_4g_mem_size,
rom_memory, &ram_memory, guest_info);
} else if (machine->kernel_filename != NULL) {
/* For xen HVM direct kernel boot, load linux here */
fw_cfg = xen_load_linux(machine->kernel_filename,
machine->kernel_cmdline,
machine->initrd_filename,
below_4g_mem_size,
guest_info);
}
gsi_state = g_malloc0(sizeof(*gsi_state));
if (kvm_irqchip_in_kernel()) {
kvm_pc_setup_irq_routing(pci_enabled);
gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,
GSI_NUM_PINS);
} else {
gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
}
if (pci_enabled) {
pci_bus = i440fx_init(&i440fx_state, &piix3_devfn, &isa_bus, gsi,
system_memory, system_io, machine->ram_size,
below_4g_mem_size,
above_4g_mem_size,
pci_memory, ram_memory);
} else {
pci_bus = NULL;
i440fx_state = NULL;
isa_bus = isa_bus_new(NULL, get_system_memory(), system_io);
no_hpet = 1;
}
isa_bus_irqs(isa_bus, gsi);
if (kvm_irqchip_in_kernel()) {
i8259 = kvm_i8259_init(isa_bus);
} else if (xen_enabled()) {
i8259 = xen_interrupt_controller_init();
} else {
cpu_irq = pc_allocate_cpu_irq();
i8259 = i8259_init(isa_bus, cpu_irq[0]);
}
for (i = 0; i < ISA_NUM_IRQS; i++) {
gsi_state->i8259_irq[i] = i8259[i];
}
if (pci_enabled) {
ioapic_init_gsi(gsi_state, "i440fx");
}
qdev_init_nofail(icc_bridge);
pc_register_ferr_irq(gsi[13]);
pc_vga_init(isa_bus, pci_enabled ? pci_bus : NULL);
assert(pc_machine->vmport != ON_OFF_AUTO_MAX);
if (pc_machine->vmport == ON_OFF_AUTO_AUTO) {
pc_machine->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;
}
/* init basic PC hardware */
pc_basic_device_init(isa_bus, gsi, &rtc_state, true, &floppy,
(pc_machine->vmport != ON_OFF_AUTO_ON), 0x4);
pc_nic_init(isa_bus, pci_bus);
ide_drive_get(hd, ARRAY_SIZE(hd));
if (pci_enabled) {
PCIDevice *dev;
if (xen_enabled()) {
dev = pci_piix3_xen_ide_init(pci_bus, hd, piix3_devfn + 1);
} else {
dev = pci_piix3_ide_init(pci_bus, hd, piix3_devfn + 1);
}
idebus[0] = qdev_get_child_bus(&dev->qdev, "ide.0");
idebus[1] = qdev_get_child_bus(&dev->qdev, "ide.1");
} else {
for(i = 0; i < MAX_IDE_BUS; i++) {
ISADevice *dev;
char busname[] = "ide.0";
dev = isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i],
ide_irq[i],
hd[MAX_IDE_DEVS * i], hd[MAX_IDE_DEVS * i + 1]);
/*
* The ide bus name is ide.0 for the first bus and ide.1 for the
* second one.
*/
busname[4] = '0' + i;
idebus[i] = qdev_get_child_bus(DEVICE(dev), busname);
}
}
pc_cmos_init(below_4g_mem_size, above_4g_mem_size, machine->boot_order,
machine, floppy, idebus[0], idebus[1], rtc_state);
if (pci_enabled && usb_enabled()) {
pci_create_simple(pci_bus, piix3_devfn + 2, "piix3-usb-uhci");
}
if (pci_enabled && acpi_enabled) {
DeviceState *piix4_pm;
I2CBus *smbus;
smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);
/* TODO: Populate SPD eeprom data. */
smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
gsi[9], *smi_irq,
kvm_enabled(), fw_cfg, &piix4_pm);
smbus_eeprom_init(smbus, 8, NULL, 0);
object_property_add_link(OBJECT(machine), PC_MACHINE_ACPI_DEVICE_PROP,
TYPE_HOTPLUG_HANDLER,
(Object **)&pc_machine->acpi_dev,
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);
object_property_set_link(OBJECT(machine), OBJECT(piix4_pm),
PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
}
if (pci_enabled) {
pc_pci_device_init(pci_bus);
}
}
| false | qemu | 6e7d82497dc8da7d420c8fa6632d759e08a18bc3 | static void pc_init1(MachineState *machine)
{
PCMachineState *pc_machine = PC_MACHINE(machine);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int i;
ram_addr_t below_4g_mem_size, above_4g_mem_size;
PCIBus *pci_bus;
ISABus *isa_bus;
PCII440FXState *i440fx_state;
int piix3_devfn = -1;
qemu_irq *cpu_irq;
qemu_irq *gsi;
qemu_irq *i8259;
qemu_irq *smi_irq;
GSIState *gsi_state;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
BusState *idebus[MAX_IDE_BUS];
ISADevice *rtc_state;
ISADevice *floppy;
MemoryRegion *ram_memory;
MemoryRegion *pci_memory;
MemoryRegion *rom_memory;
DeviceState *icc_bridge;
FWCfgState *fw_cfg = NULL;
PcGuestInfo *guest_info;
ram_addr_t lowmem;
if (machine->ram_size >= 0xe0000000) {
lowmem = gigabyte_align ? 0xc0000000 : 0xe0000000;
} else {
lowmem = 0xe0000000;
}
if (lowmem > pc_machine->max_ram_below_4g) {
lowmem = pc_machine->max_ram_below_4g;
if (machine->ram_size - lowmem > lowmem &&
lowmem & ((1ULL << 30) - 1)) {
error_report("Warning: Large machine and max_ram_below_4g(%"PRIu64
") not a multiple of 1G; possible bad performance.",
pc_machine->max_ram_below_4g);
}
}
if (machine->ram_size >= lowmem) {
above_4g_mem_size = machine->ram_size - lowmem;
below_4g_mem_size = lowmem;
} else {
above_4g_mem_size = 0;
below_4g_mem_size = machine->ram_size;
}
if (xen_enabled() && xen_hvm_init(&below_4g_mem_size, &above_4g_mem_size,
&ram_memory) != 0) {
fprintf(stderr, "xen hardware virtual machine initialisation failed\n");
exit(1);
}
icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE);
object_property_add_child(qdev_get_machine(), "icc-bridge",
OBJECT(icc_bridge), NULL);
pc_cpus_init(machine->cpu_model, icc_bridge);
if (kvm_enabled() && kvmclock_enabled) {
kvmclock_create();
}
if (pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
memory_region_init(pci_memory, NULL, "pci", UINT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size);
guest_info->has_acpi_build = has_acpi_build;
guest_info->legacy_acpi_table_size = legacy_acpi_table_size;
guest_info->isapc_ram_fw = !pci_enabled;
guest_info->has_reserved_memory = has_reserved_memory;
guest_info->rsdp_in_ram = rsdp_in_ram;
if (smbios_defaults) {
MachineClass *mc = MACHINE_GET_CLASS(machine);
smbios_set_defaults("QEMU", "Standard PC (i440FX + PIIX, 1996)",
mc->name, smbios_legacy_mode, smbios_uuid_encoded);
}
if (!xen_enabled()) {
fw_cfg = pc_memory_init(machine, system_memory,
below_4g_mem_size, above_4g_mem_size,
rom_memory, &ram_memory, guest_info);
} else if (machine->kernel_filename != NULL) {
fw_cfg = xen_load_linux(machine->kernel_filename,
machine->kernel_cmdline,
machine->initrd_filename,
below_4g_mem_size,
guest_info);
}
gsi_state = g_malloc0(sizeof(*gsi_state));
if (kvm_irqchip_in_kernel()) {
kvm_pc_setup_irq_routing(pci_enabled);
gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,
GSI_NUM_PINS);
} else {
gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
}
if (pci_enabled) {
pci_bus = i440fx_init(&i440fx_state, &piix3_devfn, &isa_bus, gsi,
system_memory, system_io, machine->ram_size,
below_4g_mem_size,
above_4g_mem_size,
pci_memory, ram_memory);
} else {
pci_bus = NULL;
i440fx_state = NULL;
isa_bus = isa_bus_new(NULL, get_system_memory(), system_io);
no_hpet = 1;
}
isa_bus_irqs(isa_bus, gsi);
if (kvm_irqchip_in_kernel()) {
i8259 = kvm_i8259_init(isa_bus);
} else if (xen_enabled()) {
i8259 = xen_interrupt_controller_init();
} else {
cpu_irq = pc_allocate_cpu_irq();
i8259 = i8259_init(isa_bus, cpu_irq[0]);
}
for (i = 0; i < ISA_NUM_IRQS; i++) {
gsi_state->i8259_irq[i] = i8259[i];
}
if (pci_enabled) {
ioapic_init_gsi(gsi_state, "i440fx");
}
qdev_init_nofail(icc_bridge);
pc_register_ferr_irq(gsi[13]);
pc_vga_init(isa_bus, pci_enabled ? pci_bus : NULL);
assert(pc_machine->vmport != ON_OFF_AUTO_MAX);
if (pc_machine->vmport == ON_OFF_AUTO_AUTO) {
pc_machine->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;
}
pc_basic_device_init(isa_bus, gsi, &rtc_state, true, &floppy,
(pc_machine->vmport != ON_OFF_AUTO_ON), 0x4);
pc_nic_init(isa_bus, pci_bus);
ide_drive_get(hd, ARRAY_SIZE(hd));
if (pci_enabled) {
PCIDevice *dev;
if (xen_enabled()) {
dev = pci_piix3_xen_ide_init(pci_bus, hd, piix3_devfn + 1);
} else {
dev = pci_piix3_ide_init(pci_bus, hd, piix3_devfn + 1);
}
idebus[0] = qdev_get_child_bus(&dev->qdev, "ide.0");
idebus[1] = qdev_get_child_bus(&dev->qdev, "ide.1");
} else {
for(i = 0; i < MAX_IDE_BUS; i++) {
ISADevice *dev;
char busname[] = "ide.0";
dev = isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i],
ide_irq[i],
hd[MAX_IDE_DEVS * i], hd[MAX_IDE_DEVS * i + 1]);
busname[4] = '0' + i;
idebus[i] = qdev_get_child_bus(DEVICE(dev), busname);
}
}
pc_cmos_init(below_4g_mem_size, above_4g_mem_size, machine->boot_order,
machine, floppy, idebus[0], idebus[1], rtc_state);
if (pci_enabled && usb_enabled()) {
pci_create_simple(pci_bus, piix3_devfn + 2, "piix3-usb-uhci");
}
if (pci_enabled && acpi_enabled) {
DeviceState *piix4_pm;
I2CBus *smbus;
smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);
smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
gsi[9], *smi_irq,
kvm_enabled(), fw_cfg, &piix4_pm);
smbus_eeprom_init(smbus, 8, NULL, 0);
object_property_add_link(OBJECT(machine), PC_MACHINE_ACPI_DEVICE_PROP,
TYPE_HOTPLUG_HANDLER,
(Object **)&pc_machine->acpi_dev,
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);
object_property_set_link(OBJECT(machine), OBJECT(piix4_pm),
PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
}
if (pci_enabled) {
pc_pci_device_init(pci_bus);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(MachineState *VAR_0)
{
PCMachineState *pc_machine = PC_MACHINE(VAR_0);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int VAR_1;
ram_addr_t below_4g_mem_size, above_4g_mem_size;
PCIBus *pci_bus;
ISABus *isa_bus;
PCII440FXState *i440fx_state;
int VAR_2 = -1;
qemu_irq *cpu_irq;
qemu_irq *gsi;
qemu_irq *i8259;
qemu_irq *smi_irq;
GSIState *gsi_state;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
BusState *idebus[MAX_IDE_BUS];
ISADevice *rtc_state;
ISADevice *floppy;
MemoryRegion *ram_memory;
MemoryRegion *pci_memory;
MemoryRegion *rom_memory;
DeviceState *icc_bridge;
FWCfgState *fw_cfg = NULL;
PcGuestInfo *guest_info;
ram_addr_t lowmem;
if (VAR_0->ram_size >= 0xe0000000) {
lowmem = gigabyte_align ? 0xc0000000 : 0xe0000000;
} else {
lowmem = 0xe0000000;
}
if (lowmem > pc_machine->max_ram_below_4g) {
lowmem = pc_machine->max_ram_below_4g;
if (VAR_0->ram_size - lowmem > lowmem &&
lowmem & ((1ULL << 30) - 1)) {
error_report("Warning: Large VAR_0 and max_ram_below_4g(%"PRIu64
") not a multiple of 1G; possible bad performance.",
pc_machine->max_ram_below_4g);
}
}
if (VAR_0->ram_size >= lowmem) {
above_4g_mem_size = VAR_0->ram_size - lowmem;
below_4g_mem_size = lowmem;
} else {
above_4g_mem_size = 0;
below_4g_mem_size = VAR_0->ram_size;
}
if (xen_enabled() && xen_hvm_init(&below_4g_mem_size, &above_4g_mem_size,
&ram_memory) != 0) {
fprintf(stderr, "xen hardware virtual VAR_0 initialisation failed\n");
exit(1);
}
icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE);
object_property_add_child(qdev_get_machine(), "icc-bridge",
OBJECT(icc_bridge), NULL);
pc_cpus_init(VAR_0->cpu_model, icc_bridge);
if (kvm_enabled() && kvmclock_enabled) {
kvmclock_create();
}
if (pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
memory_region_init(pci_memory, NULL, "pci", UINT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size);
guest_info->has_acpi_build = has_acpi_build;
guest_info->legacy_acpi_table_size = legacy_acpi_table_size;
guest_info->isapc_ram_fw = !pci_enabled;
guest_info->has_reserved_memory = has_reserved_memory;
guest_info->rsdp_in_ram = rsdp_in_ram;
if (smbios_defaults) {
MachineClass *mc = MACHINE_GET_CLASS(VAR_0);
smbios_set_defaults("QEMU", "Standard PC (i440FX + PIIX, 1996)",
mc->name, smbios_legacy_mode, smbios_uuid_encoded);
}
if (!xen_enabled()) {
fw_cfg = pc_memory_init(VAR_0, system_memory,
below_4g_mem_size, above_4g_mem_size,
rom_memory, &ram_memory, guest_info);
} else if (VAR_0->kernel_filename != NULL) {
fw_cfg = xen_load_linux(VAR_0->kernel_filename,
VAR_0->kernel_cmdline,
VAR_0->initrd_filename,
below_4g_mem_size,
guest_info);
}
gsi_state = g_malloc0(sizeof(*gsi_state));
if (kvm_irqchip_in_kernel()) {
kvm_pc_setup_irq_routing(pci_enabled);
gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,
GSI_NUM_PINS);
} else {
gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
}
if (pci_enabled) {
pci_bus = i440fx_init(&i440fx_state, &VAR_2, &isa_bus, gsi,
system_memory, system_io, VAR_0->ram_size,
below_4g_mem_size,
above_4g_mem_size,
pci_memory, ram_memory);
} else {
pci_bus = NULL;
i440fx_state = NULL;
isa_bus = isa_bus_new(NULL, get_system_memory(), system_io);
no_hpet = 1;
}
isa_bus_irqs(isa_bus, gsi);
if (kvm_irqchip_in_kernel()) {
i8259 = kvm_i8259_init(isa_bus);
} else if (xen_enabled()) {
i8259 = xen_interrupt_controller_init();
} else {
cpu_irq = pc_allocate_cpu_irq();
i8259 = i8259_init(isa_bus, cpu_irq[0]);
}
for (VAR_1 = 0; VAR_1 < ISA_NUM_IRQS; VAR_1++) {
gsi_state->i8259_irq[VAR_1] = i8259[VAR_1];
}
if (pci_enabled) {
ioapic_init_gsi(gsi_state, "i440fx");
}
qdev_init_nofail(icc_bridge);
pc_register_ferr_irq(gsi[13]);
pc_vga_init(isa_bus, pci_enabled ? pci_bus : NULL);
assert(pc_machine->vmport != ON_OFF_AUTO_MAX);
if (pc_machine->vmport == ON_OFF_AUTO_AUTO) {
pc_machine->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;
}
pc_basic_device_init(isa_bus, gsi, &rtc_state, true, &floppy,
(pc_machine->vmport != ON_OFF_AUTO_ON), 0x4);
pc_nic_init(isa_bus, pci_bus);
ide_drive_get(hd, ARRAY_SIZE(hd));
if (pci_enabled) {
PCIDevice *dev;
if (xen_enabled()) {
dev = pci_piix3_xen_ide_init(pci_bus, hd, VAR_2 + 1);
} else {
dev = pci_piix3_ide_init(pci_bus, hd, VAR_2 + 1);
}
idebus[0] = qdev_get_child_bus(&dev->qdev, "ide.0");
idebus[1] = qdev_get_child_bus(&dev->qdev, "ide.1");
} else {
for(VAR_1 = 0; VAR_1 < MAX_IDE_BUS; VAR_1++) {
ISADevice *dev;
char busname[] = "ide.0";
dev = isa_ide_init(isa_bus, ide_iobase[VAR_1], ide_iobase2[VAR_1],
ide_irq[VAR_1],
hd[MAX_IDE_DEVS * VAR_1], hd[MAX_IDE_DEVS * VAR_1 + 1]);
busname[4] = '0' + VAR_1;
idebus[VAR_1] = qdev_get_child_bus(DEVICE(dev), busname);
}
}
pc_cmos_init(below_4g_mem_size, above_4g_mem_size, VAR_0->boot_order,
VAR_0, floppy, idebus[0], idebus[1], rtc_state);
if (pci_enabled && usb_enabled()) {
pci_create_simple(pci_bus, VAR_2 + 2, "piix3-usb-uhci");
}
if (pci_enabled && acpi_enabled) {
DeviceState *piix4_pm;
I2CBus *smbus;
smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);
smbus = piix4_pm_init(pci_bus, VAR_2 + 3, 0xb100,
gsi[9], *smi_irq,
kvm_enabled(), fw_cfg, &piix4_pm);
smbus_eeprom_init(smbus, 8, NULL, 0);
object_property_add_link(OBJECT(VAR_0), PC_MACHINE_ACPI_DEVICE_PROP,
TYPE_HOTPLUG_HANDLER,
(Object **)&pc_machine->acpi_dev,
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);
object_property_set_link(OBJECT(VAR_0), OBJECT(piix4_pm),
PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
}
if (pci_enabled) {
pc_pci_device_init(pci_bus);
}
}
| [
"static void FUNC_0(MachineState *VAR_0)\n{",
"PCMachineState *pc_machine = PC_MACHINE(VAR_0);",
"MemoryRegion *system_memory = get_system_memory();",
"MemoryRegion *system_io = get_system_io();",
"int VAR_1;",
"ram_addr_t below_4g_mem_size, above_4g_mem_size;",
"PCIBus *pci_bus;",
"ISABus *isa_bus;",
"PCII440FXState *i440fx_state;",
"int VAR_2 = -1;",
"qemu_irq *cpu_irq;",
"qemu_irq *gsi;",
"qemu_irq *i8259;",
"qemu_irq *smi_irq;",
"GSIState *gsi_state;",
"DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];",
"BusState *idebus[MAX_IDE_BUS];",
"ISADevice *rtc_state;",
"ISADevice *floppy;",
"MemoryRegion *ram_memory;",
"MemoryRegion *pci_memory;",
"MemoryRegion *rom_memory;",
"DeviceState *icc_bridge;",
"FWCfgState *fw_cfg = NULL;",
"PcGuestInfo *guest_info;",
"ram_addr_t lowmem;",
"if (VAR_0->ram_size >= 0xe0000000) {",
"lowmem = gigabyte_align ? 0xc0000000 : 0xe0000000;",
"} else {",
"lowmem = 0xe0000000;",
"}",
"if (lowmem > pc_machine->max_ram_below_4g) {",
"lowmem = pc_machine->max_ram_below_4g;",
"if (VAR_0->ram_size - lowmem > lowmem &&\nlowmem & ((1ULL << 30) - 1)) {",
"error_report(\"Warning: Large VAR_0 and max_ram_below_4g(%\"PRIu64\n\") not a multiple of 1G; possible bad performance.\",",
"pc_machine->max_ram_below_4g);",
"}",
"}",
"if (VAR_0->ram_size >= lowmem) {",
"above_4g_mem_size = VAR_0->ram_size - lowmem;",
"below_4g_mem_size = lowmem;",
"} else {",
"above_4g_mem_size = 0;",
"below_4g_mem_size = VAR_0->ram_size;",
"}",
"if (xen_enabled() && xen_hvm_init(&below_4g_mem_size, &above_4g_mem_size,\n&ram_memory) != 0) {",
"fprintf(stderr, \"xen hardware virtual VAR_0 initialisation failed\\n\");",
"exit(1);",
"}",
"icc_bridge = qdev_create(NULL, TYPE_ICC_BRIDGE);",
"object_property_add_child(qdev_get_machine(), \"icc-bridge\",\nOBJECT(icc_bridge), NULL);",
"pc_cpus_init(VAR_0->cpu_model, icc_bridge);",
"if (kvm_enabled() && kvmclock_enabled) {",
"kvmclock_create();",
"}",
"if (pci_enabled) {",
"pci_memory = g_new(MemoryRegion, 1);",
"memory_region_init(pci_memory, NULL, \"pci\", UINT64_MAX);",
"rom_memory = pci_memory;",
"} else {",
"pci_memory = NULL;",
"rom_memory = system_memory;",
"}",
"guest_info = pc_guest_info_init(below_4g_mem_size, above_4g_mem_size);",
"guest_info->has_acpi_build = has_acpi_build;",
"guest_info->legacy_acpi_table_size = legacy_acpi_table_size;",
"guest_info->isapc_ram_fw = !pci_enabled;",
"guest_info->has_reserved_memory = has_reserved_memory;",
"guest_info->rsdp_in_ram = rsdp_in_ram;",
"if (smbios_defaults) {",
"MachineClass *mc = MACHINE_GET_CLASS(VAR_0);",
"smbios_set_defaults(\"QEMU\", \"Standard PC (i440FX + PIIX, 1996)\",\nmc->name, smbios_legacy_mode, smbios_uuid_encoded);",
"}",
"if (!xen_enabled()) {",
"fw_cfg = pc_memory_init(VAR_0, system_memory,\nbelow_4g_mem_size, above_4g_mem_size,\nrom_memory, &ram_memory, guest_info);",
"} else if (VAR_0->kernel_filename != NULL) {",
"fw_cfg = xen_load_linux(VAR_0->kernel_filename,\nVAR_0->kernel_cmdline,\nVAR_0->initrd_filename,\nbelow_4g_mem_size,\nguest_info);",
"}",
"gsi_state = g_malloc0(sizeof(*gsi_state));",
"if (kvm_irqchip_in_kernel()) {",
"kvm_pc_setup_irq_routing(pci_enabled);",
"gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,\nGSI_NUM_PINS);",
"} else {",
"gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);",
"}",
"if (pci_enabled) {",
"pci_bus = i440fx_init(&i440fx_state, &VAR_2, &isa_bus, gsi,\nsystem_memory, system_io, VAR_0->ram_size,\nbelow_4g_mem_size,\nabove_4g_mem_size,\npci_memory, ram_memory);",
"} else {",
"pci_bus = NULL;",
"i440fx_state = NULL;",
"isa_bus = isa_bus_new(NULL, get_system_memory(), system_io);",
"no_hpet = 1;",
"}",
"isa_bus_irqs(isa_bus, gsi);",
"if (kvm_irqchip_in_kernel()) {",
"i8259 = kvm_i8259_init(isa_bus);",
"} else if (xen_enabled()) {",
"i8259 = xen_interrupt_controller_init();",
"} else {",
"cpu_irq = pc_allocate_cpu_irq();",
"i8259 = i8259_init(isa_bus, cpu_irq[0]);",
"}",
"for (VAR_1 = 0; VAR_1 < ISA_NUM_IRQS; VAR_1++) {",
"gsi_state->i8259_irq[VAR_1] = i8259[VAR_1];",
"}",
"if (pci_enabled) {",
"ioapic_init_gsi(gsi_state, \"i440fx\");",
"}",
"qdev_init_nofail(icc_bridge);",
"pc_register_ferr_irq(gsi[13]);",
"pc_vga_init(isa_bus, pci_enabled ? pci_bus : NULL);",
"assert(pc_machine->vmport != ON_OFF_AUTO_MAX);",
"if (pc_machine->vmport == ON_OFF_AUTO_AUTO) {",
"pc_machine->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;",
"}",
"pc_basic_device_init(isa_bus, gsi, &rtc_state, true, &floppy,\n(pc_machine->vmport != ON_OFF_AUTO_ON), 0x4);",
"pc_nic_init(isa_bus, pci_bus);",
"ide_drive_get(hd, ARRAY_SIZE(hd));",
"if (pci_enabled) {",
"PCIDevice *dev;",
"if (xen_enabled()) {",
"dev = pci_piix3_xen_ide_init(pci_bus, hd, VAR_2 + 1);",
"} else {",
"dev = pci_piix3_ide_init(pci_bus, hd, VAR_2 + 1);",
"}",
"idebus[0] = qdev_get_child_bus(&dev->qdev, \"ide.0\");",
"idebus[1] = qdev_get_child_bus(&dev->qdev, \"ide.1\");",
"} else {",
"for(VAR_1 = 0; VAR_1 < MAX_IDE_BUS; VAR_1++) {",
"ISADevice *dev;",
"char busname[] = \"ide.0\";",
"dev = isa_ide_init(isa_bus, ide_iobase[VAR_1], ide_iobase2[VAR_1],\nide_irq[VAR_1],\nhd[MAX_IDE_DEVS * VAR_1], hd[MAX_IDE_DEVS * VAR_1 + 1]);",
"busname[4] = '0' + VAR_1;",
"idebus[VAR_1] = qdev_get_child_bus(DEVICE(dev), busname);",
"}",
"}",
"pc_cmos_init(below_4g_mem_size, above_4g_mem_size, VAR_0->boot_order,\nVAR_0, floppy, idebus[0], idebus[1], rtc_state);",
"if (pci_enabled && usb_enabled()) {",
"pci_create_simple(pci_bus, VAR_2 + 2, \"piix3-usb-uhci\");",
"}",
"if (pci_enabled && acpi_enabled) {",
"DeviceState *piix4_pm;",
"I2CBus *smbus;",
"smi_irq = qemu_allocate_irqs(pc_acpi_smi_interrupt, first_cpu, 1);",
"smbus = piix4_pm_init(pci_bus, VAR_2 + 3, 0xb100,\ngsi[9], *smi_irq,\nkvm_enabled(), fw_cfg, &piix4_pm);",
"smbus_eeprom_init(smbus, 8, NULL, 0);",
"object_property_add_link(OBJECT(VAR_0), PC_MACHINE_ACPI_DEVICE_PROP,\nTYPE_HOTPLUG_HANDLER,\n(Object **)&pc_machine->acpi_dev,\nobject_property_allow_set_link,\nOBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);",
"object_property_set_link(OBJECT(VAR_0), OBJECT(piix4_pm),\nPC_MACHINE_ACPI_DEVICE_PROP, &error_abort);",
"}",
"if (pci_enabled) {",
"pc_pci_device_init(pci_bus);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
89
],
[
91
],
[
93,
95
],
[
97,
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125,
127
],
[
129
],
[
131
],
[
133
],
[
137
],
[
139,
141
],
[
145
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
175
],
[
179
],
[
181
],
[
185
],
[
187
],
[
189
],
[
193
],
[
195
],
[
199,
201
],
[
203
],
[
209
],
[
211,
213,
215
],
[
217
],
[
221,
223,
225,
227,
229
],
[
231
],
[
235
],
[
237
],
[
239
],
[
241,
243
],
[
245
],
[
247
],
[
249
],
[
253
],
[
255,
257,
259,
261,
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
299
],
[
301
],
[
303
],
[
305
],
[
307
],
[
309
],
[
311
],
[
315
],
[
319
],
[
323
],
[
325
],
[
327
],
[
329
],
[
335,
337
],
[
341
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
371
],
[
373,
375,
377
],
[
387
],
[
389
],
[
391
],
[
393
],
[
397,
399
],
[
403
],
[
405
],
[
407
],
[
411
],
[
413
],
[
415
],
[
419
],
[
423,
425,
427
],
[
429
],
[
433,
435,
437,
439,
441
],
[
443,
445
],
[
447
],
[
451
],
[
453
],
[
455
],
[
457
]
]
|
12,750 | static int get_int32_le(QEMUFile *f, void *pv, size_t size)
{
int32_t *old = pv;
int32_t new;
qemu_get_sbe32s(f, &new);
if (*old <= new) {
return 0;
}
return -EINVAL;
}
| false | qemu | 24a370ef2351dc596a7e47508b952ddfba79ef94 | static int get_int32_le(QEMUFile *f, void *pv, size_t size)
{
int32_t *old = pv;
int32_t new;
qemu_get_sbe32s(f, &new);
if (*old <= new) {
return 0;
}
return -EINVAL;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)
{
int32_t *old = VAR_1;
int32_t new;
qemu_get_sbe32s(VAR_0, &new);
if (*old <= new) {
return 0;
}
return -EINVAL;
}
| [
"static int FUNC_0(QEMUFile *VAR_0, void *VAR_1, size_t VAR_2)\n{",
"int32_t *old = VAR_1;",
"int32_t new;",
"qemu_get_sbe32s(VAR_0, &new);",
"if (*old <= new) {",
"return 0;",
"}",
"return -EINVAL;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
]
|
12,751 | static void load_asl(GArray *sdts, AcpiSdtTable *sdt)
{
AcpiSdtTable *temp;
GError *error = NULL;
GString *command_line = g_string_new("'iasl' ");
gint fd;
gchar *out, *out_err;
gboolean ret;
int i;
fd = g_file_open_tmp("asl-XXXXXX.dsl", &sdt->asl_file, &error);
g_assert_no_error(error);
close(fd);
/* build command line */
g_string_append_printf(command_line, "-p %s ", sdt->asl_file);
for (i = 0; i < 2; ++i) { /* reference DSDT and SSDT */
temp = &g_array_index(sdts, AcpiSdtTable, i);
g_string_append_printf(command_line, "-e %s ", temp->aml_file);
}
g_string_append_printf(command_line, "-d %s", sdt->aml_file);
/* pass 'out' and 'out_err' in order to be redirected */
g_spawn_command_line_sync(command_line->str, &out, &out_err, NULL, &error);
g_assert_no_error(error);
ret = g_file_get_contents(sdt->asl_file, (gchar **)&sdt->asl,
&sdt->asl_len, &error);
g_assert(ret);
g_assert_no_error(error);
g_assert(sdt->asl_len);
g_free(out);
g_free(out_err);
g_string_free(command_line, true);
}
| false | qemu | cc8fa0e80836c51ba644d910cd89540a5bc83fc2 | static void load_asl(GArray *sdts, AcpiSdtTable *sdt)
{
AcpiSdtTable *temp;
GError *error = NULL;
GString *command_line = g_string_new("'iasl' ");
gint fd;
gchar *out, *out_err;
gboolean ret;
int i;
fd = g_file_open_tmp("asl-XXXXXX.dsl", &sdt->asl_file, &error);
g_assert_no_error(error);
close(fd);
g_string_append_printf(command_line, "-p %s ", sdt->asl_file);
for (i = 0; i < 2; ++i) {
temp = &g_array_index(sdts, AcpiSdtTable, i);
g_string_append_printf(command_line, "-e %s ", temp->aml_file);
}
g_string_append_printf(command_line, "-d %s", sdt->aml_file);
g_spawn_command_line_sync(command_line->str, &out, &out_err, NULL, &error);
g_assert_no_error(error);
ret = g_file_get_contents(sdt->asl_file, (gchar **)&sdt->asl,
&sdt->asl_len, &error);
g_assert(ret);
g_assert_no_error(error);
g_assert(sdt->asl_len);
g_free(out);
g_free(out_err);
g_string_free(command_line, true);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(GArray *VAR_0, AcpiSdtTable *VAR_1)
{
AcpiSdtTable *temp;
GError *error = NULL;
GString *command_line = g_string_new("'iasl' ");
gint fd;
gchar *out, *out_err;
gboolean ret;
int VAR_2;
fd = g_file_open_tmp("asl-XXXXXX.dsl", &VAR_1->asl_file, &error);
g_assert_no_error(error);
close(fd);
g_string_append_printf(command_line, "-p %s ", VAR_1->asl_file);
for (VAR_2 = 0; VAR_2 < 2; ++VAR_2) {
temp = &g_array_index(VAR_0, AcpiSdtTable, VAR_2);
g_string_append_printf(command_line, "-e %s ", temp->aml_file);
}
g_string_append_printf(command_line, "-d %s", VAR_1->aml_file);
g_spawn_command_line_sync(command_line->str, &out, &out_err, NULL, &error);
g_assert_no_error(error);
ret = g_file_get_contents(VAR_1->asl_file, (gchar **)&VAR_1->asl,
&VAR_1->asl_len, &error);
g_assert(ret);
g_assert_no_error(error);
g_assert(VAR_1->asl_len);
g_free(out);
g_free(out_err);
g_string_free(command_line, true);
}
| [
"static void FUNC_0(GArray *VAR_0, AcpiSdtTable *VAR_1)\n{",
"AcpiSdtTable *temp;",
"GError *error = NULL;",
"GString *command_line = g_string_new(\"'iasl' \");",
"gint fd;",
"gchar *out, *out_err;",
"gboolean ret;",
"int VAR_2;",
"fd = g_file_open_tmp(\"asl-XXXXXX.dsl\", &VAR_1->asl_file, &error);",
"g_assert_no_error(error);",
"close(fd);",
"g_string_append_printf(command_line, \"-p %s \", VAR_1->asl_file);",
"for (VAR_2 = 0; VAR_2 < 2; ++VAR_2) {",
"temp = &g_array_index(VAR_0, AcpiSdtTable, VAR_2);",
"g_string_append_printf(command_line, \"-e %s \", temp->aml_file);",
"}",
"g_string_append_printf(command_line, \"-d %s\", VAR_1->aml_file);",
"g_spawn_command_line_sync(command_line->str, &out, &out_err, NULL, &error);",
"g_assert_no_error(error);",
"ret = g_file_get_contents(VAR_1->asl_file, (gchar **)&VAR_1->asl,\n&VAR_1->asl_len, &error);",
"g_assert(ret);",
"g_assert_no_error(error);",
"g_assert(VAR_1->asl_len);",
"g_free(out);",
"g_free(out_err);",
"g_string_free(command_line, true);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
47
],
[
49
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
]
]
|
12,752 | static void gen_advance_ccount(DisasContext *dc)
{
if (dc->ccount_delta > 0) {
TCGv_i32 tmp = tcg_const_i32(dc->ccount_delta);
dc->ccount_delta = 0;
gen_helper_advance_ccount(cpu_env, tmp);
tcg_temp_free(tmp);
}
}
| false | qemu | 908c67fca4b2c12a9b2336aa9c188f84468b60b7 | static void gen_advance_ccount(DisasContext *dc)
{
if (dc->ccount_delta > 0) {
TCGv_i32 tmp = tcg_const_i32(dc->ccount_delta);
dc->ccount_delta = 0;
gen_helper_advance_ccount(cpu_env, tmp);
tcg_temp_free(tmp);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0)
{
if (VAR_0->ccount_delta > 0) {
TCGv_i32 tmp = tcg_const_i32(VAR_0->ccount_delta);
VAR_0->ccount_delta = 0;
gen_helper_advance_ccount(cpu_env, tmp);
tcg_temp_free(tmp);
}
}
| [
"static void FUNC_0(DisasContext *VAR_0)\n{",
"if (VAR_0->ccount_delta > 0) {",
"TCGv_i32 tmp = tcg_const_i32(VAR_0->ccount_delta);",
"VAR_0->ccount_delta = 0;",
"gen_helper_advance_ccount(cpu_env, tmp);",
"tcg_temp_free(tmp);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
]
|
12,753 | static av_cold int libgsm_close(AVCodecContext *avctx) {
av_freep(&avctx->coded_frame);
gsm_destroy(avctx->priv_data);
avctx->priv_data = NULL;
return 0;
}
| false | FFmpeg | 8febd6afbca652b331ddd8e75e356656c153cad1 | static av_cold int libgsm_close(AVCodecContext *avctx) {
av_freep(&avctx->coded_frame);
gsm_destroy(avctx->priv_data);
avctx->priv_data = NULL;
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx) {
av_freep(&avctx->coded_frame);
gsm_destroy(avctx->priv_data);
avctx->priv_data = NULL;
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx) {",
"av_freep(&avctx->coded_frame);",
"gsm_destroy(avctx->priv_data);",
"avctx->priv_data = NULL;",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
]
]
|
12,754 | static void uhci_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
{
UHCIState *s = opaque;
addr &= 0x1f;
#ifdef DEBUG
printf("uhci writel port=0x%04x val=0x%08x\n", addr, val);
#endif
switch(addr) {
case 0x08:
s->fl_base_addr = val & ~0xfff;
break;
}
}
| false | qemu | 54f254f973a1b2ed0f3571390f4de060adfe23e8 | static void uhci_ioport_writel(void *opaque, uint32_t addr, uint32_t val)
{
UHCIState *s = opaque;
addr &= 0x1f;
#ifdef DEBUG
printf("uhci writel port=0x%04x val=0x%08x\n", addr, val);
#endif
switch(addr) {
case 0x08:
s->fl_base_addr = val & ~0xfff;
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)
{
UHCIState *s = VAR_0;
VAR_1 &= 0x1f;
#ifdef DEBUG
printf("uhci writel port=0x%04x VAR_2=0x%08x\n", VAR_1, VAR_2);
#endif
switch(VAR_1) {
case 0x08:
s->fl_base_addr = VAR_2 & ~0xfff;
break;
}
}
| [
"static void FUNC_0(void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{",
"UHCIState *s = VAR_0;",
"VAR_1 &= 0x1f;",
"#ifdef DEBUG\nprintf(\"uhci writel port=0x%04x VAR_2=0x%08x\\n\", VAR_1, VAR_2);",
"#endif\nswitch(VAR_1) {",
"case 0x08:\ns->fl_base_addr = VAR_2 & ~0xfff;",
"break;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15,
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
]
]
|
12,755 | hwaddr x86_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
target_ulong pde_addr, pte_addr;
uint64_t pte;
hwaddr paddr;
uint32_t page_offset;
int page_size;
if (env->cr[4] & CR4_PAE_MASK) {
target_ulong pdpe_addr;
uint64_t pde, pdpe;
#ifdef TARGET_X86_64
if (env->hflags & HF_LMA_MASK) {
uint64_t pml4e_addr, pml4e;
int32_t sext;
/* test virtual address sign extension */
sext = (int64_t)addr >> 47;
if (sext != 0 && sext != -1)
return -1;
pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
env->a20_mask;
pml4e = ldq_phys(pml4e_addr);
if (!(pml4e & PG_PRESENT_MASK))
return -1;
pdpe_addr = ((pml4e & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 30) & 0x1ff) << 3)) & env->a20_mask;
pdpe = ldq_phys(pdpe_addr);
if (!(pdpe & PG_PRESENT_MASK))
return -1;
} else
#endif
{
pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
env->a20_mask;
pdpe = ldq_phys(pdpe_addr);
if (!(pdpe & PG_PRESENT_MASK))
return -1;
}
pde_addr = ((pdpe & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 21) & 0x1ff) << 3)) & env->a20_mask;
pde = ldq_phys(pde_addr);
if (!(pde & PG_PRESENT_MASK)) {
return -1;
}
if (pde & PG_PSE_MASK) {
/* 2 MB page */
page_size = 2048 * 1024;
pte = pde & ~( (page_size - 1) & ~0xfff); /* align to page_size */
} else {
/* 4 KB page */
pte_addr = ((pde & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 12) & 0x1ff) << 3)) & env->a20_mask;
page_size = 4096;
pte = ldq_phys(pte_addr);
}
pte &= ~(PG_NX_MASK | PG_HI_USER_MASK);
if (!(pte & PG_PRESENT_MASK))
return -1;
} else {
uint32_t pde;
if (!(env->cr[0] & CR0_PG_MASK)) {
pte = addr;
page_size = 4096;
} else {
/* page directory entry */
pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) & env->a20_mask;
pde = ldl_phys(pde_addr);
if (!(pde & PG_PRESENT_MASK))
return -1;
if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
pte = pde & ~0x003ff000; /* align to 4MB */
page_size = 4096 * 1024;
} else {
/* page directory entry */
pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) & env->a20_mask;
pte = ldl_phys(pte_addr);
if (!(pte & PG_PRESENT_MASK))
return -1;
page_size = 4096;
}
}
pte = pte & env->a20_mask;
}
page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
paddr = (pte & TARGET_PAGE_MASK) + page_offset;
return paddr;
}
| false | qemu | f2f8560c7a5303065a2a3207ec475dfb3a622a0e | hwaddr x86_cpu_get_phys_page_debug(CPUState *cs, vaddr addr)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
target_ulong pde_addr, pte_addr;
uint64_t pte;
hwaddr paddr;
uint32_t page_offset;
int page_size;
if (env->cr[4] & CR4_PAE_MASK) {
target_ulong pdpe_addr;
uint64_t pde, pdpe;
#ifdef TARGET_X86_64
if (env->hflags & HF_LMA_MASK) {
uint64_t pml4e_addr, pml4e;
int32_t sext;
sext = (int64_t)addr >> 47;
if (sext != 0 && sext != -1)
return -1;
pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
env->a20_mask;
pml4e = ldq_phys(pml4e_addr);
if (!(pml4e & PG_PRESENT_MASK))
return -1;
pdpe_addr = ((pml4e & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 30) & 0x1ff) << 3)) & env->a20_mask;
pdpe = ldq_phys(pdpe_addr);
if (!(pdpe & PG_PRESENT_MASK))
return -1;
} else
#endif
{
pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
env->a20_mask;
pdpe = ldq_phys(pdpe_addr);
if (!(pdpe & PG_PRESENT_MASK))
return -1;
}
pde_addr = ((pdpe & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 21) & 0x1ff) << 3)) & env->a20_mask;
pde = ldq_phys(pde_addr);
if (!(pde & PG_PRESENT_MASK)) {
return -1;
}
if (pde & PG_PSE_MASK) {
page_size = 2048 * 1024;
pte = pde & ~( (page_size - 1) & ~0xfff);
} else {
pte_addr = ((pde & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 12) & 0x1ff) << 3)) & env->a20_mask;
page_size = 4096;
pte = ldq_phys(pte_addr);
}
pte &= ~(PG_NX_MASK | PG_HI_USER_MASK);
if (!(pte & PG_PRESENT_MASK))
return -1;
} else {
uint32_t pde;
if (!(env->cr[0] & CR0_PG_MASK)) {
pte = addr;
page_size = 4096;
} else {
pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) & env->a20_mask;
pde = ldl_phys(pde_addr);
if (!(pde & PG_PRESENT_MASK))
return -1;
if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
pte = pde & ~0x003ff000;
page_size = 4096 * 1024;
} else {
pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) & env->a20_mask;
pte = ldl_phys(pte_addr);
if (!(pte & PG_PRESENT_MASK))
return -1;
page_size = 4096;
}
}
pte = pte & env->a20_mask;
}
page_offset = (addr & TARGET_PAGE_MASK) & (page_size - 1);
paddr = (pte & TARGET_PAGE_MASK) + page_offset;
return paddr;
}
| {
"code": [],
"line_no": []
} | hwaddr FUNC_0(CPUState *cs, vaddr addr)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
target_ulong pde_addr, pte_addr;
uint64_t pte;
hwaddr paddr;
uint32_t page_offset;
int VAR_0;
if (env->cr[4] & CR4_PAE_MASK) {
target_ulong pdpe_addr;
uint64_t pde, pdpe;
#ifdef TARGET_X86_64
if (env->hflags & HF_LMA_MASK) {
uint64_t pml4e_addr, pml4e;
int32_t sext;
sext = (int64_t)addr >> 47;
if (sext != 0 && sext != -1)
return -1;
pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &
env->a20_mask;
pml4e = ldq_phys(pml4e_addr);
if (!(pml4e & PG_PRESENT_MASK))
return -1;
pdpe_addr = ((pml4e & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 30) & 0x1ff) << 3)) & env->a20_mask;
pdpe = ldq_phys(pdpe_addr);
if (!(pdpe & PG_PRESENT_MASK))
return -1;
} else
#endif
{
pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &
env->a20_mask;
pdpe = ldq_phys(pdpe_addr);
if (!(pdpe & PG_PRESENT_MASK))
return -1;
}
pde_addr = ((pdpe & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 21) & 0x1ff) << 3)) & env->a20_mask;
pde = ldq_phys(pde_addr);
if (!(pde & PG_PRESENT_MASK)) {
return -1;
}
if (pde & PG_PSE_MASK) {
VAR_0 = 2048 * 1024;
pte = pde & ~( (VAR_0 - 1) & ~0xfff);
} else {
pte_addr = ((pde & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +
(((addr >> 12) & 0x1ff) << 3)) & env->a20_mask;
VAR_0 = 4096;
pte = ldq_phys(pte_addr);
}
pte &= ~(PG_NX_MASK | PG_HI_USER_MASK);
if (!(pte & PG_PRESENT_MASK))
return -1;
} else {
uint32_t pde;
if (!(env->cr[0] & CR0_PG_MASK)) {
pte = addr;
VAR_0 = 4096;
} else {
pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) & env->a20_mask;
pde = ldl_phys(pde_addr);
if (!(pde & PG_PRESENT_MASK))
return -1;
if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {
pte = pde & ~0x003ff000;
VAR_0 = 4096 * 1024;
} else {
pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) & env->a20_mask;
pte = ldl_phys(pte_addr);
if (!(pte & PG_PRESENT_MASK))
return -1;
VAR_0 = 4096;
}
}
pte = pte & env->a20_mask;
}
page_offset = (addr & TARGET_PAGE_MASK) & (VAR_0 - 1);
paddr = (pte & TARGET_PAGE_MASK) + page_offset;
return paddr;
}
| [
"hwaddr FUNC_0(CPUState *cs, vaddr addr)\n{",
"X86CPU *cpu = X86_CPU(cs);",
"CPUX86State *env = &cpu->env;",
"target_ulong pde_addr, pte_addr;",
"uint64_t pte;",
"hwaddr paddr;",
"uint32_t page_offset;",
"int VAR_0;",
"if (env->cr[4] & CR4_PAE_MASK) {",
"target_ulong pdpe_addr;",
"uint64_t pde, pdpe;",
"#ifdef TARGET_X86_64\nif (env->hflags & HF_LMA_MASK) {",
"uint64_t pml4e_addr, pml4e;",
"int32_t sext;",
"sext = (int64_t)addr >> 47;",
"if (sext != 0 && sext != -1)\nreturn -1;",
"pml4e_addr = ((env->cr[3] & ~0xfff) + (((addr >> 39) & 0x1ff) << 3)) &\nenv->a20_mask;",
"pml4e = ldq_phys(pml4e_addr);",
"if (!(pml4e & PG_PRESENT_MASK))\nreturn -1;",
"pdpe_addr = ((pml4e & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +\n(((addr >> 30) & 0x1ff) << 3)) & env->a20_mask;",
"pdpe = ldq_phys(pdpe_addr);",
"if (!(pdpe & PG_PRESENT_MASK))\nreturn -1;",
"} else",
"#endif\n{",
"pdpe_addr = ((env->cr[3] & ~0x1f) + ((addr >> 27) & 0x18)) &\nenv->a20_mask;",
"pdpe = ldq_phys(pdpe_addr);",
"if (!(pdpe & PG_PRESENT_MASK))\nreturn -1;",
"}",
"pde_addr = ((pdpe & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +\n(((addr >> 21) & 0x1ff) << 3)) & env->a20_mask;",
"pde = ldq_phys(pde_addr);",
"if (!(pde & PG_PRESENT_MASK)) {",
"return -1;",
"}",
"if (pde & PG_PSE_MASK) {",
"VAR_0 = 2048 * 1024;",
"pte = pde & ~( (VAR_0 - 1) & ~0xfff);",
"} else {",
"pte_addr = ((pde & ~0xfff & ~(PG_NX_MASK | PG_HI_USER_MASK)) +\n(((addr >> 12) & 0x1ff) << 3)) & env->a20_mask;",
"VAR_0 = 4096;",
"pte = ldq_phys(pte_addr);",
"}",
"pte &= ~(PG_NX_MASK | PG_HI_USER_MASK);",
"if (!(pte & PG_PRESENT_MASK))\nreturn -1;",
"} else {",
"uint32_t pde;",
"if (!(env->cr[0] & CR0_PG_MASK)) {",
"pte = addr;",
"VAR_0 = 4096;",
"} else {",
"pde_addr = ((env->cr[3] & ~0xfff) + ((addr >> 20) & 0xffc)) & env->a20_mask;",
"pde = ldl_phys(pde_addr);",
"if (!(pde & PG_PRESENT_MASK))\nreturn -1;",
"if ((pde & PG_PSE_MASK) && (env->cr[4] & CR4_PSE_MASK)) {",
"pte = pde & ~0x003ff000;",
"VAR_0 = 4096 * 1024;",
"} else {",
"pte_addr = ((pde & ~0xfff) + ((addr >> 10) & 0xffc)) & env->a20_mask;",
"pte = ldl_phys(pte_addr);",
"if (!(pte & PG_PRESENT_MASK))\nreturn -1;",
"VAR_0 = 4096;",
"}",
"}",
"pte = pte & env->a20_mask;",
"}",
"page_offset = (addr & TARGET_PAGE_MASK) & (VAR_0 - 1);",
"paddr = (pte & TARGET_PAGE_MASK) + page_offset;",
"return paddr;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29,
31
],
[
33
],
[
35
],
[
41
],
[
43,
45
],
[
49,
51
],
[
53
],
[
55,
57
],
[
61,
63
],
[
65
],
[
67,
69
],
[
71
],
[
73,
75
],
[
77,
79
],
[
81
],
[
83,
85
],
[
87
],
[
91,
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
107
],
[
109
],
[
111
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127,
129
],
[
131
],
[
133
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149
],
[
151,
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
165
],
[
167
],
[
169,
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
185
],
[
187
],
[
189
],
[
191
]
]
|
12,756 | static int hda_audio_init(HDACodecDevice *hda, const struct desc_codec *desc)
{
HDAAudioState *a = HDA_AUDIO(hda);
HDAAudioStream *st;
const desc_node *node;
const desc_param *param;
uint32_t i, type;
a->desc = desc;
a->name = object_get_typename(OBJECT(a));
dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->hda.cad);
AUD_register_card("hda", &a->card);
for (i = 0; i < a->desc->nnodes; i++) {
node = a->desc->nodes + i;
param = hda_codec_find_param(node, AC_PAR_AUDIO_WIDGET_CAP);
if (param == NULL) {
continue;
}
type = (param->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
switch (type) {
case AC_WID_AUD_OUT:
case AC_WID_AUD_IN:
assert(node->stindex < ARRAY_SIZE(a->st));
st = a->st + node->stindex;
st->state = a;
st->node = node;
if (type == AC_WID_AUD_OUT) {
/* unmute output by default */
st->gain_left = QEMU_HDA_AMP_STEPS;
st->gain_right = QEMU_HDA_AMP_STEPS;
st->bpos = sizeof(st->buf);
st->output = true;
} else {
st->output = false;
}
st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |
(1 << AC_FMT_CHAN_SHIFT);
hda_codec_parse_fmt(st->format, &st->as);
hda_audio_setup(st);
break;
}
}
return 0;
}
| false | qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | static int hda_audio_init(HDACodecDevice *hda, const struct desc_codec *desc)
{
HDAAudioState *a = HDA_AUDIO(hda);
HDAAudioStream *st;
const desc_node *node;
const desc_param *param;
uint32_t i, type;
a->desc = desc;
a->name = object_get_typename(OBJECT(a));
dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->hda.cad);
AUD_register_card("hda", &a->card);
for (i = 0; i < a->desc->nnodes; i++) {
node = a->desc->nodes + i;
param = hda_codec_find_param(node, AC_PAR_AUDIO_WIDGET_CAP);
if (param == NULL) {
continue;
}
type = (param->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
switch (type) {
case AC_WID_AUD_OUT:
case AC_WID_AUD_IN:
assert(node->stindex < ARRAY_SIZE(a->st));
st = a->st + node->stindex;
st->state = a;
st->node = node;
if (type == AC_WID_AUD_OUT) {
st->gain_left = QEMU_HDA_AMP_STEPS;
st->gain_right = QEMU_HDA_AMP_STEPS;
st->bpos = sizeof(st->buf);
st->output = true;
} else {
st->output = false;
}
st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |
(1 << AC_FMT_CHAN_SHIFT);
hda_codec_parse_fmt(st->format, &st->as);
hda_audio_setup(st);
break;
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(HDACodecDevice *VAR_0, const struct desc_codec *VAR_1)
{
HDAAudioState *a = HDA_AUDIO(VAR_0);
HDAAudioStream *st;
const desc_node *VAR_2;
const desc_param *VAR_3;
uint32_t i, type;
a->VAR_1 = VAR_1;
a->name = object_get_typename(OBJECT(a));
dprint(a, 1, "%s: cad %d\n", __FUNCTION__, a->VAR_0.cad);
AUD_register_card("VAR_0", &a->card);
for (i = 0; i < a->VAR_1->nnodes; i++) {
VAR_2 = a->VAR_1->nodes + i;
VAR_3 = hda_codec_find_param(VAR_2, AC_PAR_AUDIO_WIDGET_CAP);
if (VAR_3 == NULL) {
continue;
}
type = (VAR_3->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
switch (type) {
case AC_WID_AUD_OUT:
case AC_WID_AUD_IN:
assert(VAR_2->stindex < ARRAY_SIZE(a->st));
st = a->st + VAR_2->stindex;
st->state = a;
st->VAR_2 = VAR_2;
if (type == AC_WID_AUD_OUT) {
st->gain_left = QEMU_HDA_AMP_STEPS;
st->gain_right = QEMU_HDA_AMP_STEPS;
st->bpos = sizeof(st->buf);
st->output = true;
} else {
st->output = false;
}
st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |
(1 << AC_FMT_CHAN_SHIFT);
hda_codec_parse_fmt(st->format, &st->as);
hda_audio_setup(st);
break;
}
}
return 0;
}
| [
"static int FUNC_0(HDACodecDevice *VAR_0, const struct desc_codec *VAR_1)\n{",
"HDAAudioState *a = HDA_AUDIO(VAR_0);",
"HDAAudioStream *st;",
"const desc_node *VAR_2;",
"const desc_param *VAR_3;",
"uint32_t i, type;",
"a->VAR_1 = VAR_1;",
"a->name = object_get_typename(OBJECT(a));",
"dprint(a, 1, \"%s: cad %d\\n\", __FUNCTION__, a->VAR_0.cad);",
"AUD_register_card(\"VAR_0\", &a->card);",
"for (i = 0; i < a->VAR_1->nnodes; i++) {",
"VAR_2 = a->VAR_1->nodes + i;",
"VAR_3 = hda_codec_find_param(VAR_2, AC_PAR_AUDIO_WIDGET_CAP);",
"if (VAR_3 == NULL) {",
"continue;",
"}",
"type = (VAR_3->val & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;",
"switch (type) {",
"case AC_WID_AUD_OUT:\ncase AC_WID_AUD_IN:\nassert(VAR_2->stindex < ARRAY_SIZE(a->st));",
"st = a->st + VAR_2->stindex;",
"st->state = a;",
"st->VAR_2 = VAR_2;",
"if (type == AC_WID_AUD_OUT) {",
"st->gain_left = QEMU_HDA_AMP_STEPS;",
"st->gain_right = QEMU_HDA_AMP_STEPS;",
"st->bpos = sizeof(st->buf);",
"st->output = true;",
"} else {",
"st->output = false;",
"}",
"st->format = AC_FMT_TYPE_PCM | AC_FMT_BITS_16 |\n(1 << AC_FMT_CHAN_SHIFT);",
"hda_codec_parse_fmt(st->format, &st->as);",
"hda_audio_setup(st);",
"break;",
"}",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43,
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
]
]
|
12,757 | static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid,
unsigned int epid, unsigned int streamid)
{
XHCIStreamContext *stctx;
XHCIEPContext *epctx;
XHCIRing *ring;
USBEndpoint *ep = NULL;
uint64_t mfindex;
int length;
int i;
trace_usb_xhci_ep_kick(slotid, epid, streamid);
assert(slotid >= 1 && slotid <= xhci->numslots);
assert(epid >= 1 && epid <= 31);
if (!xhci->slots[slotid-1].enabled) {
DPRINTF("xhci: xhci_kick_ep for disabled slot %d\n", slotid);
return;
}
epctx = xhci->slots[slotid-1].eps[epid-1];
if (!epctx) {
DPRINTF("xhci: xhci_kick_ep for disabled endpoint %d,%d\n",
epid, slotid);
return;
}
/* If the device has been detached, but the guest has not noticed this
yet the 2 above checks will succeed, but we must NOT continue */
if (!xhci->slots[slotid - 1].uport ||
!xhci->slots[slotid - 1].uport->dev ||
!xhci->slots[slotid - 1].uport->dev->attached) {
return;
}
if (epctx->retry) {
XHCITransfer *xfer = epctx->retry;
trace_usb_xhci_xfer_retry(xfer);
assert(xfer->running_retry);
if (xfer->timed_xfer) {
/* time to kick the transfer? */
mfindex = xhci_mfindex_get(xhci);
xhci_check_intr_iso_kick(xhci, xfer, epctx, mfindex);
if (xfer->running_retry) {
return;
}
xfer->timed_xfer = 0;
xfer->running_retry = 1;
}
if (xfer->iso_xfer) {
/* retry iso transfer */
if (xhci_setup_packet(xfer) < 0) {
return;
}
usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
assert(xfer->packet.status != USB_RET_NAK);
xhci_complete_packet(xfer);
} else {
/* retry nak'ed transfer */
if (xhci_setup_packet(xfer) < 0) {
return;
}
usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
if (xfer->packet.status == USB_RET_NAK) {
return;
}
xhci_complete_packet(xfer);
}
assert(!xfer->running_retry);
epctx->retry = NULL;
}
if (epctx->state == EP_HALTED) {
DPRINTF("xhci: ep halted, not running schedule\n");
return;
}
if (epctx->nr_pstreams) {
uint32_t err;
stctx = xhci_find_stream(epctx, streamid, &err);
if (stctx == NULL) {
return;
}
ring = &stctx->ring;
xhci_set_ep_state(xhci, epctx, stctx, EP_RUNNING);
} else {
ring = &epctx->ring;
streamid = 0;
xhci_set_ep_state(xhci, epctx, NULL, EP_RUNNING);
}
assert(ring->dequeue != 0);
while (1) {
XHCITransfer *xfer = &epctx->transfers[epctx->next_xfer];
if (xfer->running_async || xfer->running_retry) {
break;
}
length = xhci_ring_chain_length(xhci, ring);
if (length < 0) {
break;
} else if (length == 0) {
break;
}
if (xfer->trbs && xfer->trb_alloced < length) {
xfer->trb_count = 0;
xfer->trb_alloced = 0;
g_free(xfer->trbs);
xfer->trbs = NULL;
}
if (!xfer->trbs) {
xfer->trbs = g_new(XHCITRB, length);
xfer->trb_alloced = length;
}
xfer->trb_count = length;
for (i = 0; i < length; i++) {
TRBType type;
type = xhci_ring_fetch(xhci, ring, &xfer->trbs[i], NULL);
assert(type);
}
xfer->streamid = streamid;
if (epid == 1) {
if (xhci_fire_ctl_transfer(xhci, xfer) >= 0) {
epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;
} else {
DPRINTF("xhci: error firing CTL transfer\n");
}
} else {
if (xhci_fire_transfer(xhci, xfer, epctx) >= 0) {
epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;
} else {
if (!xfer->timed_xfer) {
DPRINTF("xhci: error firing data transfer\n");
}
}
}
if (epctx->state == EP_HALTED) {
break;
}
if (xfer->running_retry) {
DPRINTF("xhci: xfer nacked, stopping schedule\n");
epctx->retry = xfer;
break;
}
}
ep = xhci_epid_to_usbep(xhci, slotid, epid);
if (ep) {
usb_device_flush_ep_queue(ep->dev, ep);
}
}
| false | qemu | 94b037f2a451b3dc855f9f2c346e5049a361bd55 | static void xhci_kick_ep(XHCIState *xhci, unsigned int slotid,
unsigned int epid, unsigned int streamid)
{
XHCIStreamContext *stctx;
XHCIEPContext *epctx;
XHCIRing *ring;
USBEndpoint *ep = NULL;
uint64_t mfindex;
int length;
int i;
trace_usb_xhci_ep_kick(slotid, epid, streamid);
assert(slotid >= 1 && slotid <= xhci->numslots);
assert(epid >= 1 && epid <= 31);
if (!xhci->slots[slotid-1].enabled) {
DPRINTF("xhci: xhci_kick_ep for disabled slot %d\n", slotid);
return;
}
epctx = xhci->slots[slotid-1].eps[epid-1];
if (!epctx) {
DPRINTF("xhci: xhci_kick_ep for disabled endpoint %d,%d\n",
epid, slotid);
return;
}
if (!xhci->slots[slotid - 1].uport ||
!xhci->slots[slotid - 1].uport->dev ||
!xhci->slots[slotid - 1].uport->dev->attached) {
return;
}
if (epctx->retry) {
XHCITransfer *xfer = epctx->retry;
trace_usb_xhci_xfer_retry(xfer);
assert(xfer->running_retry);
if (xfer->timed_xfer) {
mfindex = xhci_mfindex_get(xhci);
xhci_check_intr_iso_kick(xhci, xfer, epctx, mfindex);
if (xfer->running_retry) {
return;
}
xfer->timed_xfer = 0;
xfer->running_retry = 1;
}
if (xfer->iso_xfer) {
if (xhci_setup_packet(xfer) < 0) {
return;
}
usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
assert(xfer->packet.status != USB_RET_NAK);
xhci_complete_packet(xfer);
} else {
if (xhci_setup_packet(xfer) < 0) {
return;
}
usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
if (xfer->packet.status == USB_RET_NAK) {
return;
}
xhci_complete_packet(xfer);
}
assert(!xfer->running_retry);
epctx->retry = NULL;
}
if (epctx->state == EP_HALTED) {
DPRINTF("xhci: ep halted, not running schedule\n");
return;
}
if (epctx->nr_pstreams) {
uint32_t err;
stctx = xhci_find_stream(epctx, streamid, &err);
if (stctx == NULL) {
return;
}
ring = &stctx->ring;
xhci_set_ep_state(xhci, epctx, stctx, EP_RUNNING);
} else {
ring = &epctx->ring;
streamid = 0;
xhci_set_ep_state(xhci, epctx, NULL, EP_RUNNING);
}
assert(ring->dequeue != 0);
while (1) {
XHCITransfer *xfer = &epctx->transfers[epctx->next_xfer];
if (xfer->running_async || xfer->running_retry) {
break;
}
length = xhci_ring_chain_length(xhci, ring);
if (length < 0) {
break;
} else if (length == 0) {
break;
}
if (xfer->trbs && xfer->trb_alloced < length) {
xfer->trb_count = 0;
xfer->trb_alloced = 0;
g_free(xfer->trbs);
xfer->trbs = NULL;
}
if (!xfer->trbs) {
xfer->trbs = g_new(XHCITRB, length);
xfer->trb_alloced = length;
}
xfer->trb_count = length;
for (i = 0; i < length; i++) {
TRBType type;
type = xhci_ring_fetch(xhci, ring, &xfer->trbs[i], NULL);
assert(type);
}
xfer->streamid = streamid;
if (epid == 1) {
if (xhci_fire_ctl_transfer(xhci, xfer) >= 0) {
epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;
} else {
DPRINTF("xhci: error firing CTL transfer\n");
}
} else {
if (xhci_fire_transfer(xhci, xfer, epctx) >= 0) {
epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;
} else {
if (!xfer->timed_xfer) {
DPRINTF("xhci: error firing data transfer\n");
}
}
}
if (epctx->state == EP_HALTED) {
break;
}
if (xfer->running_retry) {
DPRINTF("xhci: xfer nacked, stopping schedule\n");
epctx->retry = xfer;
break;
}
}
ep = xhci_epid_to_usbep(xhci, slotid, epid);
if (ep) {
usb_device_flush_ep_queue(ep->dev, ep);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(XHCIState *VAR_0, unsigned int VAR_1,
unsigned int VAR_2, unsigned int VAR_3)
{
XHCIStreamContext *stctx;
XHCIEPContext *epctx;
XHCIRing *ring;
USBEndpoint *ep = NULL;
uint64_t mfindex;
int VAR_4;
int VAR_5;
trace_usb_xhci_ep_kick(VAR_1, VAR_2, VAR_3);
assert(VAR_1 >= 1 && VAR_1 <= VAR_0->numslots);
assert(VAR_2 >= 1 && VAR_2 <= 31);
if (!VAR_0->slots[VAR_1-1].enabled) {
DPRINTF("VAR_0: FUNC_0 for disabled slot %d\n", VAR_1);
return;
}
epctx = VAR_0->slots[VAR_1-1].eps[VAR_2-1];
if (!epctx) {
DPRINTF("VAR_0: FUNC_0 for disabled endpoint %d,%d\n",
VAR_2, VAR_1);
return;
}
if (!VAR_0->slots[VAR_1 - 1].uport ||
!VAR_0->slots[VAR_1 - 1].uport->dev ||
!VAR_0->slots[VAR_1 - 1].uport->dev->attached) {
return;
}
if (epctx->retry) {
XHCITransfer *xfer = epctx->retry;
trace_usb_xhci_xfer_retry(xfer);
assert(xfer->running_retry);
if (xfer->timed_xfer) {
mfindex = xhci_mfindex_get(VAR_0);
xhci_check_intr_iso_kick(VAR_0, xfer, epctx, mfindex);
if (xfer->running_retry) {
return;
}
xfer->timed_xfer = 0;
xfer->running_retry = 1;
}
if (xfer->iso_xfer) {
if (xhci_setup_packet(xfer) < 0) {
return;
}
usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
assert(xfer->packet.status != USB_RET_NAK);
xhci_complete_packet(xfer);
} else {
if (xhci_setup_packet(xfer) < 0) {
return;
}
usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);
if (xfer->packet.status == USB_RET_NAK) {
return;
}
xhci_complete_packet(xfer);
}
assert(!xfer->running_retry);
epctx->retry = NULL;
}
if (epctx->state == EP_HALTED) {
DPRINTF("VAR_0: ep halted, not running schedule\n");
return;
}
if (epctx->nr_pstreams) {
uint32_t err;
stctx = xhci_find_stream(epctx, VAR_3, &err);
if (stctx == NULL) {
return;
}
ring = &stctx->ring;
xhci_set_ep_state(VAR_0, epctx, stctx, EP_RUNNING);
} else {
ring = &epctx->ring;
VAR_3 = 0;
xhci_set_ep_state(VAR_0, epctx, NULL, EP_RUNNING);
}
assert(ring->dequeue != 0);
while (1) {
XHCITransfer *xfer = &epctx->transfers[epctx->next_xfer];
if (xfer->running_async || xfer->running_retry) {
break;
}
VAR_4 = xhci_ring_chain_length(VAR_0, ring);
if (VAR_4 < 0) {
break;
} else if (VAR_4 == 0) {
break;
}
if (xfer->trbs && xfer->trb_alloced < VAR_4) {
xfer->trb_count = 0;
xfer->trb_alloced = 0;
g_free(xfer->trbs);
xfer->trbs = NULL;
}
if (!xfer->trbs) {
xfer->trbs = g_new(XHCITRB, VAR_4);
xfer->trb_alloced = VAR_4;
}
xfer->trb_count = VAR_4;
for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {
TRBType type;
type = xhci_ring_fetch(VAR_0, ring, &xfer->trbs[VAR_5], NULL);
assert(type);
}
xfer->VAR_3 = VAR_3;
if (VAR_2 == 1) {
if (xhci_fire_ctl_transfer(VAR_0, xfer) >= 0) {
epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;
} else {
DPRINTF("VAR_0: error firing CTL transfer\n");
}
} else {
if (xhci_fire_transfer(VAR_0, xfer, epctx) >= 0) {
epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;
} else {
if (!xfer->timed_xfer) {
DPRINTF("VAR_0: error firing data transfer\n");
}
}
}
if (epctx->state == EP_HALTED) {
break;
}
if (xfer->running_retry) {
DPRINTF("VAR_0: xfer nacked, stopping schedule\n");
epctx->retry = xfer;
break;
}
}
ep = xhci_epid_to_usbep(VAR_0, VAR_1, VAR_2);
if (ep) {
usb_device_flush_ep_queue(ep->dev, ep);
}
}
| [
"static void FUNC_0(XHCIState *VAR_0, unsigned int VAR_1,\nunsigned int VAR_2, unsigned int VAR_3)\n{",
"XHCIStreamContext *stctx;",
"XHCIEPContext *epctx;",
"XHCIRing *ring;",
"USBEndpoint *ep = NULL;",
"uint64_t mfindex;",
"int VAR_4;",
"int VAR_5;",
"trace_usb_xhci_ep_kick(VAR_1, VAR_2, VAR_3);",
"assert(VAR_1 >= 1 && VAR_1 <= VAR_0->numslots);",
"assert(VAR_2 >= 1 && VAR_2 <= 31);",
"if (!VAR_0->slots[VAR_1-1].enabled) {",
"DPRINTF(\"VAR_0: FUNC_0 for disabled slot %d\\n\", VAR_1);",
"return;",
"}",
"epctx = VAR_0->slots[VAR_1-1].eps[VAR_2-1];",
"if (!epctx) {",
"DPRINTF(\"VAR_0: FUNC_0 for disabled endpoint %d,%d\\n\",\nVAR_2, VAR_1);",
"return;",
"}",
"if (!VAR_0->slots[VAR_1 - 1].uport ||\n!VAR_0->slots[VAR_1 - 1].uport->dev ||\n!VAR_0->slots[VAR_1 - 1].uport->dev->attached) {",
"return;",
"}",
"if (epctx->retry) {",
"XHCITransfer *xfer = epctx->retry;",
"trace_usb_xhci_xfer_retry(xfer);",
"assert(xfer->running_retry);",
"if (xfer->timed_xfer) {",
"mfindex = xhci_mfindex_get(VAR_0);",
"xhci_check_intr_iso_kick(VAR_0, xfer, epctx, mfindex);",
"if (xfer->running_retry) {",
"return;",
"}",
"xfer->timed_xfer = 0;",
"xfer->running_retry = 1;",
"}",
"if (xfer->iso_xfer) {",
"if (xhci_setup_packet(xfer) < 0) {",
"return;",
"}",
"usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);",
"assert(xfer->packet.status != USB_RET_NAK);",
"xhci_complete_packet(xfer);",
"} else {",
"if (xhci_setup_packet(xfer) < 0) {",
"return;",
"}",
"usb_handle_packet(xfer->packet.ep->dev, &xfer->packet);",
"if (xfer->packet.status == USB_RET_NAK) {",
"return;",
"}",
"xhci_complete_packet(xfer);",
"}",
"assert(!xfer->running_retry);",
"epctx->retry = NULL;",
"}",
"if (epctx->state == EP_HALTED) {",
"DPRINTF(\"VAR_0: ep halted, not running schedule\\n\");",
"return;",
"}",
"if (epctx->nr_pstreams) {",
"uint32_t err;",
"stctx = xhci_find_stream(epctx, VAR_3, &err);",
"if (stctx == NULL) {",
"return;",
"}",
"ring = &stctx->ring;",
"xhci_set_ep_state(VAR_0, epctx, stctx, EP_RUNNING);",
"} else {",
"ring = &epctx->ring;",
"VAR_3 = 0;",
"xhci_set_ep_state(VAR_0, epctx, NULL, EP_RUNNING);",
"}",
"assert(ring->dequeue != 0);",
"while (1) {",
"XHCITransfer *xfer = &epctx->transfers[epctx->next_xfer];",
"if (xfer->running_async || xfer->running_retry) {",
"break;",
"}",
"VAR_4 = xhci_ring_chain_length(VAR_0, ring);",
"if (VAR_4 < 0) {",
"break;",
"} else if (VAR_4 == 0) {",
"break;",
"}",
"if (xfer->trbs && xfer->trb_alloced < VAR_4) {",
"xfer->trb_count = 0;",
"xfer->trb_alloced = 0;",
"g_free(xfer->trbs);",
"xfer->trbs = NULL;",
"}",
"if (!xfer->trbs) {",
"xfer->trbs = g_new(XHCITRB, VAR_4);",
"xfer->trb_alloced = VAR_4;",
"}",
"xfer->trb_count = VAR_4;",
"for (VAR_5 = 0; VAR_5 < VAR_4; VAR_5++) {",
"TRBType type;",
"type = xhci_ring_fetch(VAR_0, ring, &xfer->trbs[VAR_5], NULL);",
"assert(type);",
"}",
"xfer->VAR_3 = VAR_3;",
"if (VAR_2 == 1) {",
"if (xhci_fire_ctl_transfer(VAR_0, xfer) >= 0) {",
"epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;",
"} else {",
"DPRINTF(\"VAR_0: error firing CTL transfer\\n\");",
"}",
"} else {",
"if (xhci_fire_transfer(VAR_0, xfer, epctx) >= 0) {",
"epctx->next_xfer = (epctx->next_xfer + 1) % TD_QUEUE;",
"} else {",
"if (!xfer->timed_xfer) {",
"DPRINTF(\"VAR_0: error firing data transfer\\n\");",
"}",
"}",
"}",
"if (epctx->state == EP_HALTED) {",
"break;",
"}",
"if (xfer->running_retry) {",
"DPRINTF(\"VAR_0: xfer nacked, stopping schedule\\n\");",
"epctx->retry = xfer;",
"break;",
"}",
"}",
"ep = xhci_epid_to_usbep(VAR_0, VAR_1, VAR_2);",
"if (ep) {",
"usb_device_flush_ep_queue(ep->dev, ep);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
57,
59,
61
],
[
63
],
[
65
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
299
],
[
301
],
[
303
],
[
305
],
[
307
]
]
|
12,758 | static int pl181_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
PL181State *s = PL181(dev);
DriveInfo *dinfo;
memory_region_init_io(&s->iomem, OBJECT(s), &pl181_ops, s, "pl181", 0x1000);
sysbus_init_mmio(sbd, &s->iomem);
sysbus_init_irq(sbd, &s->irq[0]);
sysbus_init_irq(sbd, &s->irq[1]);
qdev_init_gpio_out(dev, s->cardstatus, 2);
dinfo = drive_get_next(IF_SD);
s->card = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, false);
if (s->card == NULL) {
return -1;
}
return 0;
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | static int pl181_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
PL181State *s = PL181(dev);
DriveInfo *dinfo;
memory_region_init_io(&s->iomem, OBJECT(s), &pl181_ops, s, "pl181", 0x1000);
sysbus_init_mmio(sbd, &s->iomem);
sysbus_init_irq(sbd, &s->irq[0]);
sysbus_init_irq(sbd, &s->irq[1]);
qdev_init_gpio_out(dev, s->cardstatus, 2);
dinfo = drive_get_next(IF_SD);
s->card = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, false);
if (s->card == NULL) {
return -1;
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(SysBusDevice *VAR_0)
{
DeviceState *dev = DEVICE(VAR_0);
PL181State *s = PL181(dev);
DriveInfo *dinfo;
memory_region_init_io(&s->iomem, OBJECT(s), &pl181_ops, s, "pl181", 0x1000);
sysbus_init_mmio(VAR_0, &s->iomem);
sysbus_init_irq(VAR_0, &s->irq[0]);
sysbus_init_irq(VAR_0, &s->irq[1]);
qdev_init_gpio_out(dev, s->cardstatus, 2);
dinfo = drive_get_next(IF_SD);
s->card = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, false);
if (s->card == NULL) {
return -1;
}
return 0;
}
| [
"static int FUNC_0(SysBusDevice *VAR_0)\n{",
"DeviceState *dev = DEVICE(VAR_0);",
"PL181State *s = PL181(dev);",
"DriveInfo *dinfo;",
"memory_region_init_io(&s->iomem, OBJECT(s), &pl181_ops, s, \"pl181\", 0x1000);",
"sysbus_init_mmio(VAR_0, &s->iomem);",
"sysbus_init_irq(VAR_0, &s->irq[0]);",
"sysbus_init_irq(VAR_0, &s->irq[1]);",
"qdev_init_gpio_out(dev, s->cardstatus, 2);",
"dinfo = drive_get_next(IF_SD);",
"s->card = sd_init(dinfo ? blk_bs(blk_by_legacy_dinfo(dinfo)) : NULL, false);",
"if (s->card == NULL) {",
"return -1;",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
]
]
|
12,759 | static void curl_readv_bh_cb(void *p)
{
CURLState *state;
CURLAIOCB *acb = p;
BDRVCURLState *s = acb->common.bs->opaque;
qemu_bh_delete(acb->bh);
acb->bh = NULL;
size_t start = acb->sector_num * SECTOR_SIZE;
size_t end;
// In case we have the requested data already (e.g. read-ahead),
// we can just call the callback and be done.
switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
case FIND_RET_OK:
qemu_aio_release(acb);
// fall through
case FIND_RET_WAIT:
return;
default:
break;
}
// No cache found, so let's start a new request
state = curl_init_state(s);
if (!state) {
acb->common.cb(acb->common.opaque, -EIO);
qemu_aio_release(acb);
return;
}
acb->start = 0;
acb->end = (acb->nb_sectors * SECTOR_SIZE);
state->buf_off = 0;
if (state->orig_buf)
g_free(state->orig_buf);
state->buf_start = start;
state->buf_len = acb->end + s->readahead_size;
end = MIN(start + state->buf_len, s->len) - 1;
state->orig_buf = g_malloc(state->buf_len);
state->acb[0] = acb;
snprintf(state->range, 127, "%zd-%zd", start, end);
DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
(acb->nb_sectors * SECTOR_SIZE), start, state->range);
curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
curl_multi_add_handle(s->multi, state->curl);
curl_multi_do(s);
}
| false | qemu | b69cdef876340624bb40a2054d14f298471a40a6 | static void curl_readv_bh_cb(void *p)
{
CURLState *state;
CURLAIOCB *acb = p;
BDRVCURLState *s = acb->common.bs->opaque;
qemu_bh_delete(acb->bh);
acb->bh = NULL;
size_t start = acb->sector_num * SECTOR_SIZE;
size_t end;
switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
case FIND_RET_OK:
qemu_aio_release(acb);
case FIND_RET_WAIT:
return;
default:
break;
}
state = curl_init_state(s);
if (!state) {
acb->common.cb(acb->common.opaque, -EIO);
qemu_aio_release(acb);
return;
}
acb->start = 0;
acb->end = (acb->nb_sectors * SECTOR_SIZE);
state->buf_off = 0;
if (state->orig_buf)
g_free(state->orig_buf);
state->buf_start = start;
state->buf_len = acb->end + s->readahead_size;
end = MIN(start + state->buf_len, s->len) - 1;
state->orig_buf = g_malloc(state->buf_len);
state->acb[0] = acb;
snprintf(state->range, 127, "%zd-%zd", start, end);
DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
(acb->nb_sectors * SECTOR_SIZE), start, state->range);
curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
curl_multi_add_handle(s->multi, state->curl);
curl_multi_do(s);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
CURLState *state;
CURLAIOCB *acb = VAR_0;
BDRVCURLState *s = acb->common.bs->opaque;
qemu_bh_delete(acb->bh);
acb->bh = NULL;
size_t start = acb->sector_num * SECTOR_SIZE;
size_t end;
switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {
case FIND_RET_OK:
qemu_aio_release(acb);
case FIND_RET_WAIT:
return;
default:
break;
}
state = curl_init_state(s);
if (!state) {
acb->common.cb(acb->common.opaque, -EIO);
qemu_aio_release(acb);
return;
}
acb->start = 0;
acb->end = (acb->nb_sectors * SECTOR_SIZE);
state->buf_off = 0;
if (state->orig_buf)
g_free(state->orig_buf);
state->buf_start = start;
state->buf_len = acb->end + s->readahead_size;
end = MIN(start + state->buf_len, s->len) - 1;
state->orig_buf = g_malloc(state->buf_len);
state->acb[0] = acb;
snprintf(state->range, 127, "%zd-%zd", start, end);
DPRINTF("CURL (AIO): Reading %d at %zd (%s)\n",
(acb->nb_sectors * SECTOR_SIZE), start, state->range);
curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);
curl_multi_add_handle(s->multi, state->curl);
curl_multi_do(s);
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"CURLState *state;",
"CURLAIOCB *acb = VAR_0;",
"BDRVCURLState *s = acb->common.bs->opaque;",
"qemu_bh_delete(acb->bh);",
"acb->bh = NULL;",
"size_t start = acb->sector_num * SECTOR_SIZE;",
"size_t end;",
"switch (curl_find_buf(s, start, acb->nb_sectors * SECTOR_SIZE, acb)) {",
"case FIND_RET_OK:\nqemu_aio_release(acb);",
"case FIND_RET_WAIT:\nreturn;",
"default:\nbreak;",
"}",
"state = curl_init_state(s);",
"if (!state) {",
"acb->common.cb(acb->common.opaque, -EIO);",
"qemu_aio_release(acb);",
"return;",
"}",
"acb->start = 0;",
"acb->end = (acb->nb_sectors * SECTOR_SIZE);",
"state->buf_off = 0;",
"if (state->orig_buf)\ng_free(state->orig_buf);",
"state->buf_start = start;",
"state->buf_len = acb->end + s->readahead_size;",
"end = MIN(start + state->buf_len, s->len) - 1;",
"state->orig_buf = g_malloc(state->buf_len);",
"state->acb[0] = acb;",
"snprintf(state->range, 127, \"%zd-%zd\", start, end);",
"DPRINTF(\"CURL (AIO): Reading %d at %zd (%s)\\n\",\n(acb->nb_sectors * SECTOR_SIZE), start, state->range);",
"curl_easy_setopt(state->curl, CURLOPT_RANGE, state->range);",
"curl_multi_add_handle(s->multi, state->curl);",
"curl_multi_do(s);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
31
],
[
33,
35
],
[
39,
41
],
[
43,
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
73
],
[
75,
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93,
95
],
[
97
],
[
101
],
[
103
],
[
107
]
]
|
12,760 | static void kvm_arm_gic_put(GICState *s)
{
uint32_t reg;
int i;
int cpu;
int num_cpu;
int num_irq;
if (!kvm_arm_gic_can_save_restore(s)) {
DPRINTF("Cannot put kernel gic state, no kernel interface");
return;
}
/* Note: We do the restore in a slightly different order than the save
* (where the order doesn't matter and is simply ordered according to the
* register offset values */
/*****************************************************************
* Distributor State
*/
/* s->enabled -> GICD_CTLR */
reg = s->enabled;
kvm_gicd_access(s, 0x0, 0, ®, true);
/* Sanity checking on GICD_TYPER and s->num_irq, s->num_cpu */
kvm_gicd_access(s, 0x4, 0, ®, false);
num_irq = ((reg & 0x1f) + 1) * 32;
num_cpu = ((reg & 0xe0) >> 5) + 1;
if (num_irq < s->num_irq) {
fprintf(stderr, "Restoring %u IRQs, but kernel supports max %d\n",
s->num_irq, num_irq);
abort();
} else if (num_cpu != s->num_cpu) {
fprintf(stderr, "Restoring %u CPU interfaces, kernel only has %d\n",
s->num_cpu, num_cpu);
/* Did we not create the VCPUs in the kernel yet? */
abort();
}
/* TODO: Consider checking compatibility with the IIDR ? */
/* irq_state[n].enabled -> GICD_ISENABLERn */
kvm_dist_put(s, 0x180, 1, s->num_irq, translate_clear);
kvm_dist_put(s, 0x100, 1, s->num_irq, translate_enabled);
/* irq_state[n].group -> GICD_IGROUPRn */
kvm_dist_put(s, 0x80, 1, s->num_irq, translate_group);
/* s->irq_target[irq] -> GICD_ITARGETSRn
* (restore targets before pending to ensure the pending state is set on
* the appropriate CPU interfaces in the kernel) */
kvm_dist_put(s, 0x800, 8, s->num_irq, translate_targets);
/* irq_state[n].trigger -> GICD_ICFGRn
* (restore configuration registers before pending IRQs so we treat
* level/edge correctly) */
kvm_dist_put(s, 0xc00, 2, s->num_irq, translate_trigger);
/* irq_state[n].pending + irq_state[n].level -> GICD_ISPENDRn */
kvm_dist_put(s, 0x280, 1, s->num_irq, translate_clear);
kvm_dist_put(s, 0x200, 1, s->num_irq, translate_pending);
/* irq_state[n].active -> GICD_ISACTIVERn */
kvm_dist_put(s, 0x380, 1, s->num_irq, translate_clear);
kvm_dist_put(s, 0x300, 1, s->num_irq, translate_active);
/* s->priorityX[irq] -> ICD_IPRIORITYRn */
kvm_dist_put(s, 0x400, 8, s->num_irq, translate_priority);
/* s->sgi_pending -> ICD_CPENDSGIRn */
kvm_dist_put(s, 0xf10, 8, GIC_NR_SGIS, translate_clear);
kvm_dist_put(s, 0xf20, 8, GIC_NR_SGIS, translate_sgisource);
/*****************************************************************
* CPU Interface(s) State
*/
for (cpu = 0; cpu < s->num_cpu; cpu++) {
/* s->cpu_enabled[cpu] -> GICC_CTLR */
reg = s->cpu_enabled[cpu];
kvm_gicc_access(s, 0x00, cpu, ®, true);
/* s->priority_mask[cpu] -> GICC_PMR */
reg = (s->priority_mask[cpu] & 0xff);
kvm_gicc_access(s, 0x04, cpu, ®, true);
/* s->bpr[cpu] -> GICC_BPR */
reg = (s->bpr[cpu] & 0x7);
kvm_gicc_access(s, 0x08, cpu, ®, true);
/* s->abpr[cpu] -> GICC_ABPR */
reg = (s->abpr[cpu] & 0x7);
kvm_gicc_access(s, 0x1c, cpu, ®, true);
/* s->apr[n][cpu] -> GICC_APRn */
for (i = 0; i < 4; i++) {
reg = s->apr[i][cpu];
kvm_gicc_access(s, 0xd0 + i * 4, cpu, ®, true);
}
}
}
| false | qemu | 679aa175e84f5f80b32b307fce5a6b92729e0e61 | static void kvm_arm_gic_put(GICState *s)
{
uint32_t reg;
int i;
int cpu;
int num_cpu;
int num_irq;
if (!kvm_arm_gic_can_save_restore(s)) {
DPRINTF("Cannot put kernel gic state, no kernel interface");
return;
}
reg = s->enabled;
kvm_gicd_access(s, 0x0, 0, ®, true);
kvm_gicd_access(s, 0x4, 0, ®, false);
num_irq = ((reg & 0x1f) + 1) * 32;
num_cpu = ((reg & 0xe0) >> 5) + 1;
if (num_irq < s->num_irq) {
fprintf(stderr, "Restoring %u IRQs, but kernel supports max %d\n",
s->num_irq, num_irq);
abort();
} else if (num_cpu != s->num_cpu) {
fprintf(stderr, "Restoring %u CPU interfaces, kernel only has %d\n",
s->num_cpu, num_cpu);
abort();
}
kvm_dist_put(s, 0x180, 1, s->num_irq, translate_clear);
kvm_dist_put(s, 0x100, 1, s->num_irq, translate_enabled);
kvm_dist_put(s, 0x80, 1, s->num_irq, translate_group);
kvm_dist_put(s, 0x800, 8, s->num_irq, translate_targets);
kvm_dist_put(s, 0xc00, 2, s->num_irq, translate_trigger);
kvm_dist_put(s, 0x280, 1, s->num_irq, translate_clear);
kvm_dist_put(s, 0x200, 1, s->num_irq, translate_pending);
kvm_dist_put(s, 0x380, 1, s->num_irq, translate_clear);
kvm_dist_put(s, 0x300, 1, s->num_irq, translate_active);
kvm_dist_put(s, 0x400, 8, s->num_irq, translate_priority);
kvm_dist_put(s, 0xf10, 8, GIC_NR_SGIS, translate_clear);
kvm_dist_put(s, 0xf20, 8, GIC_NR_SGIS, translate_sgisource);
for (cpu = 0; cpu < s->num_cpu; cpu++) {
reg = s->cpu_enabled[cpu];
kvm_gicc_access(s, 0x00, cpu, ®, true);
reg = (s->priority_mask[cpu] & 0xff);
kvm_gicc_access(s, 0x04, cpu, ®, true);
reg = (s->bpr[cpu] & 0x7);
kvm_gicc_access(s, 0x08, cpu, ®, true);
reg = (s->abpr[cpu] & 0x7);
kvm_gicc_access(s, 0x1c, cpu, ®, true);
for (i = 0; i < 4; i++) {
reg = s->apr[i][cpu];
kvm_gicc_access(s, 0xd0 + i * 4, cpu, ®, true);
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(GICState *VAR_0)
{
uint32_t reg;
int VAR_1;
int VAR_2;
int VAR_3;
int VAR_4;
if (!kvm_arm_gic_can_save_restore(VAR_0)) {
DPRINTF("Cannot put kernel gic state, no kernel interface");
return;
}
reg = VAR_0->enabled;
kvm_gicd_access(VAR_0, 0x0, 0, ®, true);
kvm_gicd_access(VAR_0, 0x4, 0, ®, false);
VAR_4 = ((reg & 0x1f) + 1) * 32;
VAR_3 = ((reg & 0xe0) >> 5) + 1;
if (VAR_4 < VAR_0->VAR_4) {
fprintf(stderr, "Restoring %u IRQs, but kernel supports max %d\n",
VAR_0->VAR_4, VAR_4);
abort();
} else if (VAR_3 != VAR_0->VAR_3) {
fprintf(stderr, "Restoring %u CPU interfaces, kernel only has %d\n",
VAR_0->VAR_3, VAR_3);
abort();
}
kvm_dist_put(VAR_0, 0x180, 1, VAR_0->VAR_4, translate_clear);
kvm_dist_put(VAR_0, 0x100, 1, VAR_0->VAR_4, translate_enabled);
kvm_dist_put(VAR_0, 0x80, 1, VAR_0->VAR_4, translate_group);
kvm_dist_put(VAR_0, 0x800, 8, VAR_0->VAR_4, translate_targets);
kvm_dist_put(VAR_0, 0xc00, 2, VAR_0->VAR_4, translate_trigger);
kvm_dist_put(VAR_0, 0x280, 1, VAR_0->VAR_4, translate_clear);
kvm_dist_put(VAR_0, 0x200, 1, VAR_0->VAR_4, translate_pending);
kvm_dist_put(VAR_0, 0x380, 1, VAR_0->VAR_4, translate_clear);
kvm_dist_put(VAR_0, 0x300, 1, VAR_0->VAR_4, translate_active);
kvm_dist_put(VAR_0, 0x400, 8, VAR_0->VAR_4, translate_priority);
kvm_dist_put(VAR_0, 0xf10, 8, GIC_NR_SGIS, translate_clear);
kvm_dist_put(VAR_0, 0xf20, 8, GIC_NR_SGIS, translate_sgisource);
for (VAR_2 = 0; VAR_2 < VAR_0->VAR_3; VAR_2++) {
reg = VAR_0->cpu_enabled[VAR_2];
kvm_gicc_access(VAR_0, 0x00, VAR_2, ®, true);
reg = (VAR_0->priority_mask[VAR_2] & 0xff);
kvm_gicc_access(VAR_0, 0x04, VAR_2, ®, true);
reg = (VAR_0->bpr[VAR_2] & 0x7);
kvm_gicc_access(VAR_0, 0x08, VAR_2, ®, true);
reg = (VAR_0->abpr[VAR_2] & 0x7);
kvm_gicc_access(VAR_0, 0x1c, VAR_2, ®, true);
for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {
reg = VAR_0->apr[VAR_1][VAR_2];
kvm_gicc_access(VAR_0, 0xd0 + VAR_1 * 4, VAR_2, ®, true);
}
}
}
| [
"static void FUNC_0(GICState *VAR_0)\n{",
"uint32_t reg;",
"int VAR_1;",
"int VAR_2;",
"int VAR_3;",
"int VAR_4;",
"if (!kvm_arm_gic_can_save_restore(VAR_0)) {",
"DPRINTF(\"Cannot put kernel gic state, no kernel interface\");",
"return;",
"}",
"reg = VAR_0->enabled;",
"kvm_gicd_access(VAR_0, 0x0, 0, ®, true);",
"kvm_gicd_access(VAR_0, 0x4, 0, ®, false);",
"VAR_4 = ((reg & 0x1f) + 1) * 32;",
"VAR_3 = ((reg & 0xe0) >> 5) + 1;",
"if (VAR_4 < VAR_0->VAR_4) {",
"fprintf(stderr, \"Restoring %u IRQs, but kernel supports max %d\\n\",\nVAR_0->VAR_4, VAR_4);",
"abort();",
"} else if (VAR_3 != VAR_0->VAR_3) {",
"fprintf(stderr, \"Restoring %u CPU interfaces, kernel only has %d\\n\",\nVAR_0->VAR_3, VAR_3);",
"abort();",
"}",
"kvm_dist_put(VAR_0, 0x180, 1, VAR_0->VAR_4, translate_clear);",
"kvm_dist_put(VAR_0, 0x100, 1, VAR_0->VAR_4, translate_enabled);",
"kvm_dist_put(VAR_0, 0x80, 1, VAR_0->VAR_4, translate_group);",
"kvm_dist_put(VAR_0, 0x800, 8, VAR_0->VAR_4, translate_targets);",
"kvm_dist_put(VAR_0, 0xc00, 2, VAR_0->VAR_4, translate_trigger);",
"kvm_dist_put(VAR_0, 0x280, 1, VAR_0->VAR_4, translate_clear);",
"kvm_dist_put(VAR_0, 0x200, 1, VAR_0->VAR_4, translate_pending);",
"kvm_dist_put(VAR_0, 0x380, 1, VAR_0->VAR_4, translate_clear);",
"kvm_dist_put(VAR_0, 0x300, 1, VAR_0->VAR_4, translate_active);",
"kvm_dist_put(VAR_0, 0x400, 8, VAR_0->VAR_4, translate_priority);",
"kvm_dist_put(VAR_0, 0xf10, 8, GIC_NR_SGIS, translate_clear);",
"kvm_dist_put(VAR_0, 0xf20, 8, GIC_NR_SGIS, translate_sgisource);",
"for (VAR_2 = 0; VAR_2 < VAR_0->VAR_3; VAR_2++) {",
"reg = VAR_0->cpu_enabled[VAR_2];",
"kvm_gicc_access(VAR_0, 0x00, VAR_2, ®, true);",
"reg = (VAR_0->priority_mask[VAR_2] & 0xff);",
"kvm_gicc_access(VAR_0, 0x04, VAR_2, ®, true);",
"reg = (VAR_0->bpr[VAR_2] & 0x7);",
"kvm_gicc_access(VAR_0, 0x08, VAR_2, ®, true);",
"reg = (VAR_0->abpr[VAR_2] & 0x7);",
"kvm_gicc_access(VAR_0, 0x1c, VAR_2, ®, true);",
"for (VAR_1 = 0; VAR_1 < 4; VAR_1++) {",
"reg = VAR_0->apr[VAR_1][VAR_2];",
"kvm_gicc_access(VAR_0, 0xd0 + VAR_1 * 4, VAR_2, ®, true);",
"}",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63,
65
],
[
67
],
[
69
],
[
71,
73
],
[
77
],
[
79
],
[
89
],
[
91
],
[
97
],
[
107
],
[
117
],
[
123
],
[
125
],
[
131
],
[
133
],
[
141
],
[
147
],
[
149
],
[
163
],
[
167
],
[
169
],
[
175
],
[
177
],
[
183
],
[
185
],
[
191
],
[
193
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
]
]
|
12,761 | void readline_handle_byte(ReadLineState *rs, int ch)
{
switch(rs->esc_state) {
case IS_NORM:
switch(ch) {
case 1:
readline_bol(rs);
break;
case 4:
readline_delete_char(rs);
break;
case 5:
readline_eol(rs);
break;
case 9:
readline_completion(rs);
break;
case 10:
case 13:
rs->cmd_buf[rs->cmd_buf_size] = '\0';
if (!rs->read_password)
readline_hist_add(rs, rs->cmd_buf);
monitor_printf(rs->mon, "\n");
rs->cmd_buf_index = 0;
rs->cmd_buf_size = 0;
rs->last_cmd_buf_index = 0;
rs->last_cmd_buf_size = 0;
rs->readline_func(rs->mon, rs->cmd_buf, rs->readline_opaque);
break;
case 23:
/* ^W */
readline_backword(rs);
break;
case 27:
rs->esc_state = IS_ESC;
break;
case 127:
case 8:
readline_backspace(rs);
break;
case 155:
rs->esc_state = IS_CSI;
break;
default:
if (ch >= 32) {
readline_insert_char(rs, ch);
}
break;
}
break;
case IS_ESC:
if (ch == '[') {
rs->esc_state = IS_CSI;
rs->esc_param = 0;
} else if (ch == 'O') {
rs->esc_state = IS_SS3;
rs->esc_param = 0;
} else {
rs->esc_state = IS_NORM;
}
break;
case IS_CSI:
switch(ch) {
case 'A':
case 'F':
readline_up_char(rs);
break;
case 'B':
case 'E':
readline_down_char(rs);
break;
case 'D':
readline_backward_char(rs);
break;
case 'C':
readline_forward_char(rs);
break;
case '0' ... '9':
rs->esc_param = rs->esc_param * 10 + (ch - '0');
goto the_end;
case '~':
switch(rs->esc_param) {
case 1:
readline_bol(rs);
break;
case 3:
readline_delete_char(rs);
break;
case 4:
readline_eol(rs);
break;
}
break;
default:
break;
}
rs->esc_state = IS_NORM;
the_end:
break;
case IS_SS3:
switch(ch) {
case 'F':
readline_eol(rs);
break;
case 'H':
readline_bol(rs);
break;
}
rs->esc_state = IS_NORM;
break;
}
readline_update(rs);
}
| false | qemu | c60bf3391bf4cb79b7adc6650094e21671ddaabd | void readline_handle_byte(ReadLineState *rs, int ch)
{
switch(rs->esc_state) {
case IS_NORM:
switch(ch) {
case 1:
readline_bol(rs);
break;
case 4:
readline_delete_char(rs);
break;
case 5:
readline_eol(rs);
break;
case 9:
readline_completion(rs);
break;
case 10:
case 13:
rs->cmd_buf[rs->cmd_buf_size] = '\0';
if (!rs->read_password)
readline_hist_add(rs, rs->cmd_buf);
monitor_printf(rs->mon, "\n");
rs->cmd_buf_index = 0;
rs->cmd_buf_size = 0;
rs->last_cmd_buf_index = 0;
rs->last_cmd_buf_size = 0;
rs->readline_func(rs->mon, rs->cmd_buf, rs->readline_opaque);
break;
case 23:
readline_backword(rs);
break;
case 27:
rs->esc_state = IS_ESC;
break;
case 127:
case 8:
readline_backspace(rs);
break;
case 155:
rs->esc_state = IS_CSI;
break;
default:
if (ch >= 32) {
readline_insert_char(rs, ch);
}
break;
}
break;
case IS_ESC:
if (ch == '[') {
rs->esc_state = IS_CSI;
rs->esc_param = 0;
} else if (ch == 'O') {
rs->esc_state = IS_SS3;
rs->esc_param = 0;
} else {
rs->esc_state = IS_NORM;
}
break;
case IS_CSI:
switch(ch) {
case 'A':
case 'F':
readline_up_char(rs);
break;
case 'B':
case 'E':
readline_down_char(rs);
break;
case 'D':
readline_backward_char(rs);
break;
case 'C':
readline_forward_char(rs);
break;
case '0' ... '9':
rs->esc_param = rs->esc_param * 10 + (ch - '0');
goto the_end;
case '~':
switch(rs->esc_param) {
case 1:
readline_bol(rs);
break;
case 3:
readline_delete_char(rs);
break;
case 4:
readline_eol(rs);
break;
}
break;
default:
break;
}
rs->esc_state = IS_NORM;
the_end:
break;
case IS_SS3:
switch(ch) {
case 'F':
readline_eol(rs);
break;
case 'H':
readline_bol(rs);
break;
}
rs->esc_state = IS_NORM;
break;
}
readline_update(rs);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(ReadLineState *VAR_0, int VAR_1)
{
switch(VAR_0->esc_state) {
case IS_NORM:
switch(VAR_1) {
case 1:
readline_bol(VAR_0);
break;
case 4:
readline_delete_char(VAR_0);
break;
case 5:
readline_eol(VAR_0);
break;
case 9:
readline_completion(VAR_0);
break;
case 10:
case 13:
VAR_0->cmd_buf[VAR_0->cmd_buf_size] = '\0';
if (!VAR_0->read_password)
readline_hist_add(VAR_0, VAR_0->cmd_buf);
monitor_printf(VAR_0->mon, "\n");
VAR_0->cmd_buf_index = 0;
VAR_0->cmd_buf_size = 0;
VAR_0->last_cmd_buf_index = 0;
VAR_0->last_cmd_buf_size = 0;
VAR_0->readline_func(VAR_0->mon, VAR_0->cmd_buf, VAR_0->readline_opaque);
break;
case 23:
readline_backword(VAR_0);
break;
case 27:
VAR_0->esc_state = IS_ESC;
break;
case 127:
case 8:
readline_backspace(VAR_0);
break;
case 155:
VAR_0->esc_state = IS_CSI;
break;
default:
if (VAR_1 >= 32) {
readline_insert_char(VAR_0, VAR_1);
}
break;
}
break;
case IS_ESC:
if (VAR_1 == '[') {
VAR_0->esc_state = IS_CSI;
VAR_0->esc_param = 0;
} else if (VAR_1 == 'O') {
VAR_0->esc_state = IS_SS3;
VAR_0->esc_param = 0;
} else {
VAR_0->esc_state = IS_NORM;
}
break;
case IS_CSI:
switch(VAR_1) {
case 'A':
case 'F':
readline_up_char(VAR_0);
break;
case 'B':
case 'E':
readline_down_char(VAR_0);
break;
case 'D':
readline_backward_char(VAR_0);
break;
case 'C':
readline_forward_char(VAR_0);
break;
case '0' ... '9':
VAR_0->esc_param = VAR_0->esc_param * 10 + (VAR_1 - '0');
goto the_end;
case '~':
switch(VAR_0->esc_param) {
case 1:
readline_bol(VAR_0);
break;
case 3:
readline_delete_char(VAR_0);
break;
case 4:
readline_eol(VAR_0);
break;
}
break;
default:
break;
}
VAR_0->esc_state = IS_NORM;
the_end:
break;
case IS_SS3:
switch(VAR_1) {
case 'F':
readline_eol(VAR_0);
break;
case 'H':
readline_bol(VAR_0);
break;
}
VAR_0->esc_state = IS_NORM;
break;
}
readline_update(VAR_0);
}
| [
"void FUNC_0(ReadLineState *VAR_0, int VAR_1)\n{",
"switch(VAR_0->esc_state) {",
"case IS_NORM:\nswitch(VAR_1) {",
"case 1:\nreadline_bol(VAR_0);",
"break;",
"case 4:\nreadline_delete_char(VAR_0);",
"break;",
"case 5:\nreadline_eol(VAR_0);",
"break;",
"case 9:\nreadline_completion(VAR_0);",
"break;",
"case 10:\ncase 13:\nVAR_0->cmd_buf[VAR_0->cmd_buf_size] = '\\0';",
"if (!VAR_0->read_password)\nreadline_hist_add(VAR_0, VAR_0->cmd_buf);",
"monitor_printf(VAR_0->mon, \"\\n\");",
"VAR_0->cmd_buf_index = 0;",
"VAR_0->cmd_buf_size = 0;",
"VAR_0->last_cmd_buf_index = 0;",
"VAR_0->last_cmd_buf_size = 0;",
"VAR_0->readline_func(VAR_0->mon, VAR_0->cmd_buf, VAR_0->readline_opaque);",
"break;",
"case 23:\nreadline_backword(VAR_0);",
"break;",
"case 27:\nVAR_0->esc_state = IS_ESC;",
"break;",
"case 127:\ncase 8:\nreadline_backspace(VAR_0);",
"break;",
"case 155:\nVAR_0->esc_state = IS_CSI;",
"break;",
"default:\nif (VAR_1 >= 32) {",
"readline_insert_char(VAR_0, VAR_1);",
"}",
"break;",
"}",
"break;",
"case IS_ESC:\nif (VAR_1 == '[') {",
"VAR_0->esc_state = IS_CSI;",
"VAR_0->esc_param = 0;",
"} else if (VAR_1 == 'O') {",
"VAR_0->esc_state = IS_SS3;",
"VAR_0->esc_param = 0;",
"} else {",
"VAR_0->esc_state = IS_NORM;",
"}",
"break;",
"case IS_CSI:\nswitch(VAR_1) {",
"case 'A':\ncase 'F':\nreadline_up_char(VAR_0);",
"break;",
"case 'B':\ncase 'E':\nreadline_down_char(VAR_0);",
"break;",
"case 'D':\nreadline_backward_char(VAR_0);",
"break;",
"case 'C':\nreadline_forward_char(VAR_0);",
"break;",
"case '0' ... '9':\nVAR_0->esc_param = VAR_0->esc_param * 10 + (VAR_1 - '0');",
"goto the_end;",
"case '~':\nswitch(VAR_0->esc_param) {",
"case 1:\nreadline_bol(VAR_0);",
"break;",
"case 3:\nreadline_delete_char(VAR_0);",
"break;",
"case 4:\nreadline_eol(VAR_0);",
"break;",
"}",
"break;",
"default:\nbreak;",
"}",
"VAR_0->esc_state = IS_NORM;",
"the_end:\nbreak;",
"case IS_SS3:\nswitch(VAR_1) {",
"case 'F':\nreadline_eol(VAR_0);",
"break;",
"case 'H':\nreadline_bol(VAR_0);",
"break;",
"}",
"VAR_0->esc_state = IS_NORM;",
"break;",
"}",
"readline_update(VAR_0);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7,
9
],
[
11,
13
],
[
15
],
[
17,
19
],
[
21
],
[
23,
25
],
[
27
],
[
29,
31
],
[
33
],
[
35,
37,
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59,
63
],
[
65
],
[
67,
69
],
[
71
],
[
73,
75,
77
],
[
79
],
[
81,
83
],
[
85
],
[
87,
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101,
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123,
125
],
[
127,
129,
131
],
[
133
],
[
135,
137,
139
],
[
141
],
[
143,
145
],
[
147
],
[
149,
151
],
[
153
],
[
155,
157
],
[
159
],
[
161,
163
],
[
165,
167
],
[
169
],
[
171,
173
],
[
175
],
[
177,
179
],
[
181
],
[
183
],
[
185
],
[
187,
189
],
[
191
],
[
193
],
[
195,
197
],
[
199,
201
],
[
203,
205
],
[
207
],
[
209,
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
]
]
|
12,763 | static void ats_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
{
hwaddr phys_addr;
target_ulong page_size;
int prot;
int ret, is_user = ri->opc2 & 2;
int access_type = ri->opc2 & 1;
ret = get_phys_addr(env, value, access_type, is_user,
&phys_addr, &prot, &page_size);
if (extended_addresses_enabled(env)) {
/* ret is a DFSR/IFSR value for the long descriptor
* translation table format, but with WnR always clear.
* Convert it to a 64-bit PAR.
*/
uint64_t par64 = (1 << 11); /* LPAE bit always set */
if (ret == 0) {
par64 |= phys_addr & ~0xfffULL;
/* We don't set the ATTR or SH fields in the PAR. */
} else {
par64 |= 1; /* F */
par64 |= (ret & 0x3f) << 1; /* FS */
/* Note that S2WLK and FSTAGE are always zero, because we don't
* implement virtualization and therefore there can't be a stage 2
* fault.
*/
}
env->cp15.par_el1 = par64;
} else {
/* ret is a DFSR/IFSR value for the short descriptor
* translation table format (with WnR always clear).
* Convert it to a 32-bit PAR.
*/
if (ret == 0) {
/* We do not set any attribute bits in the PAR */
if (page_size == (1 << 24)
&& arm_feature(env, ARM_FEATURE_V7)) {
env->cp15.par_el1 = (phys_addr & 0xff000000) | 1 << 1;
} else {
env->cp15.par_el1 = phys_addr & 0xfffff000;
}
} else {
env->cp15.par_el1 = ((ret & (1 << 10)) >> 5) |
((ret & (1 << 12)) >> 6) |
((ret & 0xf) << 1) | 1;
}
}
}
| false | qemu | 01c097f7960b330c4bf038d34bae17ad6c1ba499 | static void ats_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
{
hwaddr phys_addr;
target_ulong page_size;
int prot;
int ret, is_user = ri->opc2 & 2;
int access_type = ri->opc2 & 1;
ret = get_phys_addr(env, value, access_type, is_user,
&phys_addr, &prot, &page_size);
if (extended_addresses_enabled(env)) {
uint64_t par64 = (1 << 11);
if (ret == 0) {
par64 |= phys_addr & ~0xfffULL;
} else {
par64 |= 1;
par64 |= (ret & 0x3f) << 1;
}
env->cp15.par_el1 = par64;
} else {
if (ret == 0) {
if (page_size == (1 << 24)
&& arm_feature(env, ARM_FEATURE_V7)) {
env->cp15.par_el1 = (phys_addr & 0xff000000) | 1 << 1;
} else {
env->cp15.par_el1 = phys_addr & 0xfffff000;
}
} else {
env->cp15.par_el1 = ((ret & (1 << 10)) >> 5) |
((ret & (1 << 12)) >> 6) |
((ret & 0xf) << 1) | 1;
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(CPUARMState *VAR_0, const ARMCPRegInfo *VAR_1, uint64_t VAR_2)
{
hwaddr phys_addr;
target_ulong page_size;
int VAR_3;
int VAR_4, VAR_5 = VAR_1->opc2 & 2;
int VAR_6 = VAR_1->opc2 & 1;
VAR_4 = get_phys_addr(VAR_0, VAR_2, VAR_6, VAR_5,
&phys_addr, &VAR_3, &page_size);
if (extended_addresses_enabled(VAR_0)) {
uint64_t par64 = (1 << 11);
if (VAR_4 == 0) {
par64 |= phys_addr & ~0xfffULL;
} else {
par64 |= 1;
par64 |= (VAR_4 & 0x3f) << 1;
}
VAR_0->cp15.par_el1 = par64;
} else {
if (VAR_4 == 0) {
if (page_size == (1 << 24)
&& arm_feature(VAR_0, ARM_FEATURE_V7)) {
VAR_0->cp15.par_el1 = (phys_addr & 0xff000000) | 1 << 1;
} else {
VAR_0->cp15.par_el1 = phys_addr & 0xfffff000;
}
} else {
VAR_0->cp15.par_el1 = ((VAR_4 & (1 << 10)) >> 5) |
((VAR_4 & (1 << 12)) >> 6) |
((VAR_4 & 0xf) << 1) | 1;
}
}
}
| [
"static void FUNC_0(CPUARMState *VAR_0, const ARMCPRegInfo *VAR_1, uint64_t VAR_2)\n{",
"hwaddr phys_addr;",
"target_ulong page_size;",
"int VAR_3;",
"int VAR_4, VAR_5 = VAR_1->opc2 & 2;",
"int VAR_6 = VAR_1->opc2 & 1;",
"VAR_4 = get_phys_addr(VAR_0, VAR_2, VAR_6, VAR_5,\n&phys_addr, &VAR_3, &page_size);",
"if (extended_addresses_enabled(VAR_0)) {",
"uint64_t par64 = (1 << 11);",
"if (VAR_4 == 0) {",
"par64 |= phys_addr & ~0xfffULL;",
"} else {",
"par64 |= 1;",
"par64 |= (VAR_4 & 0x3f) << 1;",
"}",
"VAR_0->cp15.par_el1 = par64;",
"} else {",
"if (VAR_4 == 0) {",
"if (page_size == (1 << 24)\n&& arm_feature(VAR_0, ARM_FEATURE_V7)) {",
"VAR_0->cp15.par_el1 = (phys_addr & 0xff000000) | 1 << 1;",
"} else {",
"VAR_0->cp15.par_el1 = phys_addr & 0xfffff000;",
"}",
"} else {",
"VAR_0->cp15.par_el1 = ((VAR_4 & (1 << 10)) >> 5) |\n((VAR_4 & (1 << 12)) >> 6) |\n((VAR_4 & 0xf) << 1) | 1;",
"}",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17,
19
],
[
21
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
53
],
[
55
],
[
57
],
[
67
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85,
87,
89
],
[
91
],
[
93
],
[
95
]
]
|
12,764 | static void test_hybrid_analysis(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, in, [12], [2]);
LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);
declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],
const INTFLOAT (*filter)[8][2],
ptrdiff_t stride, int n);
randomize((INTFLOAT *)in, 12 * 2);
randomize((INTFLOAT *)filter, N * 8 * 2);
randomize((INTFLOAT *)dst0, BUF_SIZE * 2);
memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));
call_ref(dst0, in, filter, STRIDE, N);
call_new(dst1, in, filter, STRIDE, N);
if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
fail();
bench_new(dst1, in, filter, STRIDE, N);
}
| false | FFmpeg | fb7b477a91feea1a5d1faf62e516878e388c3057 | static void test_hybrid_analysis(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, in, [12], [2]);
LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);
declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],
const INTFLOAT (*filter)[8][2],
ptrdiff_t stride, int n);
randomize((INTFLOAT *)in, 12 * 2);
randomize((INTFLOAT *)filter, N * 8 * 2);
randomize((INTFLOAT *)dst0, BUF_SIZE * 2);
memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));
call_ref(dst0, in, filter, STRIDE, N);
call_new(dst1, in, filter, STRIDE, N);
if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
fail();
bench_new(dst1, in, filter, STRIDE, N);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);
LOCAL_ALIGNED_16(INTFLOAT, in, [12], [2]);
LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);
declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],
const INTFLOAT (*filter)[8][2],
ptrdiff_t stride, int n);
randomize((INTFLOAT *)in, 12 * 2);
randomize((INTFLOAT *)filter, N * 8 * 2);
randomize((INTFLOAT *)dst0, BUF_SIZE * 2);
memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));
call_ref(dst0, in, filter, STRIDE, N);
call_new(dst1, in, filter, STRIDE, N);
if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))
fail();
bench_new(dst1, in, filter, STRIDE, N);
}
| [
"static void FUNC_0(void)\n{",
"LOCAL_ALIGNED_16(INTFLOAT, dst0, [BUF_SIZE], [2]);",
"LOCAL_ALIGNED_16(INTFLOAT, dst1, [BUF_SIZE], [2]);",
"LOCAL_ALIGNED_16(INTFLOAT, in, [12], [2]);",
"LOCAL_ALIGNED_16(INTFLOAT, filter, [N], [8][2]);",
"declare_func(void, INTFLOAT (*out)[2], INTFLOAT (*in)[2],\nconst INTFLOAT (*filter)[8][2],\nptrdiff_t stride, int n);",
"randomize((INTFLOAT *)in, 12 * 2);",
"randomize((INTFLOAT *)filter, N * 8 * 2);",
"randomize((INTFLOAT *)dst0, BUF_SIZE * 2);",
"memcpy(dst1, dst0, BUF_SIZE * 2 * sizeof(INTFLOAT));",
"call_ref(dst0, in, filter, STRIDE, N);",
"call_new(dst1, in, filter, STRIDE, N);",
"if (!float_near_abs_eps_array((float *)dst0, (float *)dst1, EPS, BUF_SIZE * 2))\nfail();",
"bench_new(dst1, in, filter, STRIDE, N);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15,
17,
19
],
[
23
],
[
25
],
[
29
],
[
31
],
[
35
],
[
37
],
[
41,
43
],
[
45
],
[
47
]
]
|
12,766 | static void test_qemu_strtoul_full_max(void)
{
char *str = g_strdup_printf("%lu", ULONG_MAX);
unsigned long res = 999;
int err;
err = qemu_strtoul(str, NULL, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, ULONG_MAX);
g_free(str);
}
| false | qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | static void test_qemu_strtoul_full_max(void)
{
char *str = g_strdup_printf("%lu", ULONG_MAX);
unsigned long res = 999;
int err;
err = qemu_strtoul(str, NULL, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, ULONG_MAX);
g_free(str);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
char *VAR_0 = g_strdup_printf("%lu", ULONG_MAX);
unsigned long VAR_1 = 999;
int VAR_2;
VAR_2 = qemu_strtoul(VAR_0, NULL, 0, &VAR_1);
g_assert_cmpint(VAR_2, ==, 0);
g_assert_cmpint(VAR_1, ==, ULONG_MAX);
g_free(VAR_0);
}
| [
"static void FUNC_0(void)\n{",
"char *VAR_0 = g_strdup_printf(\"%lu\", ULONG_MAX);",
"unsigned long VAR_1 = 999;",
"int VAR_2;",
"VAR_2 = qemu_strtoul(VAR_0, NULL, 0, &VAR_1);",
"g_assert_cmpint(VAR_2, ==, 0);",
"g_assert_cmpint(VAR_1, ==, ULONG_MAX);",
"g_free(VAR_0);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
]
]
|
12,767 | static uint64_t assigned_dev_ioport_read(void *opaque,
target_phys_addr_t addr, unsigned size)
{
return assigned_dev_ioport_rw(opaque, addr, size, NULL);
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static uint64_t assigned_dev_ioport_read(void *opaque,
target_phys_addr_t addr, unsigned size)
{
return assigned_dev_ioport_rw(opaque, addr, size, NULL);
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(void *opaque,
target_phys_addr_t addr, unsigned size)
{
return assigned_dev_ioport_rw(opaque, addr, size, NULL);
}
| [
"static uint64_t FUNC_0(void *opaque,\ntarget_phys_addr_t addr, unsigned size)\n{",
"return assigned_dev_ioport_rw(opaque, addr, size, NULL);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
]
]
|
12,768 | int qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr)
{
RAMBlock *block;
uint8_t *host = ptr;
if (xen_enabled()) {
*ram_addr = xen_ram_addr_from_mapcache(ptr);
return 0;
}
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
/* This case append when the block is not mapped. */
if (block->host == NULL) {
continue;
}
if (host - block->host < block->length) {
*ram_addr = block->offset + (host - block->host);
return 0;
}
}
return -1;
}
| false | qemu | 23887b79df2be53dc49166e1b677469abfb92147 | int qemu_ram_addr_from_host(void *ptr, ram_addr_t *ram_addr)
{
RAMBlock *block;
uint8_t *host = ptr;
if (xen_enabled()) {
*ram_addr = xen_ram_addr_from_mapcache(ptr);
return 0;
}
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
if (block->host == NULL) {
continue;
}
if (host - block->host < block->length) {
*ram_addr = block->offset + (host - block->host);
return 0;
}
}
return -1;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(void *VAR_0, ram_addr_t *VAR_1)
{
RAMBlock *block;
uint8_t *host = VAR_0;
if (xen_enabled()) {
*VAR_1 = xen_ram_addr_from_mapcache(VAR_0);
return 0;
}
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
if (block->host == NULL) {
continue;
}
if (host - block->host < block->length) {
*VAR_1 = block->offset + (host - block->host);
return 0;
}
}
return -1;
}
| [
"int FUNC_0(void *VAR_0, ram_addr_t *VAR_1)\n{",
"RAMBlock *block;",
"uint8_t *host = VAR_0;",
"if (xen_enabled()) {",
"*VAR_1 = xen_ram_addr_from_mapcache(VAR_0);",
"return 0;",
"}",
"QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
"if (block->host == NULL) {",
"continue;",
"}",
"if (host - block->host < block->length) {",
"*VAR_1 = block->offset + (host - block->host);",
"return 0;",
"}",
"}",
"return -1;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
]
]
|
12,769 | static void address_space_update_topology_pass(AddressSpace *as,
const FlatView *old_view,
const FlatView *new_view,
bool adding)
{
unsigned iold, inew;
FlatRange *frold, *frnew;
/* Generate a symmetric difference of the old and new memory maps.
* Kill ranges in the old map, and instantiate ranges in the new map.
*/
iold = inew = 0;
while (iold < old_view->nr || inew < new_view->nr) {
if (iold < old_view->nr) {
frold = &old_view->ranges[iold];
} else {
frold = NULL;
}
if (inew < new_view->nr) {
frnew = &new_view->ranges[inew];
} else {
frnew = NULL;
}
if (frold
&& (!frnew
|| int128_lt(frold->addr.start, frnew->addr.start)
|| (int128_eq(frold->addr.start, frnew->addr.start)
&& !flatrange_equal(frold, frnew)))) {
/* In old but not in new, or in both but attributes changed. */
if (!adding) {
MEMORY_LISTENER_UPDATE_REGION(frold, as, Reverse, region_del);
}
++iold;
} else if (frold && frnew && flatrange_equal(frold, frnew)) {
/* In both and unchanged (except logging may have changed) */
if (adding) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, region_nop);
if (frold->dirty_log_mask && !frnew->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Reverse, log_stop);
} else if (frnew->dirty_log_mask && !frold->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, log_start);
}
}
++iold;
++inew;
} else {
/* In new */
if (adding) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, region_add);
}
++inew;
}
}
}
| false | qemu | b2dfd71c4843a762f2befe702adb249cf55baf66 | static void address_space_update_topology_pass(AddressSpace *as,
const FlatView *old_view,
const FlatView *new_view,
bool adding)
{
unsigned iold, inew;
FlatRange *frold, *frnew;
iold = inew = 0;
while (iold < old_view->nr || inew < new_view->nr) {
if (iold < old_view->nr) {
frold = &old_view->ranges[iold];
} else {
frold = NULL;
}
if (inew < new_view->nr) {
frnew = &new_view->ranges[inew];
} else {
frnew = NULL;
}
if (frold
&& (!frnew
|| int128_lt(frold->addr.start, frnew->addr.start)
|| (int128_eq(frold->addr.start, frnew->addr.start)
&& !flatrange_equal(frold, frnew)))) {
if (!adding) {
MEMORY_LISTENER_UPDATE_REGION(frold, as, Reverse, region_del);
}
++iold;
} else if (frold && frnew && flatrange_equal(frold, frnew)) {
if (adding) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, region_nop);
if (frold->dirty_log_mask && !frnew->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Reverse, log_stop);
} else if (frnew->dirty_log_mask && !frold->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, log_start);
}
}
++iold;
++inew;
} else {
if (adding) {
MEMORY_LISTENER_UPDATE_REGION(frnew, as, Forward, region_add);
}
++inew;
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AddressSpace *VAR_0,
const FlatView *VAR_1,
const FlatView *VAR_2,
bool VAR_3)
{
unsigned VAR_4, VAR_5;
FlatRange *frold, *frnew;
VAR_4 = VAR_5 = 0;
while (VAR_4 < VAR_1->nr || VAR_5 < VAR_2->nr) {
if (VAR_4 < VAR_1->nr) {
frold = &VAR_1->ranges[VAR_4];
} else {
frold = NULL;
}
if (VAR_5 < VAR_2->nr) {
frnew = &VAR_2->ranges[VAR_5];
} else {
frnew = NULL;
}
if (frold
&& (!frnew
|| int128_lt(frold->addr.start, frnew->addr.start)
|| (int128_eq(frold->addr.start, frnew->addr.start)
&& !flatrange_equal(frold, frnew)))) {
if (!VAR_3) {
MEMORY_LISTENER_UPDATE_REGION(frold, VAR_0, Reverse, region_del);
}
++VAR_4;
} else if (frold && frnew && flatrange_equal(frold, frnew)) {
if (VAR_3) {
MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Forward, region_nop);
if (frold->dirty_log_mask && !frnew->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Reverse, log_stop);
} else if (frnew->dirty_log_mask && !frold->dirty_log_mask) {
MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Forward, log_start);
}
}
++VAR_4;
++VAR_5;
} else {
if (VAR_3) {
MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Forward, region_add);
}
++VAR_5;
}
}
}
| [
"static void FUNC_0(AddressSpace *VAR_0,\nconst FlatView *VAR_1,\nconst FlatView *VAR_2,\nbool VAR_3)\n{",
"unsigned VAR_4, VAR_5;",
"FlatRange *frold, *frnew;",
"VAR_4 = VAR_5 = 0;",
"while (VAR_4 < VAR_1->nr || VAR_5 < VAR_2->nr) {",
"if (VAR_4 < VAR_1->nr) {",
"frold = &VAR_1->ranges[VAR_4];",
"} else {",
"frold = NULL;",
"}",
"if (VAR_5 < VAR_2->nr) {",
"frnew = &VAR_2->ranges[VAR_5];",
"} else {",
"frnew = NULL;",
"}",
"if (frold\n&& (!frnew\n|| int128_lt(frold->addr.start, frnew->addr.start)\n|| (int128_eq(frold->addr.start, frnew->addr.start)\n&& !flatrange_equal(frold, frnew)))) {",
"if (!VAR_3) {",
"MEMORY_LISTENER_UPDATE_REGION(frold, VAR_0, Reverse, region_del);",
"}",
"++VAR_4;",
"} else if (frold && frnew && flatrange_equal(frold, frnew)) {",
"if (VAR_3) {",
"MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Forward, region_nop);",
"if (frold->dirty_log_mask && !frnew->dirty_log_mask) {",
"MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Reverse, log_stop);",
"} else if (frnew->dirty_log_mask && !frold->dirty_log_mask) {",
"MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Forward, log_start);",
"}",
"}",
"++VAR_4;",
"++VAR_5;",
"} else {",
"if (VAR_3) {",
"MEMORY_LISTENER_UPDATE_REGION(frnew, VAR_0, Forward, region_add);",
"}",
"++VAR_5;",
"}",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49,
51,
53,
55,
57
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
97
],
[
99
],
[
101
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119
],
[
121
]
]
|
12,770 | static void pxb_dev_exitfn(PCIDevice *pci_dev)
{
PXBDev *pxb = PXB_DEV(pci_dev);
pxb_dev_list = g_list_remove(pxb_dev_list, pxb);
}
| false | qemu | 02b07434bed8360715198b4cbfdfebd17f7cac32 | static void pxb_dev_exitfn(PCIDevice *pci_dev)
{
PXBDev *pxb = PXB_DEV(pci_dev);
pxb_dev_list = g_list_remove(pxb_dev_list, pxb);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PCIDevice *VAR_0)
{
PXBDev *pxb = PXB_DEV(VAR_0);
pxb_dev_list = g_list_remove(pxb_dev_list, pxb);
}
| [
"static void FUNC_0(PCIDevice *VAR_0)\n{",
"PXBDev *pxb = PXB_DEV(VAR_0);",
"pxb_dev_list = g_list_remove(pxb_dev_list, pxb);",
"}"
]
| [
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
]
]
|
12,771 | static void ne2000_write(void *opaque, target_phys_addr_t addr,
uint64_t data, unsigned size)
{
NE2000State *s = opaque;
if (addr < 0x10 && size == 1) {
ne2000_ioport_write(s, addr, data);
} else if (addr == 0x10) {
if (size <= 2) {
ne2000_asic_ioport_write(s, addr, data);
} else {
ne2000_asic_ioport_writel(s, addr, data);
}
} else if (addr == 0x1f && size == 1) {
ne2000_reset_ioport_write(s, addr, data);
}
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void ne2000_write(void *opaque, target_phys_addr_t addr,
uint64_t data, unsigned size)
{
NE2000State *s = opaque;
if (addr < 0x10 && size == 1) {
ne2000_ioport_write(s, addr, data);
} else if (addr == 0x10) {
if (size <= 2) {
ne2000_asic_ioport_write(s, addr, data);
} else {
ne2000_asic_ioport_writel(s, addr, data);
}
} else if (addr == 0x1f && size == 1) {
ne2000_reset_ioport_write(s, addr, data);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned VAR_3)
{
NE2000State *s = VAR_0;
if (VAR_1 < 0x10 && VAR_3 == 1) {
ne2000_ioport_write(s, VAR_1, VAR_2);
} else if (VAR_1 == 0x10) {
if (VAR_3 <= 2) {
ne2000_asic_ioport_write(s, VAR_1, VAR_2);
} else {
ne2000_asic_ioport_writel(s, VAR_1, VAR_2);
}
} else if (VAR_1 == 0x1f && VAR_3 == 1) {
ne2000_reset_ioport_write(s, VAR_1, VAR_2);
}
}
| [
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{",
"NE2000State *s = VAR_0;",
"if (VAR_1 < 0x10 && VAR_3 == 1) {",
"ne2000_ioport_write(s, VAR_1, VAR_2);",
"} else if (VAR_1 == 0x10) {",
"if (VAR_3 <= 2) {",
"ne2000_asic_ioport_write(s, VAR_1, VAR_2);",
"} else {",
"ne2000_asic_ioport_writel(s, VAR_1, VAR_2);",
"}",
"} else if (VAR_1 == 0x1f && VAR_3 == 1) {",
"ne2000_reset_ioport_write(s, VAR_1, VAR_2);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
]
|
12,772 | static void cuda_writew (void *opaque, target_phys_addr_t addr, uint32_t value)
{
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void cuda_writew (void *opaque, target_phys_addr_t addr, uint32_t value)
{
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1, uint32_t VAR_2)
{
}
| [
"static void FUNC_0 (void *VAR_0, target_phys_addr_t VAR_1, uint32_t VAR_2)\n{",
"}"
]
| [
0,
0
]
| [
[
1,
3
],
[
5
]
]
|
12,773 | void smbios_set_defaults(const char *manufacturer, const char *product,
const char *version)
{
SMBIOS_SET_DEFAULT(type1.manufacturer, manufacturer);
SMBIOS_SET_DEFAULT(type1.product, product);
SMBIOS_SET_DEFAULT(type1.version, version);
}
| false | qemu | c97294ec1b9e36887e119589d456557d72ab37b5 | void smbios_set_defaults(const char *manufacturer, const char *product,
const char *version)
{
SMBIOS_SET_DEFAULT(type1.manufacturer, manufacturer);
SMBIOS_SET_DEFAULT(type1.product, product);
SMBIOS_SET_DEFAULT(type1.version, version);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(const char *VAR_0, const char *VAR_1,
const char *VAR_2)
{
SMBIOS_SET_DEFAULT(type1.VAR_0, VAR_0);
SMBIOS_SET_DEFAULT(type1.VAR_1, VAR_1);
SMBIOS_SET_DEFAULT(type1.VAR_2, VAR_2);
}
| [
"void FUNC_0(const char *VAR_0, const char *VAR_1,\nconst char *VAR_2)\n{",
"SMBIOS_SET_DEFAULT(type1.VAR_0, VAR_0);",
"SMBIOS_SET_DEFAULT(type1.VAR_1, VAR_1);",
"SMBIOS_SET_DEFAULT(type1.VAR_2, VAR_2);",
"}"
]
| [
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
]
]
|
12,774 | void qio_channel_socket_dgram_async(QIOChannelSocket *ioc,
SocketAddressLegacy *localAddr,
SocketAddressLegacy *remoteAddr,
QIOTaskFunc callback,
gpointer opaque,
GDestroyNotify destroy)
{
QIOTask *task = qio_task_new(
OBJECT(ioc), callback, opaque, destroy);
struct QIOChannelSocketDGramWorkerData *data = g_new0(
struct QIOChannelSocketDGramWorkerData, 1);
data->localAddr = QAPI_CLONE(SocketAddressLegacy, localAddr);
data->remoteAddr = QAPI_CLONE(SocketAddressLegacy, remoteAddr);
trace_qio_channel_socket_dgram_async(ioc, localAddr, remoteAddr);
qio_task_run_in_thread(task,
qio_channel_socket_dgram_worker,
data,
qio_channel_socket_dgram_worker_free);
}
| false | qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | void qio_channel_socket_dgram_async(QIOChannelSocket *ioc,
SocketAddressLegacy *localAddr,
SocketAddressLegacy *remoteAddr,
QIOTaskFunc callback,
gpointer opaque,
GDestroyNotify destroy)
{
QIOTask *task = qio_task_new(
OBJECT(ioc), callback, opaque, destroy);
struct QIOChannelSocketDGramWorkerData *data = g_new0(
struct QIOChannelSocketDGramWorkerData, 1);
data->localAddr = QAPI_CLONE(SocketAddressLegacy, localAddr);
data->remoteAddr = QAPI_CLONE(SocketAddressLegacy, remoteAddr);
trace_qio_channel_socket_dgram_async(ioc, localAddr, remoteAddr);
qio_task_run_in_thread(task,
qio_channel_socket_dgram_worker,
data,
qio_channel_socket_dgram_worker_free);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(QIOChannelSocket *VAR_0,
SocketAddressLegacy *VAR_1,
SocketAddressLegacy *VAR_2,
QIOTaskFunc VAR_3,
gpointer VAR_4,
GDestroyNotify VAR_5)
{
QIOTask *task = qio_task_new(
OBJECT(VAR_0), VAR_3, VAR_4, VAR_5);
struct QIOChannelSocketDGramWorkerData *VAR_6 = g_new0(
struct QIOChannelSocketDGramWorkerData, 1);
VAR_6->VAR_1 = QAPI_CLONE(SocketAddressLegacy, VAR_1);
VAR_6->VAR_2 = QAPI_CLONE(SocketAddressLegacy, VAR_2);
trace_qio_channel_socket_dgram_async(VAR_0, VAR_1, VAR_2);
qio_task_run_in_thread(task,
qio_channel_socket_dgram_worker,
VAR_6,
qio_channel_socket_dgram_worker_free);
}
| [
"void FUNC_0(QIOChannelSocket *VAR_0,\nSocketAddressLegacy *VAR_1,\nSocketAddressLegacy *VAR_2,\nQIOTaskFunc VAR_3,\ngpointer VAR_4,\nGDestroyNotify VAR_5)\n{",
"QIOTask *task = qio_task_new(\nOBJECT(VAR_0), VAR_3, VAR_4, VAR_5);",
"struct QIOChannelSocketDGramWorkerData *VAR_6 = g_new0(\nstruct QIOChannelSocketDGramWorkerData, 1);",
"VAR_6->VAR_1 = QAPI_CLONE(SocketAddressLegacy, VAR_1);",
"VAR_6->VAR_2 = QAPI_CLONE(SocketAddressLegacy, VAR_2);",
"trace_qio_channel_socket_dgram_async(VAR_0, VAR_1, VAR_2);",
"qio_task_run_in_thread(task,\nqio_channel_socket_dgram_worker,\nVAR_6,\nqio_channel_socket_dgram_worker_free);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9,
11,
13
],
[
15,
17
],
[
19,
21
],
[
25
],
[
27
],
[
31
],
[
33,
35,
37,
39
],
[
41
]
]
|
12,776 | static void spawn_thread_bh_fn(void *opaque)
{
ThreadPool *pool = opaque;
qemu_mutex_lock(&pool->lock);
do_spawn_thread(pool);
qemu_mutex_unlock(&pool->lock);
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | static void spawn_thread_bh_fn(void *opaque)
{
ThreadPool *pool = opaque;
qemu_mutex_lock(&pool->lock);
do_spawn_thread(pool);
qemu_mutex_unlock(&pool->lock);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
ThreadPool *pool = VAR_0;
qemu_mutex_lock(&pool->lock);
do_spawn_thread(pool);
qemu_mutex_unlock(&pool->lock);
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"ThreadPool *pool = VAR_0;",
"qemu_mutex_lock(&pool->lock);",
"do_spawn_thread(pool);",
"qemu_mutex_unlock(&pool->lock);",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
]
]
|
12,779 | static void ppc_prep_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->initrd_filename;
const char *boot_device = machine->boot_order;
MemoryRegion *sysmem = get_system_memory();
PowerPCCPU *cpu = NULL;
CPUPPCState *env = NULL;
Nvram *m48t59;
#if 0
MemoryRegion *xcsr = g_new(MemoryRegion, 1);
#endif
int linux_boot, i, nb_nics1;
MemoryRegion *ram = g_new(MemoryRegion, 1);
uint32_t kernel_base, initrd_base;
long kernel_size, initrd_size;
DeviceState *dev;
PCIHostState *pcihost;
PCIBus *pci_bus;
PCIDevice *pci;
ISABus *isa_bus;
ISADevice *isa;
int ppc_boot_device;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
sysctrl = g_malloc0(sizeof(sysctrl_t));
linux_boot = (kernel_filename != NULL);
/* init CPUs */
if (machine->cpu_model == NULL)
machine->cpu_model = "602";
for (i = 0; i < smp_cpus; i++) {
cpu = POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU,
machine->cpu_model));
if (cpu == NULL) {
fprintf(stderr, "Unable to find PowerPC CPU definition\n");
exit(1);
}
env = &cpu->env;
if (env->flags & POWERPC_FLAG_RTC_CLK) {
/* POWER / PowerPC 601 RTC clock frequency is 7.8125 MHz */
cpu_ppc_tb_init(env, 7812500UL);
} else {
/* Set time-base frequency to 100 Mhz */
cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);
}
qemu_register_reset(ppc_prep_reset, cpu);
}
/* allocate RAM */
memory_region_allocate_system_memory(ram, NULL, "ppc_prep.ram", ram_size);
memory_region_add_subregion(sysmem, 0, ram);
if (linux_boot) {
kernel_base = KERNEL_LOAD_ADDR;
/* now we can load the kernel */
kernel_size = load_image_targphys(kernel_filename, kernel_base,
ram_size - kernel_base);
if (kernel_size < 0) {
error_report("could not load kernel '%s'", kernel_filename);
exit(1);
}
/* load initrd */
if (initrd_filename) {
initrd_base = INITRD_LOAD_ADDR;
initrd_size = load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
exit(1);
}
} else {
initrd_base = 0;
initrd_size = 0;
}
ppc_boot_device = 'm';
} else {
kernel_base = 0;
kernel_size = 0;
initrd_base = 0;
initrd_size = 0;
ppc_boot_device = '\0';
/* For now, OHW cannot boot from the network. */
for (i = 0; boot_device[i] != '\0'; i++) {
if (boot_device[i] >= 'a' && boot_device[i] <= 'f') {
ppc_boot_device = boot_device[i];
break;
}
}
if (ppc_boot_device == '\0') {
fprintf(stderr, "No valid boot device for Mac99 machine\n");
exit(1);
}
}
if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {
error_report("Only 6xx bus is supported on PREP machine");
exit(1);
}
dev = qdev_create(NULL, "raven-pcihost");
if (bios_name == NULL) {
bios_name = BIOS_FILENAME;
}
qdev_prop_set_string(dev, "bios-name", bios_name);
qdev_prop_set_uint32(dev, "elf-machine", PPC_ELF_MACHINE);
pcihost = PCI_HOST_BRIDGE(dev);
object_property_add_child(qdev_get_machine(), "raven", OBJECT(dev), NULL);
qdev_init_nofail(dev);
pci_bus = (PCIBus *)qdev_get_child_bus(dev, "pci.0");
if (pci_bus == NULL) {
fprintf(stderr, "Couldn't create PCI host controller.\n");
exit(1);
}
sysctrl->contiguous_map_irq = qdev_get_gpio_in(dev, 0);
/* PCI -> ISA bridge */
pci = pci_create_simple(pci_bus, PCI_DEVFN(1, 0), "i82378");
cpu = POWERPC_CPU(first_cpu);
qdev_connect_gpio_out(&pci->qdev, 0,
cpu->env.irq_inputs[PPC6xx_INPUT_INT]);
sysbus_connect_irq(&pcihost->busdev, 0, qdev_get_gpio_in(&pci->qdev, 9));
sysbus_connect_irq(&pcihost->busdev, 1, qdev_get_gpio_in(&pci->qdev, 11));
sysbus_connect_irq(&pcihost->busdev, 2, qdev_get_gpio_in(&pci->qdev, 9));
sysbus_connect_irq(&pcihost->busdev, 3, qdev_get_gpio_in(&pci->qdev, 11));
isa_bus = ISA_BUS(qdev_get_child_bus(DEVICE(pci), "isa.0"));
/* Super I/O (parallel + serial ports) */
isa = isa_create(isa_bus, TYPE_PC87312);
dev = DEVICE(isa);
qdev_prop_set_uint8(dev, "config", 13); /* fdc, ser0, ser1, par0 */
qdev_init_nofail(dev);
/* init basic PC hardware */
pci_vga_init(pci_bus);
nb_nics1 = nb_nics;
if (nb_nics1 > NE2000_NB_MAX)
nb_nics1 = NE2000_NB_MAX;
for(i = 0; i < nb_nics1; i++) {
if (nd_table[i].model == NULL) {
nd_table[i].model = g_strdup("ne2k_isa");
}
if (strcmp(nd_table[i].model, "ne2k_isa") == 0) {
isa_ne2000_init(isa_bus, ne2000_io[i], ne2000_irq[i],
&nd_table[i]);
} else {
pci_nic_init_nofail(&nd_table[i], pci_bus, "ne2k_pci", NULL);
}
}
ide_drive_get(hd, ARRAY_SIZE(hd));
for(i = 0; i < MAX_IDE_BUS; i++) {
isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i], ide_irq[i],
hd[2 * i],
hd[2 * i + 1]);
}
isa_create_simple(isa_bus, "i8042");
cpu = POWERPC_CPU(first_cpu);
sysctrl->reset_irq = cpu->env.irq_inputs[PPC6xx_INPUT_HRESET];
portio_list_init(&prep_port_list, NULL, prep_portio_list, sysctrl, "prep");
portio_list_add(&prep_port_list, isa_address_space_io(isa), 0x0);
/* PowerPC control and status register group */
#if 0
memory_region_init_io(xcsr, NULL, &PPC_XCSR_ops, NULL, "ppc-xcsr", 0x1000);
memory_region_add_subregion(sysmem, 0xFEFF0000, xcsr);
#endif
if (machine_usb(machine)) {
pci_create_simple(pci_bus, -1, "pci-ohci");
}
m48t59 = m48t59_init_isa(isa_bus, 0x0074, NVRAM_SIZE, 2000, 59);
if (m48t59 == NULL)
return;
sysctrl->nvram = m48t59;
/* Initialise NVRAM */
PPC_NVRAM_set_params(m48t59, NVRAM_SIZE, "PREP", ram_size,
ppc_boot_device,
kernel_base, kernel_size,
kernel_cmdline,
initrd_base, initrd_size,
/* XXX: need an option to load a NVRAM image */
0,
graphic_width, graphic_height, graphic_depth);
}
| true | qemu | 4482e05cbbb7e50e476f6a9500cf0b38913bd939 | static void ppc_prep_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->initrd_filename;
const char *boot_device = machine->boot_order;
MemoryRegion *sysmem = get_system_memory();
PowerPCCPU *cpu = NULL;
CPUPPCState *env = NULL;
Nvram *m48t59;
#if 0
MemoryRegion *xcsr = g_new(MemoryRegion, 1);
#endif
int linux_boot, i, nb_nics1;
MemoryRegion *ram = g_new(MemoryRegion, 1);
uint32_t kernel_base, initrd_base;
long kernel_size, initrd_size;
DeviceState *dev;
PCIHostState *pcihost;
PCIBus *pci_bus;
PCIDevice *pci;
ISABus *isa_bus;
ISADevice *isa;
int ppc_boot_device;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
sysctrl = g_malloc0(sizeof(sysctrl_t));
linux_boot = (kernel_filename != NULL);
if (machine->cpu_model == NULL)
machine->cpu_model = "602";
for (i = 0; i < smp_cpus; i++) {
cpu = POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU,
machine->cpu_model));
if (cpu == NULL) {
fprintf(stderr, "Unable to find PowerPC CPU definition\n");
exit(1);
}
env = &cpu->env;
if (env->flags & POWERPC_FLAG_RTC_CLK) {
cpu_ppc_tb_init(env, 7812500UL);
} else {
cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);
}
qemu_register_reset(ppc_prep_reset, cpu);
}
memory_region_allocate_system_memory(ram, NULL, "ppc_prep.ram", ram_size);
memory_region_add_subregion(sysmem, 0, ram);
if (linux_boot) {
kernel_base = KERNEL_LOAD_ADDR;
kernel_size = load_image_targphys(kernel_filename, kernel_base,
ram_size - kernel_base);
if (kernel_size < 0) {
error_report("could not load kernel '%s'", kernel_filename);
exit(1);
}
if (initrd_filename) {
initrd_base = INITRD_LOAD_ADDR;
initrd_size = load_image_targphys(initrd_filename, initrd_base,
ram_size - initrd_base);
if (initrd_size < 0) {
error_report("could not load initial ram disk '%s'",
initrd_filename);
exit(1);
}
} else {
initrd_base = 0;
initrd_size = 0;
}
ppc_boot_device = 'm';
} else {
kernel_base = 0;
kernel_size = 0;
initrd_base = 0;
initrd_size = 0;
ppc_boot_device = '\0';
for (i = 0; boot_device[i] != '\0'; i++) {
if (boot_device[i] >= 'a' && boot_device[i] <= 'f') {
ppc_boot_device = boot_device[i];
break;
}
}
if (ppc_boot_device == '\0') {
fprintf(stderr, "No valid boot device for Mac99 machine\n");
exit(1);
}
}
if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {
error_report("Only 6xx bus is supported on PREP machine");
exit(1);
}
dev = qdev_create(NULL, "raven-pcihost");
if (bios_name == NULL) {
bios_name = BIOS_FILENAME;
}
qdev_prop_set_string(dev, "bios-name", bios_name);
qdev_prop_set_uint32(dev, "elf-machine", PPC_ELF_MACHINE);
pcihost = PCI_HOST_BRIDGE(dev);
object_property_add_child(qdev_get_machine(), "raven", OBJECT(dev), NULL);
qdev_init_nofail(dev);
pci_bus = (PCIBus *)qdev_get_child_bus(dev, "pci.0");
if (pci_bus == NULL) {
fprintf(stderr, "Couldn't create PCI host controller.\n");
exit(1);
}
sysctrl->contiguous_map_irq = qdev_get_gpio_in(dev, 0);
pci = pci_create_simple(pci_bus, PCI_DEVFN(1, 0), "i82378");
cpu = POWERPC_CPU(first_cpu);
qdev_connect_gpio_out(&pci->qdev, 0,
cpu->env.irq_inputs[PPC6xx_INPUT_INT]);
sysbus_connect_irq(&pcihost->busdev, 0, qdev_get_gpio_in(&pci->qdev, 9));
sysbus_connect_irq(&pcihost->busdev, 1, qdev_get_gpio_in(&pci->qdev, 11));
sysbus_connect_irq(&pcihost->busdev, 2, qdev_get_gpio_in(&pci->qdev, 9));
sysbus_connect_irq(&pcihost->busdev, 3, qdev_get_gpio_in(&pci->qdev, 11));
isa_bus = ISA_BUS(qdev_get_child_bus(DEVICE(pci), "isa.0"));
isa = isa_create(isa_bus, TYPE_PC87312);
dev = DEVICE(isa);
qdev_prop_set_uint8(dev, "config", 13);
qdev_init_nofail(dev);
pci_vga_init(pci_bus);
nb_nics1 = nb_nics;
if (nb_nics1 > NE2000_NB_MAX)
nb_nics1 = NE2000_NB_MAX;
for(i = 0; i < nb_nics1; i++) {
if (nd_table[i].model == NULL) {
nd_table[i].model = g_strdup("ne2k_isa");
}
if (strcmp(nd_table[i].model, "ne2k_isa") == 0) {
isa_ne2000_init(isa_bus, ne2000_io[i], ne2000_irq[i],
&nd_table[i]);
} else {
pci_nic_init_nofail(&nd_table[i], pci_bus, "ne2k_pci", NULL);
}
}
ide_drive_get(hd, ARRAY_SIZE(hd));
for(i = 0; i < MAX_IDE_BUS; i++) {
isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i], ide_irq[i],
hd[2 * i],
hd[2 * i + 1]);
}
isa_create_simple(isa_bus, "i8042");
cpu = POWERPC_CPU(first_cpu);
sysctrl->reset_irq = cpu->env.irq_inputs[PPC6xx_INPUT_HRESET];
portio_list_init(&prep_port_list, NULL, prep_portio_list, sysctrl, "prep");
portio_list_add(&prep_port_list, isa_address_space_io(isa), 0x0);
#if 0
memory_region_init_io(xcsr, NULL, &PPC_XCSR_ops, NULL, "ppc-xcsr", 0x1000);
memory_region_add_subregion(sysmem, 0xFEFF0000, xcsr);
#endif
if (machine_usb(machine)) {
pci_create_simple(pci_bus, -1, "pci-ohci");
}
m48t59 = m48t59_init_isa(isa_bus, 0x0074, NVRAM_SIZE, 2000, 59);
if (m48t59 == NULL)
return;
sysctrl->nvram = m48t59;
PPC_NVRAM_set_params(m48t59, NVRAM_SIZE, "PREP", ram_size,
ppc_boot_device,
kernel_base, kernel_size,
kernel_cmdline,
initrd_base, initrd_size,
0,
graphic_width, graphic_height, graphic_depth);
}
| {
"code": [
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" if (cpu == NULL) {",
" exit(1);",
" exit(1);",
" if (cpu == NULL) {",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" if (cpu == NULL) {",
" exit(1);",
" if (cpu == NULL) {",
" exit(1);",
" if (cpu == NULL) {",
" fprintf(stderr, \"Unable to find PowerPC CPU definition\\n\");",
" exit(1);",
" if (cpu == NULL) {",
" fprintf(stderr, \"Unable to find PowerPC CPU definition\\n\");",
" exit(1);",
" exit(1);",
" exit(1);",
" if (cpu == NULL) {",
" fprintf(stderr, \"Unable to find PowerPC CPU definition\\n\");",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" exit(1);",
" if (cpu == NULL) {",
" if (cpu == NULL) {"
],
"line_no": [
205,
79,
205,
205,
205,
205,
205,
205,
205,
205,
205,
205,
205,
75,
205,
205,
75,
79,
205,
205,
205,
75,
79,
75,
79,
75,
77,
79,
75,
77,
79,
205,
205,
75,
77,
79,
205,
205,
205,
205,
205,
205,
205,
205,
205,
75,
75
]
} | static void FUNC_0(MachineState *VAR_0)
{
ram_addr_t ram_size = VAR_0->ram_size;
const char *VAR_1 = VAR_0->VAR_1;
const char *VAR_2 = VAR_0->VAR_2;
const char *VAR_3 = VAR_0->VAR_3;
const char *VAR_4 = VAR_0->boot_order;
MemoryRegion *sysmem = get_system_memory();
PowerPCCPU *cpu = NULL;
CPUPPCState *env = NULL;
Nvram *m48t59;
#if 0
MemoryRegion *xcsr = g_new(MemoryRegion, 1);
#endif
int VAR_5, VAR_6, VAR_7;
MemoryRegion *ram = g_new(MemoryRegion, 1);
uint32_t kernel_base, initrd_base;
long VAR_8, VAR_9;
DeviceState *dev;
PCIHostState *pcihost;
PCIBus *pci_bus;
PCIDevice *pci;
ISABus *isa_bus;
ISADevice *isa;
int VAR_10;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
sysctrl = g_malloc0(sizeof(sysctrl_t));
VAR_5 = (VAR_1 != NULL);
if (VAR_0->cpu_model == NULL)
VAR_0->cpu_model = "602";
for (VAR_6 = 0; VAR_6 < smp_cpus; VAR_6++) {
cpu = POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU,
VAR_0->cpu_model));
if (cpu == NULL) {
fprintf(stderr, "Unable to find PowerPC CPU definition\n");
exit(1);
}
env = &cpu->env;
if (env->flags & POWERPC_FLAG_RTC_CLK) {
cpu_ppc_tb_init(env, 7812500UL);
} else {
cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);
}
qemu_register_reset(ppc_prep_reset, cpu);
}
memory_region_allocate_system_memory(ram, NULL, "ppc_prep.ram", ram_size);
memory_region_add_subregion(sysmem, 0, ram);
if (VAR_5) {
kernel_base = KERNEL_LOAD_ADDR;
VAR_8 = load_image_targphys(VAR_1, kernel_base,
ram_size - kernel_base);
if (VAR_8 < 0) {
error_report("could not load kernel '%s'", VAR_1);
exit(1);
}
if (VAR_3) {
initrd_base = INITRD_LOAD_ADDR;
VAR_9 = load_image_targphys(VAR_3, initrd_base,
ram_size - initrd_base);
if (VAR_9 < 0) {
error_report("could not load initial ram disk '%s'",
VAR_3);
exit(1);
}
} else {
initrd_base = 0;
VAR_9 = 0;
}
VAR_10 = 'm';
} else {
kernel_base = 0;
VAR_8 = 0;
initrd_base = 0;
VAR_9 = 0;
VAR_10 = '\0';
for (VAR_6 = 0; VAR_4[VAR_6] != '\0'; VAR_6++) {
if (VAR_4[VAR_6] >= 'a' && VAR_4[VAR_6] <= 'f') {
VAR_10 = VAR_4[VAR_6];
break;
}
}
if (VAR_10 == '\0') {
fprintf(stderr, "No valid boot device for Mac99 VAR_0\n");
exit(1);
}
}
if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {
error_report("Only 6xx bus is supported on PREP VAR_0");
exit(1);
}
dev = qdev_create(NULL, "raven-pcihost");
if (bios_name == NULL) {
bios_name = BIOS_FILENAME;
}
qdev_prop_set_string(dev, "bios-name", bios_name);
qdev_prop_set_uint32(dev, "elf-VAR_0", PPC_ELF_MACHINE);
pcihost = PCI_HOST_BRIDGE(dev);
object_property_add_child(qdev_get_machine(), "raven", OBJECT(dev), NULL);
qdev_init_nofail(dev);
pci_bus = (PCIBus *)qdev_get_child_bus(dev, "pci.0");
if (pci_bus == NULL) {
fprintf(stderr, "Couldn't create PCI host controller.\n");
exit(1);
}
sysctrl->contiguous_map_irq = qdev_get_gpio_in(dev, 0);
pci = pci_create_simple(pci_bus, PCI_DEVFN(1, 0), "i82378");
cpu = POWERPC_CPU(first_cpu);
qdev_connect_gpio_out(&pci->qdev, 0,
cpu->env.irq_inputs[PPC6xx_INPUT_INT]);
sysbus_connect_irq(&pcihost->busdev, 0, qdev_get_gpio_in(&pci->qdev, 9));
sysbus_connect_irq(&pcihost->busdev, 1, qdev_get_gpio_in(&pci->qdev, 11));
sysbus_connect_irq(&pcihost->busdev, 2, qdev_get_gpio_in(&pci->qdev, 9));
sysbus_connect_irq(&pcihost->busdev, 3, qdev_get_gpio_in(&pci->qdev, 11));
isa_bus = ISA_BUS(qdev_get_child_bus(DEVICE(pci), "isa.0"));
isa = isa_create(isa_bus, TYPE_PC87312);
dev = DEVICE(isa);
qdev_prop_set_uint8(dev, "config", 13);
qdev_init_nofail(dev);
pci_vga_init(pci_bus);
VAR_7 = nb_nics;
if (VAR_7 > NE2000_NB_MAX)
VAR_7 = NE2000_NB_MAX;
for(VAR_6 = 0; VAR_6 < VAR_7; VAR_6++) {
if (nd_table[VAR_6].model == NULL) {
nd_table[VAR_6].model = g_strdup("ne2k_isa");
}
if (strcmp(nd_table[VAR_6].model, "ne2k_isa") == 0) {
isa_ne2000_init(isa_bus, ne2000_io[VAR_6], ne2000_irq[VAR_6],
&nd_table[VAR_6]);
} else {
pci_nic_init_nofail(&nd_table[VAR_6], pci_bus, "ne2k_pci", NULL);
}
}
ide_drive_get(hd, ARRAY_SIZE(hd));
for(VAR_6 = 0; VAR_6 < MAX_IDE_BUS; VAR_6++) {
isa_ide_init(isa_bus, ide_iobase[VAR_6], ide_iobase2[VAR_6], ide_irq[VAR_6],
hd[2 * VAR_6],
hd[2 * VAR_6 + 1]);
}
isa_create_simple(isa_bus, "i8042");
cpu = POWERPC_CPU(first_cpu);
sysctrl->reset_irq = cpu->env.irq_inputs[PPC6xx_INPUT_HRESET];
portio_list_init(&prep_port_list, NULL, prep_portio_list, sysctrl, "prep");
portio_list_add(&prep_port_list, isa_address_space_io(isa), 0x0);
#if 0
memory_region_init_io(xcsr, NULL, &PPC_XCSR_ops, NULL, "ppc-xcsr", 0x1000);
memory_region_add_subregion(sysmem, 0xFEFF0000, xcsr);
#endif
if (machine_usb(VAR_0)) {
pci_create_simple(pci_bus, -1, "pci-ohci");
}
m48t59 = m48t59_init_isa(isa_bus, 0x0074, NVRAM_SIZE, 2000, 59);
if (m48t59 == NULL)
return;
sysctrl->nvram = m48t59;
PPC_NVRAM_set_params(m48t59, NVRAM_SIZE, "PREP", ram_size,
VAR_10,
kernel_base, VAR_8,
VAR_2,
initrd_base, VAR_9,
0,
graphic_width, graphic_height, graphic_depth);
}
| [
"static void FUNC_0(MachineState *VAR_0)\n{",
"ram_addr_t ram_size = VAR_0->ram_size;",
"const char *VAR_1 = VAR_0->VAR_1;",
"const char *VAR_2 = VAR_0->VAR_2;",
"const char *VAR_3 = VAR_0->VAR_3;",
"const char *VAR_4 = VAR_0->boot_order;",
"MemoryRegion *sysmem = get_system_memory();",
"PowerPCCPU *cpu = NULL;",
"CPUPPCState *env = NULL;",
"Nvram *m48t59;",
"#if 0\nMemoryRegion *xcsr = g_new(MemoryRegion, 1);",
"#endif\nint VAR_5, VAR_6, VAR_7;",
"MemoryRegion *ram = g_new(MemoryRegion, 1);",
"uint32_t kernel_base, initrd_base;",
"long VAR_8, VAR_9;",
"DeviceState *dev;",
"PCIHostState *pcihost;",
"PCIBus *pci_bus;",
"PCIDevice *pci;",
"ISABus *isa_bus;",
"ISADevice *isa;",
"int VAR_10;",
"DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];",
"sysctrl = g_malloc0(sizeof(sysctrl_t));",
"VAR_5 = (VAR_1 != NULL);",
"if (VAR_0->cpu_model == NULL)\nVAR_0->cpu_model = \"602\";",
"for (VAR_6 = 0; VAR_6 < smp_cpus; VAR_6++) {",
"cpu = POWERPC_CPU(cpu_generic_init(TYPE_POWERPC_CPU,\nVAR_0->cpu_model));",
"if (cpu == NULL) {",
"fprintf(stderr, \"Unable to find PowerPC CPU definition\\n\");",
"exit(1);",
"}",
"env = &cpu->env;",
"if (env->flags & POWERPC_FLAG_RTC_CLK) {",
"cpu_ppc_tb_init(env, 7812500UL);",
"} else {",
"cpu_ppc_tb_init(env, 100UL * 1000UL * 1000UL);",
"}",
"qemu_register_reset(ppc_prep_reset, cpu);",
"}",
"memory_region_allocate_system_memory(ram, NULL, \"ppc_prep.ram\", ram_size);",
"memory_region_add_subregion(sysmem, 0, ram);",
"if (VAR_5) {",
"kernel_base = KERNEL_LOAD_ADDR;",
"VAR_8 = load_image_targphys(VAR_1, kernel_base,\nram_size - kernel_base);",
"if (VAR_8 < 0) {",
"error_report(\"could not load kernel '%s'\", VAR_1);",
"exit(1);",
"}",
"if (VAR_3) {",
"initrd_base = INITRD_LOAD_ADDR;",
"VAR_9 = load_image_targphys(VAR_3, initrd_base,\nram_size - initrd_base);",
"if (VAR_9 < 0) {",
"error_report(\"could not load initial ram disk '%s'\",\nVAR_3);",
"exit(1);",
"}",
"} else {",
"initrd_base = 0;",
"VAR_9 = 0;",
"}",
"VAR_10 = 'm';",
"} else {",
"kernel_base = 0;",
"VAR_8 = 0;",
"initrd_base = 0;",
"VAR_9 = 0;",
"VAR_10 = '\\0';",
"for (VAR_6 = 0; VAR_4[VAR_6] != '\\0'; VAR_6++) {",
"if (VAR_4[VAR_6] >= 'a' && VAR_4[VAR_6] <= 'f') {",
"VAR_10 = VAR_4[VAR_6];",
"break;",
"}",
"}",
"if (VAR_10 == '\\0') {",
"fprintf(stderr, \"No valid boot device for Mac99 VAR_0\\n\");",
"exit(1);",
"}",
"}",
"if (PPC_INPUT(env) != PPC_FLAGS_INPUT_6xx) {",
"error_report(\"Only 6xx bus is supported on PREP VAR_0\");",
"exit(1);",
"}",
"dev = qdev_create(NULL, \"raven-pcihost\");",
"if (bios_name == NULL) {",
"bios_name = BIOS_FILENAME;",
"}",
"qdev_prop_set_string(dev, \"bios-name\", bios_name);",
"qdev_prop_set_uint32(dev, \"elf-VAR_0\", PPC_ELF_MACHINE);",
"pcihost = PCI_HOST_BRIDGE(dev);",
"object_property_add_child(qdev_get_machine(), \"raven\", OBJECT(dev), NULL);",
"qdev_init_nofail(dev);",
"pci_bus = (PCIBus *)qdev_get_child_bus(dev, \"pci.0\");",
"if (pci_bus == NULL) {",
"fprintf(stderr, \"Couldn't create PCI host controller.\\n\");",
"exit(1);",
"}",
"sysctrl->contiguous_map_irq = qdev_get_gpio_in(dev, 0);",
"pci = pci_create_simple(pci_bus, PCI_DEVFN(1, 0), \"i82378\");",
"cpu = POWERPC_CPU(first_cpu);",
"qdev_connect_gpio_out(&pci->qdev, 0,\ncpu->env.irq_inputs[PPC6xx_INPUT_INT]);",
"sysbus_connect_irq(&pcihost->busdev, 0, qdev_get_gpio_in(&pci->qdev, 9));",
"sysbus_connect_irq(&pcihost->busdev, 1, qdev_get_gpio_in(&pci->qdev, 11));",
"sysbus_connect_irq(&pcihost->busdev, 2, qdev_get_gpio_in(&pci->qdev, 9));",
"sysbus_connect_irq(&pcihost->busdev, 3, qdev_get_gpio_in(&pci->qdev, 11));",
"isa_bus = ISA_BUS(qdev_get_child_bus(DEVICE(pci), \"isa.0\"));",
"isa = isa_create(isa_bus, TYPE_PC87312);",
"dev = DEVICE(isa);",
"qdev_prop_set_uint8(dev, \"config\", 13);",
"qdev_init_nofail(dev);",
"pci_vga_init(pci_bus);",
"VAR_7 = nb_nics;",
"if (VAR_7 > NE2000_NB_MAX)\nVAR_7 = NE2000_NB_MAX;",
"for(VAR_6 = 0; VAR_6 < VAR_7; VAR_6++) {",
"if (nd_table[VAR_6].model == NULL) {",
"nd_table[VAR_6].model = g_strdup(\"ne2k_isa\");",
"}",
"if (strcmp(nd_table[VAR_6].model, \"ne2k_isa\") == 0) {",
"isa_ne2000_init(isa_bus, ne2000_io[VAR_6], ne2000_irq[VAR_6],\n&nd_table[VAR_6]);",
"} else {",
"pci_nic_init_nofail(&nd_table[VAR_6], pci_bus, \"ne2k_pci\", NULL);",
"}",
"}",
"ide_drive_get(hd, ARRAY_SIZE(hd));",
"for(VAR_6 = 0; VAR_6 < MAX_IDE_BUS; VAR_6++) {",
"isa_ide_init(isa_bus, ide_iobase[VAR_6], ide_iobase2[VAR_6], ide_irq[VAR_6],\nhd[2 * VAR_6],\nhd[2 * VAR_6 + 1]);",
"}",
"isa_create_simple(isa_bus, \"i8042\");",
"cpu = POWERPC_CPU(first_cpu);",
"sysctrl->reset_irq = cpu->env.irq_inputs[PPC6xx_INPUT_HRESET];",
"portio_list_init(&prep_port_list, NULL, prep_portio_list, sysctrl, \"prep\");",
"portio_list_add(&prep_port_list, isa_address_space_io(isa), 0x0);",
"#if 0\nmemory_region_init_io(xcsr, NULL, &PPC_XCSR_ops, NULL, \"ppc-xcsr\", 0x1000);",
"memory_region_add_subregion(sysmem, 0xFEFF0000, xcsr);",
"#endif\nif (machine_usb(VAR_0)) {",
"pci_create_simple(pci_bus, -1, \"pci-ohci\");",
"}",
"m48t59 = m48t59_init_isa(isa_bus, 0x0074, NVRAM_SIZE, 2000, 59);",
"if (m48t59 == NULL)\nreturn;",
"sysctrl->nvram = m48t59;",
"PPC_NVRAM_set_params(m48t59, NVRAM_SIZE, \"PREP\", ram_size,\nVAR_10,\nkernel_base, VAR_8,\nVAR_2,\ninitrd_base, VAR_9,\n0,\ngraphic_width, graphic_height, graphic_depth);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
59
],
[
65,
67
],
[
69
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87
],
[
91
],
[
93
],
[
97
],
[
99
],
[
101
],
[
103
],
[
109
],
[
111
],
[
115
],
[
117
],
[
121,
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
135
],
[
137
],
[
139,
141
],
[
143
],
[
145,
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201
],
[
203
],
[
205
],
[
207
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
245
],
[
247
],
[
249,
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
267
],
[
269
],
[
271
],
[
273
],
[
279
],
[
283
],
[
285,
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299,
301
],
[
303
],
[
305
],
[
307
],
[
309
],
[
313
],
[
315
],
[
317,
319,
321
],
[
323
],
[
325
],
[
329
],
[
331
],
[
335
],
[
337
],
[
343,
345
],
[
347
],
[
349,
353
],
[
355
],
[
357
],
[
361
],
[
363,
365
],
[
367
],
[
373,
375,
377,
379,
381,
385,
387
],
[
389
]
]
|
12,781 | gen_set_condexec (DisasContext *s)
{
if (s->condexec_mask) {
uint32_t val = (s->condexec_cond << 4) | (s->condexec_mask >> 1);
TCGv tmp = new_tmp();
tcg_gen_movi_i32(tmp, val);
store_cpu_field(tmp, condexec_bits);
}
}
| true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 | gen_set_condexec (DisasContext *s)
{
if (s->condexec_mask) {
uint32_t val = (s->condexec_cond << 4) | (s->condexec_mask >> 1);
TCGv tmp = new_tmp();
tcg_gen_movi_i32(tmp, val);
store_cpu_field(tmp, condexec_bits);
}
}
| {
"code": [
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();"
],
"line_no": [
9,
9
]
} | FUNC_0 (DisasContext *VAR_0)
{
if (VAR_0->condexec_mask) {
uint32_t val = (VAR_0->condexec_cond << 4) | (VAR_0->condexec_mask >> 1);
TCGv tmp = new_tmp();
tcg_gen_movi_i32(tmp, val);
store_cpu_field(tmp, condexec_bits);
}
}
| [
"FUNC_0 (DisasContext *VAR_0)\n{",
"if (VAR_0->condexec_mask) {",
"uint32_t val = (VAR_0->condexec_cond << 4) | (VAR_0->condexec_mask >> 1);",
"TCGv tmp = new_tmp();",
"tcg_gen_movi_i32(tmp, val);",
"store_cpu_field(tmp, condexec_bits);",
"}",
"}"
]
| [
0,
0,
0,
1,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
]
|
12,782 | void *mcf_uart_init(qemu_irq irq, CharDriverState *chr)
{
mcf_uart_state *s;
s = g_malloc0(sizeof(mcf_uart_state));
s->chr = chr;
s->irq = irq;
if (chr) {
qemu_chr_add_handlers(chr, mcf_uart_can_receive, mcf_uart_receive,
mcf_uart_event, s);
}
mcf_uart_reset(s);
return s;
} | true | qemu | 456d60692310e7ac25cf822cc1e98192ad636ece | void *mcf_uart_init(qemu_irq irq, CharDriverState *chr)
{
mcf_uart_state *s;
s = g_malloc0(sizeof(mcf_uart_state));
s->chr = chr;
s->irq = irq;
if (chr) {
qemu_chr_add_handlers(chr, mcf_uart_can_receive, mcf_uart_receive,
mcf_uart_event, s);
}
mcf_uart_reset(s);
return s;
} | {
"code": [],
"line_no": []
} | void *FUNC_0(qemu_irq VAR_0, CharDriverState *VAR_1)
{
mcf_uart_state *s;
s = g_malloc0(sizeof(mcf_uart_state));
s->VAR_1 = VAR_1;
s->VAR_0 = VAR_0;
if (VAR_1) {
qemu_chr_add_handlers(VAR_1, mcf_uart_can_receive, mcf_uart_receive,
mcf_uart_event, s);
}
mcf_uart_reset(s);
return s;
} | [
"void *FUNC_0(qemu_irq VAR_0, CharDriverState *VAR_1)\n{",
"mcf_uart_state *s;",
"s = g_malloc0(sizeof(mcf_uart_state));",
"s->VAR_1 = VAR_1;",
"s->VAR_0 = VAR_0;",
"if (VAR_1) {",
"qemu_chr_add_handlers(VAR_1, mcf_uart_can_receive, mcf_uart_receive,\nmcf_uart_event, s);",
"}",
"mcf_uart_reset(s);",
"return s;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
18,
20
],
[
22
],
[
24
],
[
26
],
[
28
]
]
|
12,783 | static void parse_waveformatex(AVIOContext *pb, AVCodecParameters *par)
{
ff_asf_guid subformat;
par->bits_per_coded_sample = avio_rl16(pb);
par->channel_layout = avio_rl32(pb); /* dwChannelMask */
ff_get_guid(pb, &subformat);
if (!memcmp(subformat + 4,
(const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
par->codec_tag = AV_RL32(subformat);
par->codec_id = ff_wav_codec_get_id(par->codec_tag,
par->bits_per_coded_sample);
} else {
par->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);
if (!par->codec_id)
av_log(pb, AV_LOG_WARNING,
"unknown subformat:"FF_PRI_GUID"\n",
FF_ARG_GUID(subformat));
}
}
| true | FFmpeg | 7f549b8338ed3775fec4bf10421ff5744e5866dd | static void parse_waveformatex(AVIOContext *pb, AVCodecParameters *par)
{
ff_asf_guid subformat;
par->bits_per_coded_sample = avio_rl16(pb);
par->channel_layout = avio_rl32(pb);
ff_get_guid(pb, &subformat);
if (!memcmp(subformat + 4,
(const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
par->codec_tag = AV_RL32(subformat);
par->codec_id = ff_wav_codec_get_id(par->codec_tag,
par->bits_per_coded_sample);
} else {
par->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);
if (!par->codec_id)
av_log(pb, AV_LOG_WARNING,
"unknown subformat:"FF_PRI_GUID"\n",
FF_ARG_GUID(subformat));
}
}
| {
"code": [
" par->bits_per_coded_sample = avio_rl16(pb);"
],
"line_no": [
7
]
} | static void FUNC_0(AVIOContext *VAR_0, AVCodecParameters *VAR_1)
{
ff_asf_guid subformat;
VAR_1->bits_per_coded_sample = avio_rl16(VAR_0);
VAR_1->channel_layout = avio_rl32(VAR_0);
ff_get_guid(VAR_0, &subformat);
if (!memcmp(subformat + 4,
(const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
VAR_1->codec_tag = AV_RL32(subformat);
VAR_1->codec_id = ff_wav_codec_get_id(VAR_1->codec_tag,
VAR_1->bits_per_coded_sample);
} else {
VAR_1->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);
if (!VAR_1->codec_id)
av_log(VAR_0, AV_LOG_WARNING,
"unknown subformat:"FF_PRI_GUID"\n",
FF_ARG_GUID(subformat));
}
}
| [
"static void FUNC_0(AVIOContext *VAR_0, AVCodecParameters *VAR_1)\n{",
"ff_asf_guid subformat;",
"VAR_1->bits_per_coded_sample = avio_rl16(VAR_0);",
"VAR_1->channel_layout = avio_rl32(VAR_0);",
"ff_get_guid(VAR_0, &subformat);",
"if (!memcmp(subformat + 4,\n(const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {",
"VAR_1->codec_tag = AV_RL32(subformat);",
"VAR_1->codec_id = ff_wav_codec_get_id(VAR_1->codec_tag,\nVAR_1->bits_per_coded_sample);",
"} else {",
"VAR_1->codec_id = ff_codec_guid_get_id(ff_codec_wav_guids, subformat);",
"if (!VAR_1->codec_id)\nav_log(VAR_0, AV_LOG_WARNING,\n\"unknown subformat:\"FF_PRI_GUID\"\\n\",\nFF_ARG_GUID(subformat));",
"}",
"}"
]
| [
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15,
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
29,
31,
33,
35
],
[
37
],
[
39
]
]
|
12,784 | static void ict_int(void *_src0, void *_src1, void *_src2, int csize)
{
int32_t *src0 = _src0, *src1 = _src1, *src2 = _src2;
int32_t i0, i1, i2;
int i;
for (i = 0; i < csize; i++) {
i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16);
i1 = *src0 - (((i_ict_params[1] * *src1) + (1 << 15)) >> 16)
- (((i_ict_params[2] * *src2) + (1 << 15)) >> 16);
i2 = *src0 + (((i_ict_params[3] * *src1) + (1 << 15)) >> 16);
*src0++ = i0;
*src1++ = i1;
*src2++ = i2;
}
}
| true | FFmpeg | c746f92a8e03d5a062359fba836eba4b3530687e | static void ict_int(void *_src0, void *_src1, void *_src2, int csize)
{
int32_t *src0 = _src0, *src1 = _src1, *src2 = _src2;
int32_t i0, i1, i2;
int i;
for (i = 0; i < csize; i++) {
i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16);
i1 = *src0 - (((i_ict_params[1] * *src1) + (1 << 15)) >> 16)
- (((i_ict_params[2] * *src2) + (1 << 15)) >> 16);
i2 = *src0 + (((i_ict_params[3] * *src1) + (1 << 15)) >> 16);
*src0++ = i0;
*src1++ = i1;
*src2++ = i2;
}
}
| {
"code": [
" i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16);",
" i2 = *src0 + (((i_ict_params[3] * *src1) + (1 << 15)) >> 16);"
],
"line_no": [
15,
21
]
} | static void FUNC_0(void *VAR_0, void *VAR_1, void *VAR_2, int VAR_3)
{
int32_t *src0 = VAR_0, *src1 = VAR_1, *src2 = VAR_2;
int32_t i0, i1, i2;
int VAR_4;
for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {
i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16);
i1 = *src0 - (((i_ict_params[1] * *src1) + (1 << 15)) >> 16)
- (((i_ict_params[2] * *src2) + (1 << 15)) >> 16);
i2 = *src0 + (((i_ict_params[3] * *src1) + (1 << 15)) >> 16);
*src0++ = i0;
*src1++ = i1;
*src2++ = i2;
}
}
| [
"static void FUNC_0(void *VAR_0, void *VAR_1, void *VAR_2, int VAR_3)\n{",
"int32_t *src0 = VAR_0, *src1 = VAR_1, *src2 = VAR_2;",
"int32_t i0, i1, i2;",
"int VAR_4;",
"for (VAR_4 = 0; VAR_4 < VAR_3; VAR_4++) {",
"i0 = *src0 + (((i_ict_params[0] * *src2) + (1 << 15)) >> 16);",
"i1 = *src0 - (((i_ict_params[1] * *src1) + (1 << 15)) >> 16)\n- (((i_ict_params[2] * *src2) + (1 << 15)) >> 16);",
"i2 = *src0 + (((i_ict_params[3] * *src1) + (1 << 15)) >> 16);",
"*src0++ = i0;",
"*src1++ = i1;",
"*src2++ = i2;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
]
]
|
12,788 | static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name,
int flags)
{
int ret = -1;
if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
int map_dirfd;
if (flags == AT_REMOVEDIR) {
int fd;
fd = openat(dirfd, name, O_RDONLY | O_DIRECTORY | O_PATH);
if (fd == -1) {
goto err_out;
}
/*
* If directory remove .virtfs_metadata contained in the
* directory
*/
ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR);
close_preserve_errno(fd);
if (ret < 0 && errno != ENOENT) {
/*
* We didn't had the .virtfs_metadata file. May be file created
* in non-mapped mode ?. Ignore ENOENT.
*/
goto err_out;
}
}
/*
* Now remove the name from parent directory
* .virtfs_metadata directory.
*/
map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
ret = unlinkat(map_dirfd, name, 0);
close_preserve_errno(map_dirfd);
if (ret < 0 && errno != ENOENT) {
/*
* We didn't had the .virtfs_metadata file. May be file created
* in non-mapped mode ?. Ignore ENOENT.
*/
goto err_out;
}
}
ret = unlinkat(dirfd, name, flags);
err_out:
return ret;
}
| true | qemu | b003fc0d8aa5e7060dbf7e5862b8013c73857c7f | static int local_unlinkat_common(FsContext *ctx, int dirfd, const char *name,
int flags)
{
int ret = -1;
if (ctx->export_flags & V9FS_SM_MAPPED_FILE) {
int map_dirfd;
if (flags == AT_REMOVEDIR) {
int fd;
fd = openat(dirfd, name, O_RDONLY | O_DIRECTORY | O_PATH);
if (fd == -1) {
goto err_out;
}
ret = unlinkat(fd, VIRTFS_META_DIR, AT_REMOVEDIR);
close_preserve_errno(fd);
if (ret < 0 && errno != ENOENT) {
goto err_out;
}
}
map_dirfd = openat_dir(dirfd, VIRTFS_META_DIR);
ret = unlinkat(map_dirfd, name, 0);
close_preserve_errno(map_dirfd);
if (ret < 0 && errno != ENOENT) {
goto err_out;
}
}
ret = unlinkat(dirfd, name, flags);
err_out:
return ret;
}
| {
"code": [
" fd = openat(dirfd, name, O_RDONLY | O_DIRECTORY | O_PATH);"
],
"line_no": [
23
]
} | static int FUNC_0(FsContext *VAR_0, int VAR_1, const char *VAR_2,
int VAR_3)
{
int VAR_4 = -1;
if (VAR_0->export_flags & V9FS_SM_MAPPED_FILE) {
int VAR_5;
if (VAR_3 == AT_REMOVEDIR) {
int VAR_6;
VAR_6 = openat(VAR_1, VAR_2, O_RDONLY | O_DIRECTORY | O_PATH);
if (VAR_6 == -1) {
goto err_out;
}
VAR_4 = unlinkat(VAR_6, VIRTFS_META_DIR, AT_REMOVEDIR);
close_preserve_errno(VAR_6);
if (VAR_4 < 0 && errno != ENOENT) {
goto err_out;
}
}
VAR_5 = openat_dir(VAR_1, VIRTFS_META_DIR);
VAR_4 = unlinkat(VAR_5, VAR_2, 0);
close_preserve_errno(VAR_5);
if (VAR_4 < 0 && errno != ENOENT) {
goto err_out;
}
}
VAR_4 = unlinkat(VAR_1, VAR_2, VAR_3);
err_out:
return VAR_4;
}
| [
"static int FUNC_0(FsContext *VAR_0, int VAR_1, const char *VAR_2,\nint VAR_3)\n{",
"int VAR_4 = -1;",
"if (VAR_0->export_flags & V9FS_SM_MAPPED_FILE) {",
"int VAR_5;",
"if (VAR_3 == AT_REMOVEDIR) {",
"int VAR_6;",
"VAR_6 = openat(VAR_1, VAR_2, O_RDONLY | O_DIRECTORY | O_PATH);",
"if (VAR_6 == -1) {",
"goto err_out;",
"}",
"VAR_4 = unlinkat(VAR_6, VIRTFS_META_DIR, AT_REMOVEDIR);",
"close_preserve_errno(VAR_6);",
"if (VAR_4 < 0 && errno != ENOENT) {",
"goto err_out;",
"}",
"}",
"VAR_5 = openat_dir(VAR_1, VIRTFS_META_DIR);",
"VAR_4 = unlinkat(VAR_5, VAR_2, 0);",
"close_preserve_errno(VAR_5);",
"if (VAR_4 < 0 && errno != ENOENT) {",
"goto err_out;",
"}",
"}",
"VAR_4 = unlinkat(VAR_1, VAR_2, VAR_3);",
"err_out:\nreturn VAR_4;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
39
],
[
41
],
[
43
],
[
53
],
[
55
],
[
57
],
[
67
],
[
69
],
[
71
],
[
73
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93,
95
],
[
97
]
]
|
12,790 | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
{
MpegEncContext *s = &v->s;
DSPContext *dsp = &v->s.dsp;
uint8_t *srcY;
int dxy, mx, my, src_x, src_y;
int off;
int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
int v_edge_pos = s->v_edge_pos >> v->field_mode;
if ((!v->field_mode ||
(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
!v->s.last_picture.f.data[0])
mx = s->mv[dir][n][0];
my = s->mv[dir][n][1];
if (!dir) {
if (v->field_mode) {
if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
srcY = s->current_picture.f.data[0];
else
srcY = s->last_picture.f.data[0];
} else
srcY = s->last_picture.f.data[0];
} else
srcY = s->next_picture.f.data[0];
if (v->field_mode) {
if (v->cur_field_type != v->ref_field_type[dir])
my = my - 2 + 4 * v->cur_field_type;
}
if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
int same_count = 0, opp_count = 0, k;
int chosen_mv[2][4][2], f;
int tx, ty;
for (k = 0; k < 4; k++) {
f = v->mv_f[0][s->block_index[k] + v->blocks_off];
chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
opp_count += f;
same_count += 1 - f;
}
f = opp_count > same_count;
switch (f ? opp_count : same_count) {
case 4:
tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
chosen_mv[f][2][0], chosen_mv[f][3][0]);
ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
chosen_mv[f][2][1], chosen_mv[f][3][1]);
break;
case 3:
tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
break;
case 2:
tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
break;
default:
av_assert2(0);
}
s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
for (k = 0; k < 4; k++)
v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
}
if (v->fcm == ILACE_FRAME) { // not sure if needed for other types of picture
int qx, qy;
int width = s->avctx->coded_width;
int height = s->avctx->coded_height >> 1;
qx = (s->mb_x * 16) + (mx >> 2);
qy = (s->mb_y * 8) + (my >> 3);
if (qx < -17)
mx -= 4 * (qx + 17);
else if (qx > width)
mx -= 4 * (qx - width);
if (qy < -18)
my -= 8 * (qy + 18);
else if (qy > height + 1)
my -= 8 * (qy - height - 1);
}
if ((v->fcm == ILACE_FRAME) && fieldmv)
off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
else
off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
if (v->field_mode && v->second_field)
off += s->current_picture_ptr->f.linesize[0];
src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
if (!fieldmv)
src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
else
src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
if (v->profile != PROFILE_ADVANCED) {
src_x = av_clip(src_x, -16, s->mb_width * 16);
src_y = av_clip(src_y, -16, s->mb_height * 16);
} else {
src_x = av_clip(src_x, -17, s->avctx->coded_width);
if (v->fcm == ILACE_FRAME) {
if (src_y & 1)
src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
else
src_y = av_clip(src_y, -18, s->avctx->coded_height);
} else {
src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
}
}
srcY += src_y * s->linesize + src_x;
if (v->field_mode && v->ref_field_type[dir])
srcY += s->current_picture_ptr->f.linesize[0];
if (fieldmv && !(src_y & 1))
v_edge_pos--;
if (fieldmv && (src_y & 1) && src_y < 4)
src_y--;
if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
|| s->h_edge_pos < 13 || v_edge_pos < 23
|| (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
|| (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
srcY -= s->mspel * (1 + (s->linesize << fieldmv));
/* check emulate edge stride and offset */
s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
src_x - s->mspel, src_y - (s->mspel << fieldmv),
s->h_edge_pos, v_edge_pos);
srcY = s->edge_emu_buffer;
/* if we deal with range reduction we need to scale source blocks */
if (v->rangeredfrm) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = ((src[i] - 128) >> 1) + 128;
src += s->linesize << fieldmv;
}
}
/* if we deal with intensity compensation we need to scale source blocks */
if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = v->luty[src[i]];
src += s->linesize << fieldmv;
}
}
srcY += s->mspel * (1 + (s->linesize << fieldmv));
}
if (s->mspel) {
dxy = ((my & 3) << 2) | (mx & 3);
v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
} else { // hpel mc - always used for luma
dxy = (my & 2) | ((mx & 2) >> 1);
if (!v->rnd)
dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
else
dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
}
} | true | FFmpeg | 3a04c18d899d278eea551c216e5117974063062b | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir)
{
MpegEncContext *s = &v->s;
DSPContext *dsp = &v->s.dsp;
uint8_t *srcY;
int dxy, mx, my, src_x, src_y;
int off;
int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
int v_edge_pos = s->v_edge_pos >> v->field_mode;
if ((!v->field_mode ||
(v->ref_field_type[dir] == 1 && v->cur_field_type == 1)) &&
!v->s.last_picture.f.data[0])
mx = s->mv[dir][n][0];
my = s->mv[dir][n][1];
if (!dir) {
if (v->field_mode) {
if ((v->cur_field_type != v->ref_field_type[dir]) && v->second_field)
srcY = s->current_picture.f.data[0];
else
srcY = s->last_picture.f.data[0];
} else
srcY = s->last_picture.f.data[0];
} else
srcY = s->next_picture.f.data[0];
if (v->field_mode) {
if (v->cur_field_type != v->ref_field_type[dir])
my = my - 2 + 4 * v->cur_field_type;
}
if (s->pict_type == AV_PICTURE_TYPE_P && n == 3 && v->field_mode) {
int same_count = 0, opp_count = 0, k;
int chosen_mv[2][4][2], f;
int tx, ty;
for (k = 0; k < 4; k++) {
f = v->mv_f[0][s->block_index[k] + v->blocks_off];
chosen_mv[f][f ? opp_count : same_count][0] = s->mv[0][k][0];
chosen_mv[f][f ? opp_count : same_count][1] = s->mv[0][k][1];
opp_count += f;
same_count += 1 - f;
}
f = opp_count > same_count;
switch (f ? opp_count : same_count) {
case 4:
tx = median4(chosen_mv[f][0][0], chosen_mv[f][1][0],
chosen_mv[f][2][0], chosen_mv[f][3][0]);
ty = median4(chosen_mv[f][0][1], chosen_mv[f][1][1],
chosen_mv[f][2][1], chosen_mv[f][3][1]);
break;
case 3:
tx = mid_pred(chosen_mv[f][0][0], chosen_mv[f][1][0], chosen_mv[f][2][0]);
ty = mid_pred(chosen_mv[f][0][1], chosen_mv[f][1][1], chosen_mv[f][2][1]);
break;
case 2:
tx = (chosen_mv[f][0][0] + chosen_mv[f][1][0]) / 2;
ty = (chosen_mv[f][0][1] + chosen_mv[f][1][1]) / 2;
break;
default:
av_assert2(0);
}
s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][0] = tx;
s->current_picture.f.motion_val[1][s->block_index[0] + v->blocks_off][1] = ty;
for (k = 0; k < 4; k++)
v->mv_f[1][s->block_index[k] + v->blocks_off] = f;
}
if (v->fcm == ILACE_FRAME) {
int qx, qy;
int width = s->avctx->coded_width;
int height = s->avctx->coded_height >> 1;
qx = (s->mb_x * 16) + (mx >> 2);
qy = (s->mb_y * 8) + (my >> 3);
if (qx < -17)
mx -= 4 * (qx + 17);
else if (qx > width)
mx -= 4 * (qx - width);
if (qy < -18)
my -= 8 * (qy + 18);
else if (qy > height + 1)
my -= 8 * (qy - height - 1);
}
if ((v->fcm == ILACE_FRAME) && fieldmv)
off = ((n > 1) ? s->linesize : 0) + (n & 1) * 8;
else
off = s->linesize * 4 * (n & 2) + (n & 1) * 8;
if (v->field_mode && v->second_field)
off += s->current_picture_ptr->f.linesize[0];
src_x = s->mb_x * 16 + (n & 1) * 8 + (mx >> 2);
if (!fieldmv)
src_y = s->mb_y * 16 + (n & 2) * 4 + (my >> 2);
else
src_y = s->mb_y * 16 + ((n > 1) ? 1 : 0) + (my >> 2);
if (v->profile != PROFILE_ADVANCED) {
src_x = av_clip(src_x, -16, s->mb_width * 16);
src_y = av_clip(src_y, -16, s->mb_height * 16);
} else {
src_x = av_clip(src_x, -17, s->avctx->coded_width);
if (v->fcm == ILACE_FRAME) {
if (src_y & 1)
src_y = av_clip(src_y, -17, s->avctx->coded_height + 1);
else
src_y = av_clip(src_y, -18, s->avctx->coded_height);
} else {
src_y = av_clip(src_y, -18, s->avctx->coded_height + 1);
}
}
srcY += src_y * s->linesize + src_x;
if (v->field_mode && v->ref_field_type[dir])
srcY += s->current_picture_ptr->f.linesize[0];
if (fieldmv && !(src_y & 1))
v_edge_pos--;
if (fieldmv && (src_y & 1) && src_y < 4)
src_y--;
if (v->rangeredfrm || (v->mv_mode == MV_PMODE_INTENSITY_COMP)
|| s->h_edge_pos < 13 || v_edge_pos < 23
|| (unsigned)(src_x - s->mspel) > s->h_edge_pos - (mx & 3) - 8 - s->mspel * 2
|| (unsigned)(src_y - (s->mspel << fieldmv)) > v_edge_pos - (my & 3) - ((8 + s->mspel * 2) << fieldmv)) {
srcY -= s->mspel * (1 + (s->linesize << fieldmv));
s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
9 + s->mspel * 2, (9 + s->mspel * 2) << fieldmv,
src_x - s->mspel, src_y - (s->mspel << fieldmv),
s->h_edge_pos, v_edge_pos);
srcY = s->edge_emu_buffer;
if (v->rangeredfrm) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = ((src[i] - 128) >> 1) + 128;
src += s->linesize << fieldmv;
}
}
if (v->mv_mode == MV_PMODE_INTENSITY_COMP) {
int i, j;
uint8_t *src;
src = srcY;
for (j = 0; j < 9 + s->mspel * 2; j++) {
for (i = 0; i < 9 + s->mspel * 2; i++)
src[i] = v->luty[src[i]];
src += s->linesize << fieldmv;
}
}
srcY += s->mspel * (1 + (s->linesize << fieldmv));
}
if (s->mspel) {
dxy = ((my & 3) << 2) | (mx & 3);
v->vc1dsp.put_vc1_mspel_pixels_tab[dxy](s->dest[0] + off, srcY, s->linesize << fieldmv, v->rnd);
} else {
dxy = (my & 2) | ((mx & 2) >> 1);
if (!v->rnd)
dsp->put_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
else
dsp->put_no_rnd_pixels_tab[1][dxy](s->dest[0] + off, srcY, s->linesize, 8);
}
} | {
"code": [],
"line_no": []
} | static void FUNC_0(VC1Context *VAR_0, int VAR_1, int VAR_2)
{
MpegEncContext *s = &VAR_0->s;
DSPContext *dsp = &VAR_0->s.dsp;
uint8_t *srcY;
int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;
int VAR_8;
int VAR_9 = (VAR_0->fcm == ILACE_FRAME) ? VAR_0->blk_mv_type[s->block_index[VAR_1]] : 0;
int VAR_10 = s->VAR_10 >> VAR_0->field_mode;
if ((!VAR_0->field_mode ||
(VAR_0->ref_field_type[VAR_2] == 1 && VAR_0->cur_field_type == 1)) &&
!VAR_0->s.last_picture.VAR_15.data[0])
VAR_4 = s->mv[VAR_2][VAR_1][0];
VAR_5 = s->mv[VAR_2][VAR_1][1];
if (!VAR_2) {
if (VAR_0->field_mode) {
if ((VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2]) && VAR_0->second_field)
srcY = s->current_picture.VAR_15.data[0];
else
srcY = s->last_picture.VAR_15.data[0];
} else
srcY = s->last_picture.VAR_15.data[0];
} else
srcY = s->next_picture.VAR_15.data[0];
if (VAR_0->field_mode) {
if (VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2])
VAR_5 = VAR_5 - 2 + 4 * VAR_0->cur_field_type;
}
if (s->pict_type == AV_PICTURE_TYPE_P && VAR_1 == 3 && VAR_0->field_mode) {
int VAR_11 = 0, VAR_12 = 0, VAR_13;
int VAR_14[2][4][2], VAR_15;
int VAR_16, VAR_17;
for (VAR_13 = 0; VAR_13 < 4; VAR_13++) {
VAR_15 = VAR_0->mv_f[0][s->block_index[VAR_13] + VAR_0->blocks_off];
VAR_14[VAR_15][VAR_15 ? VAR_12 : VAR_11][0] = s->mv[0][VAR_13][0];
VAR_14[VAR_15][VAR_15 ? VAR_12 : VAR_11][1] = s->mv[0][VAR_13][1];
VAR_12 += VAR_15;
VAR_11 += 1 - VAR_15;
}
VAR_15 = VAR_12 > VAR_11;
switch (VAR_15 ? VAR_12 : VAR_11) {
case 4:
VAR_16 = median4(VAR_14[VAR_15][0][0], VAR_14[VAR_15][1][0],
VAR_14[VAR_15][2][0], VAR_14[VAR_15][3][0]);
VAR_17 = median4(VAR_14[VAR_15][0][1], VAR_14[VAR_15][1][1],
VAR_14[VAR_15][2][1], VAR_14[VAR_15][3][1]);
break;
case 3:
VAR_16 = mid_pred(VAR_14[VAR_15][0][0], VAR_14[VAR_15][1][0], VAR_14[VAR_15][2][0]);
VAR_17 = mid_pred(VAR_14[VAR_15][0][1], VAR_14[VAR_15][1][1], VAR_14[VAR_15][2][1]);
break;
case 2:
VAR_16 = (VAR_14[VAR_15][0][0] + VAR_14[VAR_15][1][0]) / 2;
VAR_17 = (VAR_14[VAR_15][0][1] + VAR_14[VAR_15][1][1]) / 2;
break;
default:
av_assert2(0);
}
s->current_picture.VAR_15.motion_val[1][s->block_index[0] + VAR_0->blocks_off][0] = VAR_16;
s->current_picture.VAR_15.motion_val[1][s->block_index[0] + VAR_0->blocks_off][1] = VAR_17;
for (VAR_13 = 0; VAR_13 < 4; VAR_13++)
VAR_0->mv_f[1][s->block_index[VAR_13] + VAR_0->blocks_off] = VAR_15;
}
if (VAR_0->fcm == ILACE_FRAME) {
int VAR_18, VAR_19;
int VAR_20 = s->avctx->coded_width;
int VAR_21 = s->avctx->coded_height >> 1;
VAR_18 = (s->mb_x * 16) + (VAR_4 >> 2);
VAR_19 = (s->mb_y * 8) + (VAR_5 >> 3);
if (VAR_18 < -17)
VAR_4 -= 4 * (VAR_18 + 17);
else if (VAR_18 > VAR_20)
VAR_4 -= 4 * (VAR_18 - VAR_20);
if (VAR_19 < -18)
VAR_5 -= 8 * (VAR_19 + 18);
else if (VAR_19 > VAR_21 + 1)
VAR_5 -= 8 * (VAR_19 - VAR_21 - 1);
}
if ((VAR_0->fcm == ILACE_FRAME) && VAR_9)
VAR_8 = ((VAR_1 > 1) ? s->linesize : 0) + (VAR_1 & 1) * 8;
else
VAR_8 = s->linesize * 4 * (VAR_1 & 2) + (VAR_1 & 1) * 8;
if (VAR_0->field_mode && VAR_0->second_field)
VAR_8 += s->current_picture_ptr->VAR_15.linesize[0];
VAR_6 = s->mb_x * 16 + (VAR_1 & 1) * 8 + (VAR_4 >> 2);
if (!VAR_9)
VAR_7 = s->mb_y * 16 + (VAR_1 & 2) * 4 + (VAR_5 >> 2);
else
VAR_7 = s->mb_y * 16 + ((VAR_1 > 1) ? 1 : 0) + (VAR_5 >> 2);
if (VAR_0->profile != PROFILE_ADVANCED) {
VAR_6 = av_clip(VAR_6, -16, s->mb_width * 16);
VAR_7 = av_clip(VAR_7, -16, s->mb_height * 16);
} else {
VAR_6 = av_clip(VAR_6, -17, s->avctx->coded_width);
if (VAR_0->fcm == ILACE_FRAME) {
if (VAR_7 & 1)
VAR_7 = av_clip(VAR_7, -17, s->avctx->coded_height + 1);
else
VAR_7 = av_clip(VAR_7, -18, s->avctx->coded_height);
} else {
VAR_7 = av_clip(VAR_7, -18, s->avctx->coded_height + 1);
}
}
srcY += VAR_7 * s->linesize + VAR_6;
if (VAR_0->field_mode && VAR_0->ref_field_type[VAR_2])
srcY += s->current_picture_ptr->VAR_15.linesize[0];
if (VAR_9 && !(VAR_7 & 1))
VAR_10--;
if (VAR_9 && (VAR_7 & 1) && VAR_7 < 4)
VAR_7--;
if (VAR_0->rangeredfrm || (VAR_0->mv_mode == MV_PMODE_INTENSITY_COMP)
|| s->h_edge_pos < 13 || VAR_10 < 23
|| (unsigned)(VAR_6 - s->mspel) > s->h_edge_pos - (VAR_4 & 3) - 8 - s->mspel * 2
|| (unsigned)(VAR_7 - (s->mspel << VAR_9)) > VAR_10 - (VAR_5 & 3) - ((8 + s->mspel * 2) << VAR_9)) {
srcY -= s->mspel * (1 + (s->linesize << VAR_9));
s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,
9 + s->mspel * 2, (9 + s->mspel * 2) << VAR_9,
VAR_6 - s->mspel, VAR_7 - (s->mspel << VAR_9),
s->h_edge_pos, VAR_10);
srcY = s->edge_emu_buffer;
if (VAR_0->rangeredfrm) {
int VAR_24, VAR_24;
uint8_t *src;
src = srcY;
for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++) {
for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++)
src[VAR_24] = ((src[VAR_24] - 128) >> 1) + 128;
src += s->linesize << VAR_9;
}
}
if (VAR_0->mv_mode == MV_PMODE_INTENSITY_COMP) {
int VAR_24, VAR_24;
uint8_t *src;
src = srcY;
for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++) {
for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++)
src[VAR_24] = VAR_0->luty[src[VAR_24]];
src += s->linesize << VAR_9;
}
}
srcY += s->mspel * (1 + (s->linesize << VAR_9));
}
if (s->mspel) {
VAR_3 = ((VAR_5 & 3) << 2) | (VAR_4 & 3);
VAR_0->vc1dsp.put_vc1_mspel_pixels_tab[VAR_3](s->dest[0] + VAR_8, srcY, s->linesize << VAR_9, VAR_0->rnd);
} else {
VAR_3 = (VAR_5 & 2) | ((VAR_4 & 2) >> 1);
if (!VAR_0->rnd)
dsp->put_pixels_tab[1][VAR_3](s->dest[0] + VAR_8, srcY, s->linesize, 8);
else
dsp->put_no_rnd_pixels_tab[1][VAR_3](s->dest[0] + VAR_8, srcY, s->linesize, 8);
}
} | [
"static void FUNC_0(VC1Context *VAR_0, int VAR_1, int VAR_2)\n{",
"MpegEncContext *s = &VAR_0->s;",
"DSPContext *dsp = &VAR_0->s.dsp;",
"uint8_t *srcY;",
"int VAR_3, VAR_4, VAR_5, VAR_6, VAR_7;",
"int VAR_8;",
"int VAR_9 = (VAR_0->fcm == ILACE_FRAME) ? VAR_0->blk_mv_type[s->block_index[VAR_1]] : 0;",
"int VAR_10 = s->VAR_10 >> VAR_0->field_mode;",
"if ((!VAR_0->field_mode ||\n(VAR_0->ref_field_type[VAR_2] == 1 && VAR_0->cur_field_type == 1)) &&\n!VAR_0->s.last_picture.VAR_15.data[0])\nVAR_4 = s->mv[VAR_2][VAR_1][0];",
"VAR_5 = s->mv[VAR_2][VAR_1][1];",
"if (!VAR_2) {",
"if (VAR_0->field_mode) {",
"if ((VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2]) && VAR_0->second_field)\nsrcY = s->current_picture.VAR_15.data[0];",
"else\nsrcY = s->last_picture.VAR_15.data[0];",
"} else",
"srcY = s->last_picture.VAR_15.data[0];",
"} else",
"srcY = s->next_picture.VAR_15.data[0];",
"if (VAR_0->field_mode) {",
"if (VAR_0->cur_field_type != VAR_0->ref_field_type[VAR_2])\nVAR_5 = VAR_5 - 2 + 4 * VAR_0->cur_field_type;",
"}",
"if (s->pict_type == AV_PICTURE_TYPE_P && VAR_1 == 3 && VAR_0->field_mode) {",
"int VAR_11 = 0, VAR_12 = 0, VAR_13;",
"int VAR_14[2][4][2], VAR_15;",
"int VAR_16, VAR_17;",
"for (VAR_13 = 0; VAR_13 < 4; VAR_13++) {",
"VAR_15 = VAR_0->mv_f[0][s->block_index[VAR_13] + VAR_0->blocks_off];",
"VAR_14[VAR_15][VAR_15 ? VAR_12 : VAR_11][0] = s->mv[0][VAR_13][0];",
"VAR_14[VAR_15][VAR_15 ? VAR_12 : VAR_11][1] = s->mv[0][VAR_13][1];",
"VAR_12 += VAR_15;",
"VAR_11 += 1 - VAR_15;",
"}",
"VAR_15 = VAR_12 > VAR_11;",
"switch (VAR_15 ? VAR_12 : VAR_11) {",
"case 4:\nVAR_16 = median4(VAR_14[VAR_15][0][0], VAR_14[VAR_15][1][0],\nVAR_14[VAR_15][2][0], VAR_14[VAR_15][3][0]);",
"VAR_17 = median4(VAR_14[VAR_15][0][1], VAR_14[VAR_15][1][1],\nVAR_14[VAR_15][2][1], VAR_14[VAR_15][3][1]);",
"break;",
"case 3:\nVAR_16 = mid_pred(VAR_14[VAR_15][0][0], VAR_14[VAR_15][1][0], VAR_14[VAR_15][2][0]);",
"VAR_17 = mid_pred(VAR_14[VAR_15][0][1], VAR_14[VAR_15][1][1], VAR_14[VAR_15][2][1]);",
"break;",
"case 2:\nVAR_16 = (VAR_14[VAR_15][0][0] + VAR_14[VAR_15][1][0]) / 2;",
"VAR_17 = (VAR_14[VAR_15][0][1] + VAR_14[VAR_15][1][1]) / 2;",
"break;",
"default:\nav_assert2(0);",
"}",
"s->current_picture.VAR_15.motion_val[1][s->block_index[0] + VAR_0->blocks_off][0] = VAR_16;",
"s->current_picture.VAR_15.motion_val[1][s->block_index[0] + VAR_0->blocks_off][1] = VAR_17;",
"for (VAR_13 = 0; VAR_13 < 4; VAR_13++)",
"VAR_0->mv_f[1][s->block_index[VAR_13] + VAR_0->blocks_off] = VAR_15;",
"}",
"if (VAR_0->fcm == ILACE_FRAME) {",
"int VAR_18, VAR_19;",
"int VAR_20 = s->avctx->coded_width;",
"int VAR_21 = s->avctx->coded_height >> 1;",
"VAR_18 = (s->mb_x * 16) + (VAR_4 >> 2);",
"VAR_19 = (s->mb_y * 8) + (VAR_5 >> 3);",
"if (VAR_18 < -17)\nVAR_4 -= 4 * (VAR_18 + 17);",
"else if (VAR_18 > VAR_20)\nVAR_4 -= 4 * (VAR_18 - VAR_20);",
"if (VAR_19 < -18)\nVAR_5 -= 8 * (VAR_19 + 18);",
"else if (VAR_19 > VAR_21 + 1)\nVAR_5 -= 8 * (VAR_19 - VAR_21 - 1);",
"}",
"if ((VAR_0->fcm == ILACE_FRAME) && VAR_9)\nVAR_8 = ((VAR_1 > 1) ? s->linesize : 0) + (VAR_1 & 1) * 8;",
"else\nVAR_8 = s->linesize * 4 * (VAR_1 & 2) + (VAR_1 & 1) * 8;",
"if (VAR_0->field_mode && VAR_0->second_field)\nVAR_8 += s->current_picture_ptr->VAR_15.linesize[0];",
"VAR_6 = s->mb_x * 16 + (VAR_1 & 1) * 8 + (VAR_4 >> 2);",
"if (!VAR_9)\nVAR_7 = s->mb_y * 16 + (VAR_1 & 2) * 4 + (VAR_5 >> 2);",
"else\nVAR_7 = s->mb_y * 16 + ((VAR_1 > 1) ? 1 : 0) + (VAR_5 >> 2);",
"if (VAR_0->profile != PROFILE_ADVANCED) {",
"VAR_6 = av_clip(VAR_6, -16, s->mb_width * 16);",
"VAR_7 = av_clip(VAR_7, -16, s->mb_height * 16);",
"} else {",
"VAR_6 = av_clip(VAR_6, -17, s->avctx->coded_width);",
"if (VAR_0->fcm == ILACE_FRAME) {",
"if (VAR_7 & 1)\nVAR_7 = av_clip(VAR_7, -17, s->avctx->coded_height + 1);",
"else\nVAR_7 = av_clip(VAR_7, -18, s->avctx->coded_height);",
"} else {",
"VAR_7 = av_clip(VAR_7, -18, s->avctx->coded_height + 1);",
"}",
"}",
"srcY += VAR_7 * s->linesize + VAR_6;",
"if (VAR_0->field_mode && VAR_0->ref_field_type[VAR_2])\nsrcY += s->current_picture_ptr->VAR_15.linesize[0];",
"if (VAR_9 && !(VAR_7 & 1))\nVAR_10--;",
"if (VAR_9 && (VAR_7 & 1) && VAR_7 < 4)\nVAR_7--;",
"if (VAR_0->rangeredfrm || (VAR_0->mv_mode == MV_PMODE_INTENSITY_COMP)\n|| s->h_edge_pos < 13 || VAR_10 < 23\n|| (unsigned)(VAR_6 - s->mspel) > s->h_edge_pos - (VAR_4 & 3) - 8 - s->mspel * 2\n|| (unsigned)(VAR_7 - (s->mspel << VAR_9)) > VAR_10 - (VAR_5 & 3) - ((8 + s->mspel * 2) << VAR_9)) {",
"srcY -= s->mspel * (1 + (s->linesize << VAR_9));",
"s->dsp.emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize,\n9 + s->mspel * 2, (9 + s->mspel * 2) << VAR_9,\nVAR_6 - s->mspel, VAR_7 - (s->mspel << VAR_9),\ns->h_edge_pos, VAR_10);",
"srcY = s->edge_emu_buffer;",
"if (VAR_0->rangeredfrm) {",
"int VAR_24, VAR_24;",
"uint8_t *src;",
"src = srcY;",
"for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++) {",
"for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++)",
"src[VAR_24] = ((src[VAR_24] - 128) >> 1) + 128;",
"src += s->linesize << VAR_9;",
"}",
"}",
"if (VAR_0->mv_mode == MV_PMODE_INTENSITY_COMP) {",
"int VAR_24, VAR_24;",
"uint8_t *src;",
"src = srcY;",
"for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++) {",
"for (VAR_24 = 0; VAR_24 < 9 + s->mspel * 2; VAR_24++)",
"src[VAR_24] = VAR_0->luty[src[VAR_24]];",
"src += s->linesize << VAR_9;",
"}",
"}",
"srcY += s->mspel * (1 + (s->linesize << VAR_9));",
"}",
"if (s->mspel) {",
"VAR_3 = ((VAR_5 & 3) << 2) | (VAR_4 & 3);",
"VAR_0->vc1dsp.put_vc1_mspel_pixels_tab[VAR_3](s->dest[0] + VAR_8, srcY, s->linesize << VAR_9, VAR_0->rnd);",
"} else {",
"VAR_3 = (VAR_5 & 2) | ((VAR_4 & 2) >> 1);",
"if (!VAR_0->rnd)\ndsp->put_pixels_tab[1][VAR_3](s->dest[0] + VAR_8, srcY, s->linesize, 8);",
"else\ndsp->put_no_rnd_pixels_tab[1][VAR_3](s->dest[0] + VAR_8, srcY, s->linesize, 8);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10,
11,
12,
13
],
[
14
],
[
15
],
[
16
],
[
17,
18
],
[
19,
20
],
[
21
],
[
22
],
[
23
],
[
24
],
[
25
],
[
26,
27
],
[
28
],
[
29
],
[
30
],
[
31
],
[
32
],
[
33
],
[
34
],
[
35
],
[
36
],
[
37
],
[
38
],
[
39
],
[
40
],
[
41
],
[
42,
43,
44
],
[
45,
46
],
[
47
],
[
48,
49
],
[
50
],
[
51
],
[
52,
53
],
[
54
],
[
55
],
[
56,
57
],
[
58
],
[
59
],
[
60
],
[
61
],
[
62
],
[
63
],
[
64
],
[
65
],
[
66
],
[
67
],
[
68
],
[
69
],
[
70,
71
],
[
72,
73
],
[
74,
75
],
[
76,
77
],
[
78
],
[
79,
80
],
[
81,
82
],
[
83,
84
],
[
85
],
[
86,
87
],
[
88,
89
],
[
90
],
[
91
],
[
92
],
[
93
],
[
94
],
[
95
],
[
96,
97
],
[
98,
99
],
[
100
],
[
101
],
[
102
],
[
103
],
[
104
],
[
105,
106
],
[
107,
108
],
[
109,
110
],
[
111,
112,
113,
114
],
[
115
],
[
117,
118,
119,
120
],
[
121
],
[
123
],
[
124
],
[
125
],
[
126
],
[
127
],
[
128
],
[
129
],
[
130
],
[
131
],
[
132
],
[
134
],
[
135
],
[
136
],
[
137
],
[
138
],
[
139
],
[
140
],
[
141
],
[
142
],
[
143
],
[
144
],
[
145
],
[
146
],
[
147
],
[
148
],
[
149
],
[
150
],
[
151,
152
],
[
153,
154
],
[
155
],
[
156
]
]
|
12,791 | int main(int argc, char **argv)
{
int ret = EXIT_SUCCESS;
GAState *s = g_new0(GAState, 1);
GAConfig *config = g_new0(GAConfig, 1);
config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
module_call_init(MODULE_INIT_QAPI);
init_dfl_pathnames();
config_load(config);
config_parse(config, argc, argv);
if (config->pid_filepath == NULL) {
config->pid_filepath = g_strdup(dfl_pathnames.pidfile);
if (config->state_dir == NULL) {
config->state_dir = g_strdup(dfl_pathnames.state_dir);
if (config->method == NULL) {
config->method = g_strdup("virtio-serial");
if (config->channel_path == NULL) {
if (strcmp(config->method, "virtio-serial") == 0) {
/* try the default path for the virtio-serial port */
config->channel_path = g_strdup(QGA_VIRTIO_PATH_DEFAULT);
} else if (strcmp(config->method, "isa-serial") == 0) {
/* try the default path for the serial port - COM1 */
config->channel_path = g_strdup(QGA_SERIAL_PATH_DEFAULT);
} else {
g_critical("must specify a path for this channel");
ret = EXIT_FAILURE;
goto end;
s->log_level = config->log_level;
s->log_file = stderr;
#ifdef CONFIG_FSFREEZE
s->fsfreeze_hook = config->fsfreeze_hook;
#endif
s->pstate_filepath = g_strdup_printf("%s/qga.state", config->state_dir);
s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
config->state_dir);
s->frozen = check_is_frozen(s);
if (config->dumpconf) {
config_dump(config);
goto end;
ret = run_agent(s, config);
end:
if (s->command_state) {
ga_command_state_cleanup_all(s->command_state);
ga_command_state_free(s->command_state);
json_message_parser_destroy(&s->parser);
if (s->channel) {
ga_channel_free(s->channel);
g_free(s->pstate_filepath);
g_free(s->state_filepath_isfrozen);
if (config->daemonize) {
unlink(config->pid_filepath);
config_free(config);
return ret;
| true | qemu | 3e3e302ff388669d811077248aee45c45a14168e | int main(int argc, char **argv)
{
int ret = EXIT_SUCCESS;
GAState *s = g_new0(GAState, 1);
GAConfig *config = g_new0(GAConfig, 1);
config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
module_call_init(MODULE_INIT_QAPI);
init_dfl_pathnames();
config_load(config);
config_parse(config, argc, argv);
if (config->pid_filepath == NULL) {
config->pid_filepath = g_strdup(dfl_pathnames.pidfile);
if (config->state_dir == NULL) {
config->state_dir = g_strdup(dfl_pathnames.state_dir);
if (config->method == NULL) {
config->method = g_strdup("virtio-serial");
if (config->channel_path == NULL) {
if (strcmp(config->method, "virtio-serial") == 0) {
config->channel_path = g_strdup(QGA_VIRTIO_PATH_DEFAULT);
} else if (strcmp(config->method, "isa-serial") == 0) {
config->channel_path = g_strdup(QGA_SERIAL_PATH_DEFAULT);
} else {
g_critical("must specify a path for this channel");
ret = EXIT_FAILURE;
goto end;
s->log_level = config->log_level;
s->log_file = stderr;
#ifdef CONFIG_FSFREEZE
s->fsfreeze_hook = config->fsfreeze_hook;
#endif
s->pstate_filepath = g_strdup_printf("%s/qga.state", config->state_dir);
s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
config->state_dir);
s->frozen = check_is_frozen(s);
if (config->dumpconf) {
config_dump(config);
goto end;
ret = run_agent(s, config);
end:
if (s->command_state) {
ga_command_state_cleanup_all(s->command_state);
ga_command_state_free(s->command_state);
json_message_parser_destroy(&s->parser);
if (s->channel) {
ga_channel_free(s->channel);
g_free(s->pstate_filepath);
g_free(s->state_filepath_isfrozen);
if (config->daemonize) {
unlink(config->pid_filepath);
config_free(config);
return ret;
| {
"code": [],
"line_no": []
} | int FUNC_0(int VAR_0, char **VAR_1)
{
int VAR_2 = EXIT_SUCCESS;
GAState *s = g_new0(GAState, 1);
GAConfig *config = g_new0(GAConfig, 1);
config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;
module_call_init(MODULE_INIT_QAPI);
init_dfl_pathnames();
config_load(config);
config_parse(config, VAR_0, VAR_1);
if (config->pid_filepath == NULL) {
config->pid_filepath = g_strdup(dfl_pathnames.pidfile);
if (config->state_dir == NULL) {
config->state_dir = g_strdup(dfl_pathnames.state_dir);
if (config->method == NULL) {
config->method = g_strdup("virtio-serial");
if (config->channel_path == NULL) {
if (strcmp(config->method, "virtio-serial") == 0) {
config->channel_path = g_strdup(QGA_VIRTIO_PATH_DEFAULT);
} else if (strcmp(config->method, "isa-serial") == 0) {
config->channel_path = g_strdup(QGA_SERIAL_PATH_DEFAULT);
} else {
g_critical("must specify a path for this channel");
VAR_2 = EXIT_FAILURE;
goto end;
s->log_level = config->log_level;
s->log_file = stderr;
#ifdef CONFIG_FSFREEZE
s->fsfreeze_hook = config->fsfreeze_hook;
#endif
s->pstate_filepath = g_strdup_printf("%s/qga.state", config->state_dir);
s->state_filepath_isfrozen = g_strdup_printf("%s/qga.state.isfrozen",
config->state_dir);
s->frozen = check_is_frozen(s);
if (config->dumpconf) {
config_dump(config);
goto end;
VAR_2 = run_agent(s, config);
end:
if (s->command_state) {
ga_command_state_cleanup_all(s->command_state);
ga_command_state_free(s->command_state);
json_message_parser_destroy(&s->parser);
if (s->channel) {
ga_channel_free(s->channel);
g_free(s->pstate_filepath);
g_free(s->state_filepath_isfrozen);
if (config->daemonize) {
unlink(config->pid_filepath);
config_free(config);
return VAR_2;
| [
"int FUNC_0(int VAR_0, char **VAR_1)\n{",
"int VAR_2 = EXIT_SUCCESS;",
"GAState *s = g_new0(GAState, 1);",
"GAConfig *config = g_new0(GAConfig, 1);",
"config->log_level = G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL;",
"module_call_init(MODULE_INIT_QAPI);",
"init_dfl_pathnames();",
"config_load(config);",
"config_parse(config, VAR_0, VAR_1);",
"if (config->pid_filepath == NULL) {",
"config->pid_filepath = g_strdup(dfl_pathnames.pidfile);",
"if (config->state_dir == NULL) {",
"config->state_dir = g_strdup(dfl_pathnames.state_dir);",
"if (config->method == NULL) {",
"config->method = g_strdup(\"virtio-serial\");",
"if (config->channel_path == NULL) {",
"if (strcmp(config->method, \"virtio-serial\") == 0) {",
"config->channel_path = g_strdup(QGA_VIRTIO_PATH_DEFAULT);",
"} else if (strcmp(config->method, \"isa-serial\") == 0) {",
"config->channel_path = g_strdup(QGA_SERIAL_PATH_DEFAULT);",
"} else {",
"g_critical(\"must specify a path for this channel\");",
"VAR_2 = EXIT_FAILURE;",
"goto end;",
"s->log_level = config->log_level;",
"s->log_file = stderr;",
"#ifdef CONFIG_FSFREEZE\ns->fsfreeze_hook = config->fsfreeze_hook;",
"#endif\ns->pstate_filepath = g_strdup_printf(\"%s/qga.state\", config->state_dir);",
"s->state_filepath_isfrozen = g_strdup_printf(\"%s/qga.state.isfrozen\",\nconfig->state_dir);",
"s->frozen = check_is_frozen(s);",
"if (config->dumpconf) {",
"config_dump(config);",
"goto end;",
"VAR_2 = run_agent(s, config);",
"end:\nif (s->command_state) {",
"ga_command_state_cleanup_all(s->command_state);",
"ga_command_state_free(s->command_state);",
"json_message_parser_destroy(&s->parser);",
"if (s->channel) {",
"ga_channel_free(s->channel);",
"g_free(s->pstate_filepath);",
"g_free(s->state_filepath_isfrozen);",
"if (config->daemonize) {",
"unlink(config->pid_filepath);",
"config_free(config);",
"return VAR_2;"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
36
],
[
38
],
[
43
],
[
45
],
[
50
],
[
52
],
[
56
],
[
58
],
[
62
],
[
64
],
[
66
],
[
68
],
[
70
],
[
76
],
[
78
],
[
80,
82
],
[
84,
86
],
[
88,
90
],
[
92
],
[
96
],
[
98
],
[
100
],
[
105
],
[
109,
111
],
[
113
],
[
115
],
[
117
],
[
120
],
[
122
],
[
125
],
[
127
],
[
131
],
[
133
],
[
138
],
[
146
]
]
|
12,792 | static int gen_rp_interrupts_init(PCIDevice *d, Error **errp)
{
int rc;
rc = msix_init_exclusive_bar(d, GEN_PCIE_ROOT_PORT_MSIX_NR_VECTOR, 0);
if (rc < 0) {
assert(rc == -ENOTSUP);
error_setg(errp, "Unable to init msix vectors");
} else {
msix_vector_use(d, 0);
}
return rc;
}
| true | qemu | ee640c625e190a0c0e6b8966adc0e4720fb75200 | static int gen_rp_interrupts_init(PCIDevice *d, Error **errp)
{
int rc;
rc = msix_init_exclusive_bar(d, GEN_PCIE_ROOT_PORT_MSIX_NR_VECTOR, 0);
if (rc < 0) {
assert(rc == -ENOTSUP);
error_setg(errp, "Unable to init msix vectors");
} else {
msix_vector_use(d, 0);
}
return rc;
}
| {
"code": [
" rc = msix_init_exclusive_bar(d, GEN_PCIE_ROOT_PORT_MSIX_NR_VECTOR, 0);",
" error_setg(errp, \"Unable to init msix vectors\");"
],
"line_no": [
9,
17
]
} | static int FUNC_0(PCIDevice *VAR_0, Error **VAR_1)
{
int VAR_2;
VAR_2 = msix_init_exclusive_bar(VAR_0, GEN_PCIE_ROOT_PORT_MSIX_NR_VECTOR, 0);
if (VAR_2 < 0) {
assert(VAR_2 == -ENOTSUP);
error_setg(VAR_1, "Unable to init msix vectors");
} else {
msix_vector_use(VAR_0, 0);
}
return VAR_2;
}
| [
"static int FUNC_0(PCIDevice *VAR_0, Error **VAR_1)\n{",
"int VAR_2;",
"VAR_2 = msix_init_exclusive_bar(VAR_0, GEN_PCIE_ROOT_PORT_MSIX_NR_VECTOR, 0);",
"if (VAR_2 < 0) {",
"assert(VAR_2 == -ENOTSUP);",
"error_setg(VAR_1, \"Unable to init msix vectors\");",
"} else {",
"msix_vector_use(VAR_0, 0);",
"}",
"return VAR_2;",
"}"
]
| [
0,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
]
]
|
12,793 | static int vaapi_decode_make_config(AVCodecContext *avctx)
{
VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
AVVAAPIHWConfig *hwconfig = NULL;
AVHWFramesConstraints *constraints = NULL;
VAStatus vas;
int err, i, j;
const AVCodecDescriptor *codec_desc;
VAProfile profile, *profile_list = NULL;
int profile_count, exact_match, alt_profile;
const AVPixFmtDescriptor *sw_desc, *desc;
codec_desc = avcodec_descriptor_get(avctx->codec_id);
if (!codec_desc) {
err = AVERROR(EINVAL);
goto fail;
}
profile_count = vaMaxNumProfiles(ctx->hwctx->display);
profile_list = av_malloc_array(profile_count,
sizeof(VAProfile));
if (!profile_list) {
err = AVERROR(ENOMEM);
goto fail;
}
vas = vaQueryConfigProfiles(ctx->hwctx->display,
profile_list, &profile_count);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to query profiles: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(ENOSYS);
goto fail;
}
profile = VAProfileNone;
exact_match = 0;
for (i = 0; i < FF_ARRAY_ELEMS(vaapi_profile_map); i++) {
int profile_match = 0;
if (avctx->codec_id != vaapi_profile_map[i].codec_id)
continue;
if (avctx->profile == vaapi_profile_map[i].codec_profile ||
vaapi_profile_map[i].codec_profile == FF_PROFILE_UNKNOWN)
profile_match = 1;
profile = vaapi_profile_map[i].va_profile;
for (j = 0; j < profile_count; j++) {
if (profile == profile_list[j]) {
exact_match = profile_match;
break;
}
}
if (j < profile_count) {
if (exact_match)
break;
alt_profile = vaapi_profile_map[i].codec_profile;
}
}
av_freep(&profile_list);
if (profile == VAProfileNone) {
av_log(avctx, AV_LOG_ERROR, "No support for codec %s "
"profile %d.\n", codec_desc->name, avctx->profile);
err = AVERROR(ENOSYS);
goto fail;
}
if (!exact_match) {
if (avctx->hwaccel_flags &
AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH) {
av_log(avctx, AV_LOG_VERBOSE, "Codec %s profile %d not "
"supported for hardware decode.\n",
codec_desc->name, avctx->profile);
av_log(avctx, AV_LOG_WARNING, "Using possibly-"
"incompatible profile %d instead.\n",
alt_profile);
} else {
av_log(avctx, AV_LOG_VERBOSE, "Codec %s profile %d not "
"supported for hardware decode.\n",
codec_desc->name, avctx->profile);
err = AVERROR(EINVAL);
goto fail;
}
}
ctx->va_profile = profile;
ctx->va_entrypoint = VAEntrypointVLD;
vas = vaCreateConfig(ctx->hwctx->display, ctx->va_profile,
ctx->va_entrypoint, NULL, 0,
&ctx->va_config);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create decode "
"configuration: %d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
hwconfig = av_hwdevice_hwconfig_alloc(avctx->hw_device_ctx ?
avctx->hw_device_ctx :
ctx->frames->device_ref);
if (!hwconfig) {
err = AVERROR(ENOMEM);
goto fail;
}
hwconfig->config_id = ctx->va_config;
constraints =
av_hwdevice_get_hwframe_constraints(avctx->hw_device_ctx ?
avctx->hw_device_ctx :
ctx->frames->device_ref,
hwconfig);
if (!constraints) {
err = AVERROR(ENOMEM);
goto fail;
}
if (avctx->coded_width < constraints->min_width ||
avctx->coded_height < constraints->min_height ||
avctx->coded_width > constraints->max_width ||
avctx->coded_height > constraints->max_height) {
av_log(avctx, AV_LOG_ERROR, "Hardware does not support image "
"size %dx%d (constraints: width %d-%d height %d-%d).\n",
avctx->coded_width, avctx->coded_height,
constraints->min_width, constraints->max_width,
constraints->min_height, constraints->max_height);
err = AVERROR(EINVAL);
goto fail;
}
if (!constraints->valid_sw_formats ||
constraints->valid_sw_formats[0] == AV_PIX_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Hardware does not offer any "
"usable surface formats.\n");
err = AVERROR(EINVAL);
goto fail;
}
// Find the first format in the list which matches the expected
// bit depth and subsampling. If none are found (this can happen
// when 10-bit streams are decoded to 8-bit surfaces, for example)
// then just take the first format on the list.
ctx->surface_format = constraints->valid_sw_formats[0];
sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
desc = av_pix_fmt_desc_get(constraints->valid_sw_formats[i]);
if (desc->nb_components != sw_desc->nb_components ||
desc->log2_chroma_w != sw_desc->log2_chroma_w ||
desc->log2_chroma_h != sw_desc->log2_chroma_h)
continue;
for (j = 0; j < desc->nb_components; j++) {
if (desc->comp[j].depth != sw_desc->comp[j].depth)
break;
}
if (j < desc->nb_components)
continue;
ctx->surface_format = constraints->valid_sw_formats[i];
break;
}
// Start with at least four surfaces.
ctx->surface_count = 4;
// Add per-codec number of surfaces used for storing reference frames.
switch (avctx->codec_id) {
case AV_CODEC_ID_H264:
case AV_CODEC_ID_HEVC:
ctx->surface_count += 16;
break;
case AV_CODEC_ID_VP9:
ctx->surface_count += 8;
break;
case AV_CODEC_ID_VP8:
ctx->surface_count += 3;
break;
default:
ctx->surface_count += 2;
}
// Add an additional surface per thread is frame threading is enabled.
if (avctx->active_thread_type & FF_THREAD_FRAME)
ctx->surface_count += avctx->thread_count;
av_hwframe_constraints_free(&constraints);
av_freep(&hwconfig);
return 0;
fail:
av_hwframe_constraints_free(&constraints);
av_freep(&hwconfig);
if (ctx->va_config != VA_INVALID_ID) {
vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
ctx->va_config = VA_INVALID_ID;
}
av_freep(&profile_list);
return err;
}
| false | FFmpeg | b46a77f19ddc4b2b5fa3187835ceb602a5244e24 | static int vaapi_decode_make_config(AVCodecContext *avctx)
{
VAAPIDecodeContext *ctx = avctx->internal->hwaccel_priv_data;
AVVAAPIHWConfig *hwconfig = NULL;
AVHWFramesConstraints *constraints = NULL;
VAStatus vas;
int err, i, j;
const AVCodecDescriptor *codec_desc;
VAProfile profile, *profile_list = NULL;
int profile_count, exact_match, alt_profile;
const AVPixFmtDescriptor *sw_desc, *desc;
codec_desc = avcodec_descriptor_get(avctx->codec_id);
if (!codec_desc) {
err = AVERROR(EINVAL);
goto fail;
}
profile_count = vaMaxNumProfiles(ctx->hwctx->display);
profile_list = av_malloc_array(profile_count,
sizeof(VAProfile));
if (!profile_list) {
err = AVERROR(ENOMEM);
goto fail;
}
vas = vaQueryConfigProfiles(ctx->hwctx->display,
profile_list, &profile_count);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to query profiles: "
"%d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(ENOSYS);
goto fail;
}
profile = VAProfileNone;
exact_match = 0;
for (i = 0; i < FF_ARRAY_ELEMS(vaapi_profile_map); i++) {
int profile_match = 0;
if (avctx->codec_id != vaapi_profile_map[i].codec_id)
continue;
if (avctx->profile == vaapi_profile_map[i].codec_profile ||
vaapi_profile_map[i].codec_profile == FF_PROFILE_UNKNOWN)
profile_match = 1;
profile = vaapi_profile_map[i].va_profile;
for (j = 0; j < profile_count; j++) {
if (profile == profile_list[j]) {
exact_match = profile_match;
break;
}
}
if (j < profile_count) {
if (exact_match)
break;
alt_profile = vaapi_profile_map[i].codec_profile;
}
}
av_freep(&profile_list);
if (profile == VAProfileNone) {
av_log(avctx, AV_LOG_ERROR, "No support for codec %s "
"profile %d.\n", codec_desc->name, avctx->profile);
err = AVERROR(ENOSYS);
goto fail;
}
if (!exact_match) {
if (avctx->hwaccel_flags &
AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH) {
av_log(avctx, AV_LOG_VERBOSE, "Codec %s profile %d not "
"supported for hardware decode.\n",
codec_desc->name, avctx->profile);
av_log(avctx, AV_LOG_WARNING, "Using possibly-"
"incompatible profile %d instead.\n",
alt_profile);
} else {
av_log(avctx, AV_LOG_VERBOSE, "Codec %s profile %d not "
"supported for hardware decode.\n",
codec_desc->name, avctx->profile);
err = AVERROR(EINVAL);
goto fail;
}
}
ctx->va_profile = profile;
ctx->va_entrypoint = VAEntrypointVLD;
vas = vaCreateConfig(ctx->hwctx->display, ctx->va_profile,
ctx->va_entrypoint, NULL, 0,
&ctx->va_config);
if (vas != VA_STATUS_SUCCESS) {
av_log(avctx, AV_LOG_ERROR, "Failed to create decode "
"configuration: %d (%s).\n", vas, vaErrorStr(vas));
err = AVERROR(EIO);
goto fail;
}
hwconfig = av_hwdevice_hwconfig_alloc(avctx->hw_device_ctx ?
avctx->hw_device_ctx :
ctx->frames->device_ref);
if (!hwconfig) {
err = AVERROR(ENOMEM);
goto fail;
}
hwconfig->config_id = ctx->va_config;
constraints =
av_hwdevice_get_hwframe_constraints(avctx->hw_device_ctx ?
avctx->hw_device_ctx :
ctx->frames->device_ref,
hwconfig);
if (!constraints) {
err = AVERROR(ENOMEM);
goto fail;
}
if (avctx->coded_width < constraints->min_width ||
avctx->coded_height < constraints->min_height ||
avctx->coded_width > constraints->max_width ||
avctx->coded_height > constraints->max_height) {
av_log(avctx, AV_LOG_ERROR, "Hardware does not support image "
"size %dx%d (constraints: width %d-%d height %d-%d).\n",
avctx->coded_width, avctx->coded_height,
constraints->min_width, constraints->max_width,
constraints->min_height, constraints->max_height);
err = AVERROR(EINVAL);
goto fail;
}
if (!constraints->valid_sw_formats ||
constraints->valid_sw_formats[0] == AV_PIX_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Hardware does not offer any "
"usable surface formats.\n");
err = AVERROR(EINVAL);
goto fail;
}
ctx->surface_format = constraints->valid_sw_formats[0];
sw_desc = av_pix_fmt_desc_get(avctx->sw_pix_fmt);
for (i = 0; constraints->valid_sw_formats[i] != AV_PIX_FMT_NONE; i++) {
desc = av_pix_fmt_desc_get(constraints->valid_sw_formats[i]);
if (desc->nb_components != sw_desc->nb_components ||
desc->log2_chroma_w != sw_desc->log2_chroma_w ||
desc->log2_chroma_h != sw_desc->log2_chroma_h)
continue;
for (j = 0; j < desc->nb_components; j++) {
if (desc->comp[j].depth != sw_desc->comp[j].depth)
break;
}
if (j < desc->nb_components)
continue;
ctx->surface_format = constraints->valid_sw_formats[i];
break;
}
ctx->surface_count = 4;
switch (avctx->codec_id) {
case AV_CODEC_ID_H264:
case AV_CODEC_ID_HEVC:
ctx->surface_count += 16;
break;
case AV_CODEC_ID_VP9:
ctx->surface_count += 8;
break;
case AV_CODEC_ID_VP8:
ctx->surface_count += 3;
break;
default:
ctx->surface_count += 2;
}
if (avctx->active_thread_type & FF_THREAD_FRAME)
ctx->surface_count += avctx->thread_count;
av_hwframe_constraints_free(&constraints);
av_freep(&hwconfig);
return 0;
fail:
av_hwframe_constraints_free(&constraints);
av_freep(&hwconfig);
if (ctx->va_config != VA_INVALID_ID) {
vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
ctx->va_config = VA_INVALID_ID;
}
av_freep(&profile_list);
return err;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0)
{
VAAPIDecodeContext *ctx = VAR_0->internal->hwaccel_priv_data;
AVVAAPIHWConfig *hwconfig = NULL;
AVHWFramesConstraints *constraints = NULL;
VAStatus vas;
int VAR_1, VAR_2, VAR_3;
const AVCodecDescriptor *VAR_4;
VAProfile profile, *profile_list = NULL;
int VAR_5, VAR_6, VAR_7;
const AVPixFmtDescriptor *VAR_8, *desc;
VAR_4 = avcodec_descriptor_get(VAR_0->codec_id);
if (!VAR_4) {
VAR_1 = AVERROR(EINVAL);
goto fail;
}
VAR_5 = vaMaxNumProfiles(ctx->hwctx->display);
profile_list = av_malloc_array(VAR_5,
sizeof(VAProfile));
if (!profile_list) {
VAR_1 = AVERROR(ENOMEM);
goto fail;
}
vas = vaQueryConfigProfiles(ctx->hwctx->display,
profile_list, &VAR_5);
if (vas != VA_STATUS_SUCCESS) {
av_log(VAR_0, AV_LOG_ERROR, "Failed to query profiles: "
"%d (%s).\n", vas, vaErrorStr(vas));
VAR_1 = AVERROR(ENOSYS);
goto fail;
}
profile = VAProfileNone;
VAR_6 = 0;
for (VAR_2 = 0; VAR_2 < FF_ARRAY_ELEMS(vaapi_profile_map); VAR_2++) {
int profile_match = 0;
if (VAR_0->codec_id != vaapi_profile_map[VAR_2].codec_id)
continue;
if (VAR_0->profile == vaapi_profile_map[VAR_2].codec_profile ||
vaapi_profile_map[VAR_2].codec_profile == FF_PROFILE_UNKNOWN)
profile_match = 1;
profile = vaapi_profile_map[VAR_2].va_profile;
for (VAR_3 = 0; VAR_3 < VAR_5; VAR_3++) {
if (profile == profile_list[VAR_3]) {
VAR_6 = profile_match;
break;
}
}
if (VAR_3 < VAR_5) {
if (VAR_6)
break;
VAR_7 = vaapi_profile_map[VAR_2].codec_profile;
}
}
av_freep(&profile_list);
if (profile == VAProfileNone) {
av_log(VAR_0, AV_LOG_ERROR, "No support for codec %s "
"profile %d.\n", VAR_4->name, VAR_0->profile);
VAR_1 = AVERROR(ENOSYS);
goto fail;
}
if (!VAR_6) {
if (VAR_0->hwaccel_flags &
AV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH) {
av_log(VAR_0, AV_LOG_VERBOSE, "Codec %s profile %d not "
"supported for hardware decode.\n",
VAR_4->name, VAR_0->profile);
av_log(VAR_0, AV_LOG_WARNING, "Using possibly-"
"incompatible profile %d instead.\n",
VAR_7);
} else {
av_log(VAR_0, AV_LOG_VERBOSE, "Codec %s profile %d not "
"supported for hardware decode.\n",
VAR_4->name, VAR_0->profile);
VAR_1 = AVERROR(EINVAL);
goto fail;
}
}
ctx->va_profile = profile;
ctx->va_entrypoint = VAEntrypointVLD;
vas = vaCreateConfig(ctx->hwctx->display, ctx->va_profile,
ctx->va_entrypoint, NULL, 0,
&ctx->va_config);
if (vas != VA_STATUS_SUCCESS) {
av_log(VAR_0, AV_LOG_ERROR, "Failed to create decode "
"configuration: %d (%s).\n", vas, vaErrorStr(vas));
VAR_1 = AVERROR(EIO);
goto fail;
}
hwconfig = av_hwdevice_hwconfig_alloc(VAR_0->hw_device_ctx ?
VAR_0->hw_device_ctx :
ctx->frames->device_ref);
if (!hwconfig) {
VAR_1 = AVERROR(ENOMEM);
goto fail;
}
hwconfig->config_id = ctx->va_config;
constraints =
av_hwdevice_get_hwframe_constraints(VAR_0->hw_device_ctx ?
VAR_0->hw_device_ctx :
ctx->frames->device_ref,
hwconfig);
if (!constraints) {
VAR_1 = AVERROR(ENOMEM);
goto fail;
}
if (VAR_0->coded_width < constraints->min_width ||
VAR_0->coded_height < constraints->min_height ||
VAR_0->coded_width > constraints->max_width ||
VAR_0->coded_height > constraints->max_height) {
av_log(VAR_0, AV_LOG_ERROR, "Hardware does not support image "
"size %dx%d (constraints: width %d-%d height %d-%d).\n",
VAR_0->coded_width, VAR_0->coded_height,
constraints->min_width, constraints->max_width,
constraints->min_height, constraints->max_height);
VAR_1 = AVERROR(EINVAL);
goto fail;
}
if (!constraints->valid_sw_formats ||
constraints->valid_sw_formats[0] == AV_PIX_FMT_NONE) {
av_log(VAR_0, AV_LOG_ERROR, "Hardware does not offer any "
"usable surface formats.\n");
VAR_1 = AVERROR(EINVAL);
goto fail;
}
ctx->surface_format = constraints->valid_sw_formats[0];
VAR_8 = av_pix_fmt_desc_get(VAR_0->sw_pix_fmt);
for (VAR_2 = 0; constraints->valid_sw_formats[VAR_2] != AV_PIX_FMT_NONE; VAR_2++) {
desc = av_pix_fmt_desc_get(constraints->valid_sw_formats[VAR_2]);
if (desc->nb_components != VAR_8->nb_components ||
desc->log2_chroma_w != VAR_8->log2_chroma_w ||
desc->log2_chroma_h != VAR_8->log2_chroma_h)
continue;
for (VAR_3 = 0; VAR_3 < desc->nb_components; VAR_3++) {
if (desc->comp[VAR_3].depth != VAR_8->comp[VAR_3].depth)
break;
}
if (VAR_3 < desc->nb_components)
continue;
ctx->surface_format = constraints->valid_sw_formats[VAR_2];
break;
}
ctx->surface_count = 4;
switch (VAR_0->codec_id) {
case AV_CODEC_ID_H264:
case AV_CODEC_ID_HEVC:
ctx->surface_count += 16;
break;
case AV_CODEC_ID_VP9:
ctx->surface_count += 8;
break;
case AV_CODEC_ID_VP8:
ctx->surface_count += 3;
break;
default:
ctx->surface_count += 2;
}
if (VAR_0->active_thread_type & FF_THREAD_FRAME)
ctx->surface_count += VAR_0->thread_count;
av_hwframe_constraints_free(&constraints);
av_freep(&hwconfig);
return 0;
fail:
av_hwframe_constraints_free(&constraints);
av_freep(&hwconfig);
if (ctx->va_config != VA_INVALID_ID) {
vaDestroyConfig(ctx->hwctx->display, ctx->va_config);
ctx->va_config = VA_INVALID_ID;
}
av_freep(&profile_list);
return VAR_1;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0)\n{",
"VAAPIDecodeContext *ctx = VAR_0->internal->hwaccel_priv_data;",
"AVVAAPIHWConfig *hwconfig = NULL;",
"AVHWFramesConstraints *constraints = NULL;",
"VAStatus vas;",
"int VAR_1, VAR_2, VAR_3;",
"const AVCodecDescriptor *VAR_4;",
"VAProfile profile, *profile_list = NULL;",
"int VAR_5, VAR_6, VAR_7;",
"const AVPixFmtDescriptor *VAR_8, *desc;",
"VAR_4 = avcodec_descriptor_get(VAR_0->codec_id);",
"if (!VAR_4) {",
"VAR_1 = AVERROR(EINVAL);",
"goto fail;",
"}",
"VAR_5 = vaMaxNumProfiles(ctx->hwctx->display);",
"profile_list = av_malloc_array(VAR_5,\nsizeof(VAProfile));",
"if (!profile_list) {",
"VAR_1 = AVERROR(ENOMEM);",
"goto fail;",
"}",
"vas = vaQueryConfigProfiles(ctx->hwctx->display,\nprofile_list, &VAR_5);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Failed to query profiles: \"\n\"%d (%s).\\n\", vas, vaErrorStr(vas));",
"VAR_1 = AVERROR(ENOSYS);",
"goto fail;",
"}",
"profile = VAProfileNone;",
"VAR_6 = 0;",
"for (VAR_2 = 0; VAR_2 < FF_ARRAY_ELEMS(vaapi_profile_map); VAR_2++) {",
"int profile_match = 0;",
"if (VAR_0->codec_id != vaapi_profile_map[VAR_2].codec_id)\ncontinue;",
"if (VAR_0->profile == vaapi_profile_map[VAR_2].codec_profile ||\nvaapi_profile_map[VAR_2].codec_profile == FF_PROFILE_UNKNOWN)\nprofile_match = 1;",
"profile = vaapi_profile_map[VAR_2].va_profile;",
"for (VAR_3 = 0; VAR_3 < VAR_5; VAR_3++) {",
"if (profile == profile_list[VAR_3]) {",
"VAR_6 = profile_match;",
"break;",
"}",
"}",
"if (VAR_3 < VAR_5) {",
"if (VAR_6)\nbreak;",
"VAR_7 = vaapi_profile_map[VAR_2].codec_profile;",
"}",
"}",
"av_freep(&profile_list);",
"if (profile == VAProfileNone) {",
"av_log(VAR_0, AV_LOG_ERROR, \"No support for codec %s \"\n\"profile %d.\\n\", VAR_4->name, VAR_0->profile);",
"VAR_1 = AVERROR(ENOSYS);",
"goto fail;",
"}",
"if (!VAR_6) {",
"if (VAR_0->hwaccel_flags &\nAV_HWACCEL_FLAG_ALLOW_PROFILE_MISMATCH) {",
"av_log(VAR_0, AV_LOG_VERBOSE, \"Codec %s profile %d not \"\n\"supported for hardware decode.\\n\",\nVAR_4->name, VAR_0->profile);",
"av_log(VAR_0, AV_LOG_WARNING, \"Using possibly-\"\n\"incompatible profile %d instead.\\n\",\nVAR_7);",
"} else {",
"av_log(VAR_0, AV_LOG_VERBOSE, \"Codec %s profile %d not \"\n\"supported for hardware decode.\\n\",\nVAR_4->name, VAR_0->profile);",
"VAR_1 = AVERROR(EINVAL);",
"goto fail;",
"}",
"}",
"ctx->va_profile = profile;",
"ctx->va_entrypoint = VAEntrypointVLD;",
"vas = vaCreateConfig(ctx->hwctx->display, ctx->va_profile,\nctx->va_entrypoint, NULL, 0,\n&ctx->va_config);",
"if (vas != VA_STATUS_SUCCESS) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Failed to create decode \"\n\"configuration: %d (%s).\\n\", vas, vaErrorStr(vas));",
"VAR_1 = AVERROR(EIO);",
"goto fail;",
"}",
"hwconfig = av_hwdevice_hwconfig_alloc(VAR_0->hw_device_ctx ?\nVAR_0->hw_device_ctx :\nctx->frames->device_ref);",
"if (!hwconfig) {",
"VAR_1 = AVERROR(ENOMEM);",
"goto fail;",
"}",
"hwconfig->config_id = ctx->va_config;",
"constraints =\nav_hwdevice_get_hwframe_constraints(VAR_0->hw_device_ctx ?\nVAR_0->hw_device_ctx :\nctx->frames->device_ref,\nhwconfig);",
"if (!constraints) {",
"VAR_1 = AVERROR(ENOMEM);",
"goto fail;",
"}",
"if (VAR_0->coded_width < constraints->min_width ||\nVAR_0->coded_height < constraints->min_height ||\nVAR_0->coded_width > constraints->max_width ||\nVAR_0->coded_height > constraints->max_height) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Hardware does not support image \"\n\"size %dx%d (constraints: width %d-%d height %d-%d).\\n\",\nVAR_0->coded_width, VAR_0->coded_height,\nconstraints->min_width, constraints->max_width,\nconstraints->min_height, constraints->max_height);",
"VAR_1 = AVERROR(EINVAL);",
"goto fail;",
"}",
"if (!constraints->valid_sw_formats ||\nconstraints->valid_sw_formats[0] == AV_PIX_FMT_NONE) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Hardware does not offer any \"\n\"usable surface formats.\\n\");",
"VAR_1 = AVERROR(EINVAL);",
"goto fail;",
"}",
"ctx->surface_format = constraints->valid_sw_formats[0];",
"VAR_8 = av_pix_fmt_desc_get(VAR_0->sw_pix_fmt);",
"for (VAR_2 = 0; constraints->valid_sw_formats[VAR_2] != AV_PIX_FMT_NONE; VAR_2++) {",
"desc = av_pix_fmt_desc_get(constraints->valid_sw_formats[VAR_2]);",
"if (desc->nb_components != VAR_8->nb_components ||\ndesc->log2_chroma_w != VAR_8->log2_chroma_w ||\ndesc->log2_chroma_h != VAR_8->log2_chroma_h)\ncontinue;",
"for (VAR_3 = 0; VAR_3 < desc->nb_components; VAR_3++) {",
"if (desc->comp[VAR_3].depth != VAR_8->comp[VAR_3].depth)\nbreak;",
"}",
"if (VAR_3 < desc->nb_components)\ncontinue;",
"ctx->surface_format = constraints->valid_sw_formats[VAR_2];",
"break;",
"}",
"ctx->surface_count = 4;",
"switch (VAR_0->codec_id) {",
"case AV_CODEC_ID_H264:\ncase AV_CODEC_ID_HEVC:\nctx->surface_count += 16;",
"break;",
"case AV_CODEC_ID_VP9:\nctx->surface_count += 8;",
"break;",
"case AV_CODEC_ID_VP8:\nctx->surface_count += 3;",
"break;",
"default:\nctx->surface_count += 2;",
"}",
"if (VAR_0->active_thread_type & FF_THREAD_FRAME)\nctx->surface_count += VAR_0->thread_count;",
"av_hwframe_constraints_free(&constraints);",
"av_freep(&hwconfig);",
"return 0;",
"fail:\nav_hwframe_constraints_free(&constraints);",
"av_freep(&hwconfig);",
"if (ctx->va_config != VA_INVALID_ID) {",
"vaDestroyConfig(ctx->hwctx->display, ctx->va_config);",
"ctx->va_config = VA_INVALID_ID;",
"}",
"av_freep(&profile_list);",
"return VAR_1;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83,
85
],
[
87,
89,
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109,
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
123
],
[
125,
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137,
139
],
[
141,
143,
145
],
[
147,
149,
151
],
[
153
],
[
155,
157,
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
171
],
[
173
],
[
177,
179,
181
],
[
183
],
[
185,
187
],
[
189
],
[
191
],
[
193
],
[
197,
199,
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
215,
217,
219,
221,
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
235,
237,
239,
241
],
[
243,
245,
247,
249,
251
],
[
253
],
[
255
],
[
257
],
[
259,
261
],
[
263,
265
],
[
267
],
[
269
],
[
271
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291,
293,
295,
297
],
[
299
],
[
301,
303
],
[
305
],
[
307,
309
],
[
311
],
[
313
],
[
315
],
[
321
],
[
325
],
[
327,
329,
331
],
[
333
],
[
335,
337
],
[
339
],
[
341,
343
],
[
345
],
[
347,
349
],
[
351
],
[
355,
357
],
[
361
],
[
363
],
[
367
],
[
371,
373
],
[
375
],
[
377
],
[
379
],
[
381
],
[
383
],
[
385
],
[
387
],
[
389
]
]
|
12,794 | static int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
{
if (qemu_opt_get_bool(opts, "enable", false)) {
#ifdef CONFIG_SECCOMP
uint32_t seccomp_opts = QEMU_SECCOMP_SET_DEFAULT
| QEMU_SECCOMP_SET_OBSOLETE;
const char *value = NULL;
value = qemu_opt_get(opts, "obsolete");
if (g_str_equal(value, "allow")) {
seccomp_opts &= ~QEMU_SECCOMP_SET_OBSOLETE;
} else if (g_str_equal(value, "deny")) {
/* this is the default option, this if is here
* to provide a little bit of consistency for
* the command line */
error_report("invalid argument for obsolete");
if (seccomp_start(seccomp_opts) < 0) {
error_report("failed to install seccomp syscall filter "
"in the kernel");
#else
error_report("seccomp support is disabled");
#endif
return 0; | true | qemu | 73a1e647256b09734ce64ef7a6001a0db03f7106 | static int parse_sandbox(void *opaque, QemuOpts *opts, Error **errp)
{
if (qemu_opt_get_bool(opts, "enable", false)) {
#ifdef CONFIG_SECCOMP
uint32_t seccomp_opts = QEMU_SECCOMP_SET_DEFAULT
| QEMU_SECCOMP_SET_OBSOLETE;
const char *value = NULL;
value = qemu_opt_get(opts, "obsolete");
if (g_str_equal(value, "allow")) {
seccomp_opts &= ~QEMU_SECCOMP_SET_OBSOLETE;
} else if (g_str_equal(value, "deny")) {
error_report("invalid argument for obsolete");
if (seccomp_start(seccomp_opts) < 0) {
error_report("failed to install seccomp syscall filter "
"in the kernel");
#else
error_report("seccomp support is disabled");
#endif
return 0; | {
"code": [],
"line_no": []
} | static int FUNC_0(void *VAR_0, QemuOpts *VAR_1, Error **VAR_2)
{
if (qemu_opt_get_bool(VAR_1, "enable", false)) {
#ifdef CONFIG_SECCOMP
uint32_t seccomp_opts = QEMU_SECCOMP_SET_DEFAULT
| QEMU_SECCOMP_SET_OBSOLETE;
const char *value = NULL;
value = qemu_opt_get(VAR_1, "obsolete");
if (g_str_equal(value, "allow")) {
seccomp_opts &= ~QEMU_SECCOMP_SET_OBSOLETE;
} else if (g_str_equal(value, "deny")) {
error_report("invalid argument for obsolete");
if (seccomp_start(seccomp_opts) < 0) {
error_report("failed to install seccomp syscall filter "
"in the kernel");
#else
error_report("seccomp support is disabled");
#endif
return 0; | [
"static int FUNC_0(void *VAR_0, QemuOpts *VAR_1, Error **VAR_2)\n{",
"if (qemu_opt_get_bool(VAR_1, \"enable\", false)) {",
"#ifdef CONFIG_SECCOMP\nuint32_t seccomp_opts = QEMU_SECCOMP_SET_DEFAULT\n| QEMU_SECCOMP_SET_OBSOLETE;",
"const char *value = NULL;",
"value = qemu_opt_get(VAR_1, \"obsolete\");",
"if (g_str_equal(value, \"allow\")) {",
"seccomp_opts &= ~QEMU_SECCOMP_SET_OBSOLETE;",
"} else if (g_str_equal(value, \"deny\")) {",
"error_report(\"invalid argument for obsolete\");",
"if (seccomp_start(seccomp_opts) < 0) {",
"error_report(\"failed to install seccomp syscall filter \"\n\"in the kernel\");",
"#else\nerror_report(\"seccomp support is disabled\");",
"#endif\nreturn 0;"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
2
],
[
3
],
[
4,
5,
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
15
],
[
16
],
[
17,
18
],
[
19,
20
],
[
21,
22
]
]
|
12,795 | static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id)
{
return ((TiffGeoTagKeyName*)bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key))->name;
}
| true | FFmpeg | f28043d0a34aaf4ac7cf25bd0dddd868811c0ab2 | static const char *search_keyval(const TiffGeoTagKeyName *keys, int n, int id)
{
return ((TiffGeoTagKeyName*)bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key))->name;
}
| {
"code": [
" return ((TiffGeoTagKeyName*)bsearch(&id, keys, n, sizeof(keys[0]), cmp_id_key))->name;"
],
"line_no": [
5
]
} | static const char *FUNC_0(const TiffGeoTagKeyName *VAR_0, int VAR_1, int VAR_2)
{
return ((TiffGeoTagKeyName*)bsearch(&VAR_2, VAR_0, VAR_1, sizeof(VAR_0[0]), cmp_id_key))->name;
}
| [
"static const char *FUNC_0(const TiffGeoTagKeyName *VAR_0, int VAR_1, int VAR_2)\n{",
"return ((TiffGeoTagKeyName*)bsearch(&VAR_2, VAR_0, VAR_1, sizeof(VAR_0[0]), cmp_id_key))->name;",
"}"
]
| [
0,
1,
0
]
| [
[
1,
3
],
[
5
],
[
7
]
]
|
12,797 | static int wm8750_tx(I2CSlave *i2c, uint8_t data)
{
WM8750State *s = (WM8750State *) i2c;
uint8_t cmd;
uint16_t value;
if (s->i2c_len >= 2) {
printf("%s: long message (%i bytes)\n", __FUNCTION__, s->i2c_len);
#ifdef VERBOSE
return 1;
#endif
}
s->i2c_data[s->i2c_len ++] = data;
if (s->i2c_len != 2)
return 0;
cmd = s->i2c_data[0] >> 1;
value = ((s->i2c_data[0] << 8) | s->i2c_data[1]) & 0x1ff;
switch (cmd) {
case WM8750_LADCIN: /* ADC Signal Path Control (Left) */
s->diff[0] = (((value >> 6) & 3) == 3); /* LINSEL */
if (s->diff[0])
s->in[0] = &s->adc_voice[0 + s->ds * 1];
else
s->in[0] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];
break;
case WM8750_RADCIN: /* ADC Signal Path Control (Right) */
s->diff[1] = (((value >> 6) & 3) == 3); /* RINSEL */
if (s->diff[1])
s->in[1] = &s->adc_voice[0 + s->ds * 1];
else
s->in[1] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];
break;
case WM8750_ADCIN: /* ADC Input Mode */
s->ds = (value >> 8) & 1; /* DS */
if (s->diff[0])
s->in[0] = &s->adc_voice[0 + s->ds * 1];
if (s->diff[1])
s->in[1] = &s->adc_voice[0 + s->ds * 1];
s->monomix[0] = (value >> 6) & 3; /* MONOMIX */
break;
case WM8750_ADCTL1: /* Additional Control (1) */
s->monomix[1] = (value >> 1) & 1; /* DMONOMIX */
break;
case WM8750_PWR1: /* Power Management (1) */
s->enable = ((value >> 6) & 7) == 3; /* VMIDSEL, VREF */
wm8750_set_format(s);
break;
case WM8750_LINVOL: /* Left Channel PGA */
s->invol[0] = value & 0x3f; /* LINVOL */
s->inmute[0] = (value >> 7) & 1; /* LINMUTE */
wm8750_vol_update(s);
break;
case WM8750_RINVOL: /* Right Channel PGA */
s->invol[1] = value & 0x3f; /* RINVOL */
s->inmute[1] = (value >> 7) & 1; /* RINMUTE */
wm8750_vol_update(s);
break;
case WM8750_ADCDAC: /* ADC and DAC Control */
s->pol = (value >> 5) & 3; /* ADCPOL */
s->mute = (value >> 3) & 1; /* DACMU */
wm8750_vol_update(s);
break;
case WM8750_ADCTL3: /* Additional Control (3) */
break;
case WM8750_LADC: /* Left ADC Digital Volume */
s->invol[2] = value & 0xff; /* LADCVOL */
wm8750_vol_update(s);
break;
case WM8750_RADC: /* Right ADC Digital Volume */
s->invol[3] = value & 0xff; /* RADCVOL */
wm8750_vol_update(s);
break;
case WM8750_ALC1: /* ALC Control (1) */
s->alc = (value >> 7) & 3; /* ALCSEL */
break;
case WM8750_NGATE: /* Noise Gate Control */
case WM8750_3D: /* 3D enhance */
break;
case WM8750_LDAC: /* Left Channel Digital Volume */
s->outvol[0] = value & 0xff; /* LDACVOL */
wm8750_vol_update(s);
break;
case WM8750_RDAC: /* Right Channel Digital Volume */
s->outvol[1] = value & 0xff; /* RDACVOL */
wm8750_vol_update(s);
break;
case WM8750_BASS: /* Bass Control */
break;
case WM8750_LOUTM1: /* Left Mixer Control (1) */
s->path[0] = (value >> 8) & 1; /* LD2LO */
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_LOUTM2: /* Left Mixer Control (2) */
s->path[1] = (value >> 8) & 1; /* RD2LO */
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_ROUTM1: /* Right Mixer Control (1) */
s->path[2] = (value >> 8) & 1; /* LD2RO */
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_ROUTM2: /* Right Mixer Control (2) */
s->path[3] = (value >> 8) & 1; /* RD2RO */
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_MOUTM1: /* Mono Mixer Control (1) */
s->mpath[0] = (value >> 8) & 1; /* LD2MO */
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_MOUTM2: /* Mono Mixer Control (2) */
s->mpath[1] = (value >> 8) & 1; /* RD2MO */
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_LOUT1V: /* LOUT1 Volume */
s->outvol[2] = value & 0x7f; /* LOUT1VOL */
wm8750_vol_update(s);
break;
case WM8750_LOUT2V: /* LOUT2 Volume */
s->outvol[4] = value & 0x7f; /* LOUT2VOL */
wm8750_vol_update(s);
break;
case WM8750_ROUT1V: /* ROUT1 Volume */
s->outvol[3] = value & 0x7f; /* ROUT1VOL */
wm8750_vol_update(s);
break;
case WM8750_ROUT2V: /* ROUT2 Volume */
s->outvol[5] = value & 0x7f; /* ROUT2VOL */
wm8750_vol_update(s);
break;
case WM8750_MOUTV: /* MONOOUT Volume */
s->outvol[6] = value & 0x7f; /* MONOOUTVOL */
wm8750_vol_update(s);
break;
case WM8750_ADCTL2: /* Additional Control (2) */
break;
case WM8750_PWR2: /* Power Management (2) */
s->power = value & 0x7e;
/* TODO: mute/unmute respective paths */
wm8750_vol_update(s);
break;
case WM8750_IFACE: /* Digital Audio Interface Format */
s->format = value;
s->master = (value >> 6) & 1; /* MS */
wm8750_clk_update(s, s->master);
break;
case WM8750_SRATE: /* Clocking and Sample Rate Control */
s->rate = &wm_rate_table[(value >> 1) & 0x1f];
wm8750_clk_update(s, 0);
break;
case WM8750_RESET: /* Reset */
wm8750_reset(&s->i2c);
break;
#ifdef VERBOSE
default:
printf("%s: unknown register %02x\n", __FUNCTION__, cmd);
#endif
}
return 0;
}
| true | qemu | 149eeb5fe57b853081e8059575d91b8a58a4f96c | static int wm8750_tx(I2CSlave *i2c, uint8_t data)
{
WM8750State *s = (WM8750State *) i2c;
uint8_t cmd;
uint16_t value;
if (s->i2c_len >= 2) {
printf("%s: long message (%i bytes)\n", __FUNCTION__, s->i2c_len);
#ifdef VERBOSE
return 1;
#endif
}
s->i2c_data[s->i2c_len ++] = data;
if (s->i2c_len != 2)
return 0;
cmd = s->i2c_data[0] >> 1;
value = ((s->i2c_data[0] << 8) | s->i2c_data[1]) & 0x1ff;
switch (cmd) {
case WM8750_LADCIN:
s->diff[0] = (((value >> 6) & 3) == 3);
if (s->diff[0])
s->in[0] = &s->adc_voice[0 + s->ds * 1];
else
s->in[0] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];
break;
case WM8750_RADCIN:
s->diff[1] = (((value >> 6) & 3) == 3);
if (s->diff[1])
s->in[1] = &s->adc_voice[0 + s->ds * 1];
else
s->in[1] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];
break;
case WM8750_ADCIN:
s->ds = (value >> 8) & 1;
if (s->diff[0])
s->in[0] = &s->adc_voice[0 + s->ds * 1];
if (s->diff[1])
s->in[1] = &s->adc_voice[0 + s->ds * 1];
s->monomix[0] = (value >> 6) & 3;
break;
case WM8750_ADCTL1:
s->monomix[1] = (value >> 1) & 1;
break;
case WM8750_PWR1:
s->enable = ((value >> 6) & 7) == 3;
wm8750_set_format(s);
break;
case WM8750_LINVOL:
s->invol[0] = value & 0x3f;
s->inmute[0] = (value >> 7) & 1;
wm8750_vol_update(s);
break;
case WM8750_RINVOL:
s->invol[1] = value & 0x3f;
s->inmute[1] = (value >> 7) & 1;
wm8750_vol_update(s);
break;
case WM8750_ADCDAC:
s->pol = (value >> 5) & 3;
s->mute = (value >> 3) & 1;
wm8750_vol_update(s);
break;
case WM8750_ADCTL3:
break;
case WM8750_LADC:
s->invol[2] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_RADC:
s->invol[3] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_ALC1:
s->alc = (value >> 7) & 3;
break;
case WM8750_NGATE:
case WM8750_3D:
break;
case WM8750_LDAC:
s->outvol[0] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_RDAC:
s->outvol[1] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_BASS:
break;
case WM8750_LOUTM1:
s->path[0] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_LOUTM2:
s->path[1] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_ROUTM1:
s->path[2] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_ROUTM2:
s->path[3] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_MOUTM1:
s->mpath[0] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_MOUTM2:
s->mpath[1] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_LOUT1V:
s->outvol[2] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_LOUT2V:
s->outvol[4] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_ROUT1V:
s->outvol[3] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_ROUT2V:
s->outvol[5] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_MOUTV:
s->outvol[6] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_ADCTL2:
break;
case WM8750_PWR2:
s->power = value & 0x7e;
wm8750_vol_update(s);
break;
case WM8750_IFACE:
s->format = value;
s->master = (value >> 6) & 1;
wm8750_clk_update(s, s->master);
break;
case WM8750_SRATE:
s->rate = &wm_rate_table[(value >> 1) & 0x1f];
wm8750_clk_update(s, 0);
break;
case WM8750_RESET:
wm8750_reset(&s->i2c);
break;
#ifdef VERBOSE
default:
printf("%s: unknown register %02x\n", __FUNCTION__, cmd);
#endif
}
return 0;
}
| {
"code": [
" printf(\"%s: long message (%i bytes)\\n\", __FUNCTION__, s->i2c_len);",
" return 1;"
],
"line_no": [
15,
19
]
} | static int FUNC_0(I2CSlave *VAR_0, uint8_t VAR_1)
{
WM8750State *s = (WM8750State *) VAR_0;
uint8_t cmd;
uint16_t value;
if (s->i2c_len >= 2) {
printf("%s: long message (%i bytes)\n", __FUNCTION__, s->i2c_len);
#ifdef VERBOSE
return 1;
#endif
}
s->i2c_data[s->i2c_len ++] = VAR_1;
if (s->i2c_len != 2)
return 0;
cmd = s->i2c_data[0] >> 1;
value = ((s->i2c_data[0] << 8) | s->i2c_data[1]) & 0x1ff;
switch (cmd) {
case WM8750_LADCIN:
s->diff[0] = (((value >> 6) & 3) == 3);
if (s->diff[0])
s->in[0] = &s->adc_voice[0 + s->ds * 1];
else
s->in[0] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];
break;
case WM8750_RADCIN:
s->diff[1] = (((value >> 6) & 3) == 3);
if (s->diff[1])
s->in[1] = &s->adc_voice[0 + s->ds * 1];
else
s->in[1] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];
break;
case WM8750_ADCIN:
s->ds = (value >> 8) & 1;
if (s->diff[0])
s->in[0] = &s->adc_voice[0 + s->ds * 1];
if (s->diff[1])
s->in[1] = &s->adc_voice[0 + s->ds * 1];
s->monomix[0] = (value >> 6) & 3;
break;
case WM8750_ADCTL1:
s->monomix[1] = (value >> 1) & 1;
break;
case WM8750_PWR1:
s->enable = ((value >> 6) & 7) == 3;
wm8750_set_format(s);
break;
case WM8750_LINVOL:
s->invol[0] = value & 0x3f;
s->inmute[0] = (value >> 7) & 1;
wm8750_vol_update(s);
break;
case WM8750_RINVOL:
s->invol[1] = value & 0x3f;
s->inmute[1] = (value >> 7) & 1;
wm8750_vol_update(s);
break;
case WM8750_ADCDAC:
s->pol = (value >> 5) & 3;
s->mute = (value >> 3) & 1;
wm8750_vol_update(s);
break;
case WM8750_ADCTL3:
break;
case WM8750_LADC:
s->invol[2] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_RADC:
s->invol[3] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_ALC1:
s->alc = (value >> 7) & 3;
break;
case WM8750_NGATE:
case WM8750_3D:
break;
case WM8750_LDAC:
s->outvol[0] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_RDAC:
s->outvol[1] = value & 0xff;
wm8750_vol_update(s);
break;
case WM8750_BASS:
break;
case WM8750_LOUTM1:
s->path[0] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_LOUTM2:
s->path[1] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_ROUTM1:
s->path[2] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_ROUTM2:
s->path[3] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_MOUTM1:
s->mpath[0] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_MOUTM2:
s->mpath[1] = (value >> 8) & 1;
wm8750_vol_update(s);
break;
case WM8750_LOUT1V:
s->outvol[2] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_LOUT2V:
s->outvol[4] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_ROUT1V:
s->outvol[3] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_ROUT2V:
s->outvol[5] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_MOUTV:
s->outvol[6] = value & 0x7f;
wm8750_vol_update(s);
break;
case WM8750_ADCTL2:
break;
case WM8750_PWR2:
s->power = value & 0x7e;
wm8750_vol_update(s);
break;
case WM8750_IFACE:
s->format = value;
s->master = (value >> 6) & 1;
wm8750_clk_update(s, s->master);
break;
case WM8750_SRATE:
s->rate = &wm_rate_table[(value >> 1) & 0x1f];
wm8750_clk_update(s, 0);
break;
case WM8750_RESET:
wm8750_reset(&s->VAR_0);
break;
#ifdef VERBOSE
default:
printf("%s: unknown register %02x\n", __FUNCTION__, cmd);
#endif
}
return 0;
}
| [
"static int FUNC_0(I2CSlave *VAR_0, uint8_t VAR_1)\n{",
"WM8750State *s = (WM8750State *) VAR_0;",
"uint8_t cmd;",
"uint16_t value;",
"if (s->i2c_len >= 2) {",
"printf(\"%s: long message (%i bytes)\\n\", __FUNCTION__, s->i2c_len);",
"#ifdef VERBOSE\nreturn 1;",
"#endif\n}",
"s->i2c_data[s->i2c_len ++] = VAR_1;",
"if (s->i2c_len != 2)\nreturn 0;",
"cmd = s->i2c_data[0] >> 1;",
"value = ((s->i2c_data[0] << 8) | s->i2c_data[1]) & 0x1ff;",
"switch (cmd) {",
"case WM8750_LADCIN:\ns->diff[0] = (((value >> 6) & 3) == 3);",
"if (s->diff[0])\ns->in[0] = &s->adc_voice[0 + s->ds * 1];",
"else\ns->in[0] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];",
"break;",
"case WM8750_RADCIN:\ns->diff[1] = (((value >> 6) & 3) == 3);",
"if (s->diff[1])\ns->in[1] = &s->adc_voice[0 + s->ds * 1];",
"else\ns->in[1] = &s->adc_voice[((value >> 6) & 3) * 1 + 0];",
"break;",
"case WM8750_ADCIN:\ns->ds = (value >> 8) & 1;",
"if (s->diff[0])\ns->in[0] = &s->adc_voice[0 + s->ds * 1];",
"if (s->diff[1])\ns->in[1] = &s->adc_voice[0 + s->ds * 1];",
"s->monomix[0] = (value >> 6) & 3;",
"break;",
"case WM8750_ADCTL1:\ns->monomix[1] = (value >> 1) & 1;",
"break;",
"case WM8750_PWR1:\ns->enable = ((value >> 6) & 7) == 3;",
"wm8750_set_format(s);",
"break;",
"case WM8750_LINVOL:\ns->invol[0] = value & 0x3f;",
"s->inmute[0] = (value >> 7) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_RINVOL:\ns->invol[1] = value & 0x3f;",
"s->inmute[1] = (value >> 7) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ADCDAC:\ns->pol = (value >> 5) & 3;",
"s->mute = (value >> 3) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ADCTL3:\nbreak;",
"case WM8750_LADC:\ns->invol[2] = value & 0xff;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_RADC:\ns->invol[3] = value & 0xff;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ALC1:\ns->alc = (value >> 7) & 3;",
"break;",
"case WM8750_NGATE:\ncase WM8750_3D:\nbreak;",
"case WM8750_LDAC:\ns->outvol[0] = value & 0xff;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_RDAC:\ns->outvol[1] = value & 0xff;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_BASS:\nbreak;",
"case WM8750_LOUTM1:\ns->path[0] = (value >> 8) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_LOUTM2:\ns->path[1] = (value >> 8) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ROUTM1:\ns->path[2] = (value >> 8) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ROUTM2:\ns->path[3] = (value >> 8) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_MOUTM1:\ns->mpath[0] = (value >> 8) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_MOUTM2:\ns->mpath[1] = (value >> 8) & 1;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_LOUT1V:\ns->outvol[2] = value & 0x7f;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_LOUT2V:\ns->outvol[4] = value & 0x7f;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ROUT1V:\ns->outvol[3] = value & 0x7f;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ROUT2V:\ns->outvol[5] = value & 0x7f;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_MOUTV:\ns->outvol[6] = value & 0x7f;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_ADCTL2:\nbreak;",
"case WM8750_PWR2:\ns->power = value & 0x7e;",
"wm8750_vol_update(s);",
"break;",
"case WM8750_IFACE:\ns->format = value;",
"s->master = (value >> 6) & 1;",
"wm8750_clk_update(s, s->master);",
"break;",
"case WM8750_SRATE:\ns->rate = &wm_rate_table[(value >> 1) & 0x1f];",
"wm8750_clk_update(s, 0);",
"break;",
"case WM8750_RESET:\nwm8750_reset(&s->VAR_0);",
"break;",
"#ifdef VERBOSE\ndefault:\nprintf(\"%s: unknown register %02x\\n\", __FUNCTION__, cmd);",
"#endif\n}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17,
19
],
[
21,
23
],
[
25
],
[
27,
29
],
[
33
],
[
35
],
[
39
],
[
41,
43
],
[
45,
47
],
[
49,
51
],
[
53
],
[
57,
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
73,
75
],
[
77,
79
],
[
81,
83
],
[
85
],
[
87
],
[
91,
93
],
[
95
],
[
99,
101
],
[
103
],
[
105
],
[
109,
111
],
[
113
],
[
115
],
[
117
],
[
121,
123
],
[
125
],
[
127
],
[
129
],
[
133,
135
],
[
137
],
[
139
],
[
141
],
[
145,
147
],
[
151,
153
],
[
155
],
[
157
],
[
161,
163
],
[
165
],
[
167
],
[
171,
173
],
[
175
],
[
179,
181,
183
],
[
187,
189
],
[
191
],
[
193
],
[
197,
199
],
[
201
],
[
203
],
[
207,
209
],
[
213,
215
],
[
219
],
[
221
],
[
225,
227
],
[
231
],
[
233
],
[
237,
239
],
[
243
],
[
245
],
[
249,
251
],
[
255
],
[
257
],
[
261,
263
],
[
267
],
[
269
],
[
273,
275
],
[
279
],
[
281
],
[
285,
287
],
[
289
],
[
291
],
[
295,
297
],
[
299
],
[
301
],
[
305,
307
],
[
309
],
[
311
],
[
315,
317
],
[
319
],
[
321
],
[
325,
327
],
[
329
],
[
331
],
[
335,
337
],
[
341,
343
],
[
347
],
[
349
],
[
353,
355
],
[
357
],
[
359
],
[
361
],
[
365,
367
],
[
369
],
[
371
],
[
375,
377
],
[
379
],
[
383,
385,
387
],
[
389,
391
],
[
395
],
[
397
]
]
|
12,798 | static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp)
{
const QDictEntry *ent;
const char *arg_name;
const QObject *arg_obj;
bool has_exec_key = false;
QDict *dict = NULL;
dict = qobject_to_qdict(request);
if (!dict) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT,
"request is not a dictionary");
return NULL;
}
for (ent = qdict_first(dict); ent;
ent = qdict_next(dict, ent)) {
arg_name = qdict_entry_key(ent);
arg_obj = qdict_entry_value(ent);
if (!strcmp(arg_name, "execute")) {
if (qobject_type(arg_obj) != QTYPE_QSTRING) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
"string");
return NULL;
}
has_exec_key = true;
} else if (!strcmp(arg_name, "arguments")) {
if (qobject_type(arg_obj) != QTYPE_QDICT) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
"arguments", "object");
return NULL;
}
} else {
error_setg(errp, QERR_QMP_EXTRA_MEMBER, arg_name);
return NULL;
}
}
if (!has_exec_key) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
return NULL;
}
return dict;
}
| true | qemu | 104fc3027960dd2aa9d310936a6cb201c60e1088 | static QDict *qmp_dispatch_check_obj(const QObject *request, Error **errp)
{
const QDictEntry *ent;
const char *arg_name;
const QObject *arg_obj;
bool has_exec_key = false;
QDict *dict = NULL;
dict = qobject_to_qdict(request);
if (!dict) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT,
"request is not a dictionary");
return NULL;
}
for (ent = qdict_first(dict); ent;
ent = qdict_next(dict, ent)) {
arg_name = qdict_entry_key(ent);
arg_obj = qdict_entry_value(ent);
if (!strcmp(arg_name, "execute")) {
if (qobject_type(arg_obj) != QTYPE_QSTRING) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
"string");
return NULL;
}
has_exec_key = true;
} else if (!strcmp(arg_name, "arguments")) {
if (qobject_type(arg_obj) != QTYPE_QDICT) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
"arguments", "object");
return NULL;
}
} else {
error_setg(errp, QERR_QMP_EXTRA_MEMBER, arg_name);
return NULL;
}
}
if (!has_exec_key) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
return NULL;
}
return dict;
}
| {
"code": [
" const QDictEntry *ent;",
" return NULL;",
" if (!strcmp(arg_name, \"execute\")) {",
" if (qobject_type(arg_obj) != QTYPE_QSTRING) {",
" error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,",
" return NULL;",
" } else if (!strcmp(arg_name, \"arguments\")) {",
" if (qobject_type(arg_obj) != QTYPE_QDICT) {",
" error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,",
" \"arguments\", \"object\");",
" return NULL;",
" } else {",
" error_setg(errp, QERR_QMP_EXTRA_MEMBER, arg_name);",
" return NULL;",
" if (!has_exec_key) {",
" error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, \"execute\");",
" return NULL;",
" error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT,",
" \"request is not a dictionary\");"
],
"line_no": [
5,
25,
41,
43,
59,
49,
55,
57,
59,
61,
49,
67,
69,
71,
79,
81,
25,
21,
23
]
} | static QDict *FUNC_0(const QObject *request, Error **errp)
{
const QDictEntry *VAR_0;
const char *VAR_1;
const QObject *VAR_2;
bool has_exec_key = false;
QDict *dict = NULL;
dict = qobject_to_qdict(request);
if (!dict) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT,
"request is not a dictionary");
return NULL;
}
for (VAR_0 = qdict_first(dict); VAR_0;
VAR_0 = qdict_next(dict, VAR_0)) {
VAR_1 = qdict_entry_key(VAR_0);
VAR_2 = qdict_entry_value(VAR_0);
if (!strcmp(VAR_1, "execute")) {
if (qobject_type(VAR_2) != QTYPE_QSTRING) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER, "execute",
"string");
return NULL;
}
has_exec_key = true;
} else if (!strcmp(VAR_1, "arguments")) {
if (qobject_type(VAR_2) != QTYPE_QDICT) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,
"arguments", "object");
return NULL;
}
} else {
error_setg(errp, QERR_QMP_EXTRA_MEMBER, VAR_1);
return NULL;
}
}
if (!has_exec_key) {
error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, "execute");
return NULL;
}
return dict;
}
| [
"static QDict *FUNC_0(const QObject *request, Error **errp)\n{",
"const QDictEntry *VAR_0;",
"const char *VAR_1;",
"const QObject *VAR_2;",
"bool has_exec_key = false;",
"QDict *dict = NULL;",
"dict = qobject_to_qdict(request);",
"if (!dict) {",
"error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT,\n\"request is not a dictionary\");",
"return NULL;",
"}",
"for (VAR_0 = qdict_first(dict); VAR_0;",
"VAR_0 = qdict_next(dict, VAR_0)) {",
"VAR_1 = qdict_entry_key(VAR_0);",
"VAR_2 = qdict_entry_value(VAR_0);",
"if (!strcmp(VAR_1, \"execute\")) {",
"if (qobject_type(VAR_2) != QTYPE_QSTRING) {",
"error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER, \"execute\",\n\"string\");",
"return NULL;",
"}",
"has_exec_key = true;",
"} else if (!strcmp(VAR_1, \"arguments\")) {",
"if (qobject_type(VAR_2) != QTYPE_QDICT) {",
"error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT_MEMBER,\n\"arguments\", \"object\");",
"return NULL;",
"}",
"} else {",
"error_setg(errp, QERR_QMP_EXTRA_MEMBER, VAR_1);",
"return NULL;",
"}",
"}",
"if (!has_exec_key) {",
"error_setg(errp, QERR_QMP_BAD_INPUT_OBJECT, \"execute\");",
"return NULL;",
"}",
"return dict;",
"}"
]
| [
0,
1,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
1,
1,
0,
1,
0,
0,
1,
1,
1,
0,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
]
]
|
12,800 | static void j2k_flush(J2kDecoderContext *s)
{
if (*s->buf == 0xff)
s->buf++;
s->bit_index = 8;
s->buf++;
}
| true | FFmpeg | ddfa3751c092feaf1e080f66587024689dfe603c | static void j2k_flush(J2kDecoderContext *s)
{
if (*s->buf == 0xff)
s->buf++;
s->bit_index = 8;
s->buf++;
}
| {
"code": [
" if (*s->buf == 0xff)",
" s->buf++;",
" s->buf++;"
],
"line_no": [
5,
7,
11
]
} | static void FUNC_0(J2kDecoderContext *VAR_0)
{
if (*VAR_0->buf == 0xff)
VAR_0->buf++;
VAR_0->bit_index = 8;
VAR_0->buf++;
}
| [
"static void FUNC_0(J2kDecoderContext *VAR_0)\n{",
"if (*VAR_0->buf == 0xff)\nVAR_0->buf++;",
"VAR_0->bit_index = 8;",
"VAR_0->buf++;",
"}"
]
| [
0,
1,
0,
1,
0
]
| [
[
1,
3
],
[
5,
7
],
[
9
],
[
11
],
[
13
]
]
|
12,802 | av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
{
int blk, ch;
AC3EncodeContext *s = avctx->priv_data;
av_freep(&s->windowed_samples);
for (ch = 0; ch < s->channels; ch++)
av_freep(&s->planar_samples[ch]);
av_freep(&s->planar_samples);
av_freep(&s->bap_buffer);
av_freep(&s->bap1_buffer);
av_freep(&s->mdct_coef_buffer);
av_freep(&s->fixed_coef_buffer);
av_freep(&s->exp_buffer);
av_freep(&s->grouped_exp_buffer);
av_freep(&s->psd_buffer);
av_freep(&s->band_psd_buffer);
av_freep(&s->mask_buffer);
av_freep(&s->qmant_buffer);
av_freep(&s->cpl_coord_exp_buffer);
av_freep(&s->cpl_coord_mant_buffer);
for (blk = 0; blk < s->num_blocks; blk++) {
AC3Block *block = &s->blocks[blk];
av_freep(&block->mdct_coef);
av_freep(&block->fixed_coef);
av_freep(&block->exp);
av_freep(&block->grouped_exp);
av_freep(&block->psd);
av_freep(&block->band_psd);
av_freep(&block->mask);
av_freep(&block->qmant);
av_freep(&block->cpl_coord_exp);
av_freep(&block->cpl_coord_mant);
}
s->mdct_end(s);
return 0;
} | true | FFmpeg | 225f78b7ef589e52bbbb19c97d36de5b27982702 | av_cold int ff_ac3_encode_close(AVCodecContext *avctx)
{
int blk, ch;
AC3EncodeContext *s = avctx->priv_data;
av_freep(&s->windowed_samples);
for (ch = 0; ch < s->channels; ch++)
av_freep(&s->planar_samples[ch]);
av_freep(&s->planar_samples);
av_freep(&s->bap_buffer);
av_freep(&s->bap1_buffer);
av_freep(&s->mdct_coef_buffer);
av_freep(&s->fixed_coef_buffer);
av_freep(&s->exp_buffer);
av_freep(&s->grouped_exp_buffer);
av_freep(&s->psd_buffer);
av_freep(&s->band_psd_buffer);
av_freep(&s->mask_buffer);
av_freep(&s->qmant_buffer);
av_freep(&s->cpl_coord_exp_buffer);
av_freep(&s->cpl_coord_mant_buffer);
for (blk = 0; blk < s->num_blocks; blk++) {
AC3Block *block = &s->blocks[blk];
av_freep(&block->mdct_coef);
av_freep(&block->fixed_coef);
av_freep(&block->exp);
av_freep(&block->grouped_exp);
av_freep(&block->psd);
av_freep(&block->band_psd);
av_freep(&block->mask);
av_freep(&block->qmant);
av_freep(&block->cpl_coord_exp);
av_freep(&block->cpl_coord_mant);
}
s->mdct_end(s);
return 0;
} | {
"code": [],
"line_no": []
} | av_cold int FUNC_0(AVCodecContext *avctx)
{
int VAR_0, VAR_1;
AC3EncodeContext *s = avctx->priv_data;
av_freep(&s->windowed_samples);
for (VAR_1 = 0; VAR_1 < s->channels; VAR_1++)
av_freep(&s->planar_samples[VAR_1]);
av_freep(&s->planar_samples);
av_freep(&s->bap_buffer);
av_freep(&s->bap1_buffer);
av_freep(&s->mdct_coef_buffer);
av_freep(&s->fixed_coef_buffer);
av_freep(&s->exp_buffer);
av_freep(&s->grouped_exp_buffer);
av_freep(&s->psd_buffer);
av_freep(&s->band_psd_buffer);
av_freep(&s->mask_buffer);
av_freep(&s->qmant_buffer);
av_freep(&s->cpl_coord_exp_buffer);
av_freep(&s->cpl_coord_mant_buffer);
for (VAR_0 = 0; VAR_0 < s->num_blocks; VAR_0++) {
AC3Block *block = &s->blocks[VAR_0];
av_freep(&block->mdct_coef);
av_freep(&block->fixed_coef);
av_freep(&block->exp);
av_freep(&block->grouped_exp);
av_freep(&block->psd);
av_freep(&block->band_psd);
av_freep(&block->mask);
av_freep(&block->qmant);
av_freep(&block->cpl_coord_exp);
av_freep(&block->cpl_coord_mant);
}
s->mdct_end(s);
return 0;
} | [
"av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"int VAR_0, VAR_1;",
"AC3EncodeContext *s = avctx->priv_data;",
"av_freep(&s->windowed_samples);",
"for (VAR_1 = 0; VAR_1 < s->channels; VAR_1++)",
"av_freep(&s->planar_samples[VAR_1]);",
"av_freep(&s->planar_samples);",
"av_freep(&s->bap_buffer);",
"av_freep(&s->bap1_buffer);",
"av_freep(&s->mdct_coef_buffer);",
"av_freep(&s->fixed_coef_buffer);",
"av_freep(&s->exp_buffer);",
"av_freep(&s->grouped_exp_buffer);",
"av_freep(&s->psd_buffer);",
"av_freep(&s->band_psd_buffer);",
"av_freep(&s->mask_buffer);",
"av_freep(&s->qmant_buffer);",
"av_freep(&s->cpl_coord_exp_buffer);",
"av_freep(&s->cpl_coord_mant_buffer);",
"for (VAR_0 = 0; VAR_0 < s->num_blocks; VAR_0++) {",
"AC3Block *block = &s->blocks[VAR_0];",
"av_freep(&block->mdct_coef);",
"av_freep(&block->fixed_coef);",
"av_freep(&block->exp);",
"av_freep(&block->grouped_exp);",
"av_freep(&block->psd);",
"av_freep(&block->band_psd);",
"av_freep(&block->mask);",
"av_freep(&block->qmant);",
"av_freep(&block->cpl_coord_exp);",
"av_freep(&block->cpl_coord_mant);",
"}",
"s->mdct_end(s);",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
14
],
[
16
],
[
18
],
[
20
],
[
22
],
[
24
],
[
26
],
[
28
],
[
30
],
[
32
],
[
34
],
[
36
],
[
38
],
[
40
],
[
42
],
[
44
],
[
46
],
[
48
],
[
50
],
[
52
],
[
54
],
[
56
],
[
58
],
[
60
],
[
62
],
[
64
],
[
66
],
[
68
],
[
72
],
[
76
],
[
78
]
]
|
12,803 | static uint64_t pit_ioport_read(void *opaque, hwaddr addr,
unsigned size)
{
PITCommonState *pit = opaque;
int ret, count;
PITChannelState *s;
addr &= 3;
s = &pit->channels[addr];
if (s->status_latched) {
s->status_latched = 0;
ret = s->status;
} else if (s->count_latched) {
switch(s->count_latched) {
default:
case RW_STATE_LSB:
ret = s->latched_count & 0xff;
s->count_latched = 0;
break;
case RW_STATE_MSB:
ret = s->latched_count >> 8;
s->count_latched = 0;
break;
case RW_STATE_WORD0:
ret = s->latched_count & 0xff;
s->count_latched = RW_STATE_MSB;
break;
} else {
switch(s->read_state) {
default:
case RW_STATE_LSB:
count = pit_get_count(s);
ret = count & 0xff;
break;
case RW_STATE_MSB:
count = pit_get_count(s);
ret = (count >> 8) & 0xff;
break;
case RW_STATE_WORD0:
count = pit_get_count(s);
ret = count & 0xff;
s->read_state = RW_STATE_WORD1;
break;
case RW_STATE_WORD1:
count = pit_get_count(s);
ret = (count >> 8) & 0xff;
s->read_state = RW_STATE_WORD0;
break;
return ret; | true | qemu | d4862a87e31a51de9eb260f25c9e99a75efe3235 | static uint64_t pit_ioport_read(void *opaque, hwaddr addr,
unsigned size)
{
PITCommonState *pit = opaque;
int ret, count;
PITChannelState *s;
addr &= 3;
s = &pit->channels[addr];
if (s->status_latched) {
s->status_latched = 0;
ret = s->status;
} else if (s->count_latched) {
switch(s->count_latched) {
default:
case RW_STATE_LSB:
ret = s->latched_count & 0xff;
s->count_latched = 0;
break;
case RW_STATE_MSB:
ret = s->latched_count >> 8;
s->count_latched = 0;
break;
case RW_STATE_WORD0:
ret = s->latched_count & 0xff;
s->count_latched = RW_STATE_MSB;
break;
} else {
switch(s->read_state) {
default:
case RW_STATE_LSB:
count = pit_get_count(s);
ret = count & 0xff;
break;
case RW_STATE_MSB:
count = pit_get_count(s);
ret = (count >> 8) & 0xff;
break;
case RW_STATE_WORD0:
count = pit_get_count(s);
ret = count & 0xff;
s->read_state = RW_STATE_WORD1;
break;
case RW_STATE_WORD1:
count = pit_get_count(s);
ret = (count >> 8) & 0xff;
s->read_state = RW_STATE_WORD0;
break;
return ret; | {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(void *opaque, hwaddr addr,
unsigned size)
{
PITCommonState *pit = opaque;
int VAR_0, VAR_1;
PITChannelState *s;
addr &= 3;
s = &pit->channels[addr];
if (s->status_latched) {
s->status_latched = 0;
VAR_0 = s->status;
} else if (s->count_latched) {
switch(s->count_latched) {
default:
case RW_STATE_LSB:
VAR_0 = s->latched_count & 0xff;
s->count_latched = 0;
break;
case RW_STATE_MSB:
VAR_0 = s->latched_count >> 8;
s->count_latched = 0;
break;
case RW_STATE_WORD0:
VAR_0 = s->latched_count & 0xff;
s->count_latched = RW_STATE_MSB;
break;
} else {
switch(s->read_state) {
default:
case RW_STATE_LSB:
VAR_1 = pit_get_count(s);
VAR_0 = VAR_1 & 0xff;
break;
case RW_STATE_MSB:
VAR_1 = pit_get_count(s);
VAR_0 = (VAR_1 >> 8) & 0xff;
break;
case RW_STATE_WORD0:
VAR_1 = pit_get_count(s);
VAR_0 = VAR_1 & 0xff;
s->read_state = RW_STATE_WORD1;
break;
case RW_STATE_WORD1:
VAR_1 = pit_get_count(s);
VAR_0 = (VAR_1 >> 8) & 0xff;
s->read_state = RW_STATE_WORD0;
break;
return VAR_0; | [
"static uint64_t FUNC_0(void *opaque, hwaddr addr,\nunsigned size)\n{",
"PITCommonState *pit = opaque;",
"int VAR_0, VAR_1;",
"PITChannelState *s;",
"addr &= 3;",
"s = &pit->channels[addr];",
"if (s->status_latched) {",
"s->status_latched = 0;",
"VAR_0 = s->status;",
"} else if (s->count_latched) {",
"switch(s->count_latched) {",
"default:\ncase RW_STATE_LSB:\nVAR_0 = s->latched_count & 0xff;",
"s->count_latched = 0;",
"break;",
"case RW_STATE_MSB:\nVAR_0 = s->latched_count >> 8;",
"s->count_latched = 0;",
"break;",
"case RW_STATE_WORD0:\nVAR_0 = s->latched_count & 0xff;",
"s->count_latched = RW_STATE_MSB;",
"break;",
"} else {",
"switch(s->read_state) {",
"default:\ncase RW_STATE_LSB:\nVAR_1 = pit_get_count(s);",
"VAR_0 = VAR_1 & 0xff;",
"break;",
"case RW_STATE_MSB:\nVAR_1 = pit_get_count(s);",
"VAR_0 = (VAR_1 >> 8) & 0xff;",
"break;",
"case RW_STATE_WORD0:\nVAR_1 = pit_get_count(s);",
"VAR_0 = VAR_1 & 0xff;",
"s->read_state = RW_STATE_WORD1;",
"break;",
"case RW_STATE_WORD1:\nVAR_1 = pit_get_count(s);",
"VAR_0 = (VAR_1 >> 8) & 0xff;",
"s->read_state = RW_STATE_WORD0;",
"break;",
"return VAR_0;"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
2,
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12
],
[
13
],
[
14,
15,
16
],
[
17
],
[
18
],
[
19,
20
],
[
21
],
[
22
],
[
23,
24
],
[
25
],
[
26
],
[
27
],
[
28
],
[
29,
30,
31
],
[
32
],
[
33
],
[
34,
35
],
[
36
],
[
37
],
[
38,
39
],
[
40
],
[
41
],
[
42
],
[
43,
44
],
[
45
],
[
46
],
[
47
],
[
48
]
]
|
12,804 | static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
{
ASFContext *asf = s->priv_data;
ASFStream *asf_st = 0;
for (;;) {
int ret;
if(pb->eof_reached)
return AVERROR_EOF;
if (asf->packet_size_left < FRAME_HEADER_SIZE
|| asf->packet_segments < 1) {
//asf->packet_size_left <= asf->packet_padsize) {
int ret = asf->packet_size_left + asf->packet_padsize;
//printf("PacketLeftSize:%d Pad:%d Pos:%"PRId64"\n", asf->packet_size_left, asf->packet_padsize, avio_tell(pb));
assert(ret>=0);
/* fail safe */
avio_skip(pb, ret);
asf->packet_pos= avio_tell(pb);
if (asf->data_object_size != (uint64_t)-1 &&
(asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
return AVERROR_EOF; /* Do not exceed the size of the data object */
return 1;
}
if (asf->packet_time_start == 0) {
if(asf_read_frame_header(s, pb) < 0){
asf->packet_segments= 0;
continue;
}
if (asf->stream_index < 0
|| s->streams[asf->stream_index]->discard >= AVDISCARD_ALL
|| (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
) {
asf->packet_time_start = 0;
/* unhandled packet (should not happen) */
avio_skip(pb, asf->packet_frag_size);
asf->packet_size_left -= asf->packet_frag_size;
if(asf->stream_index < 0)
av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
continue;
}
asf->asf_st = s->streams[asf->stream_index]->priv_data;
}
asf_st = asf->asf_st;
if (asf->packet_replic_size == 1) {
// frag_offset is here used as the beginning timestamp
asf->packet_frag_timestamp = asf->packet_time_start;
asf->packet_time_start += asf->packet_time_delta;
asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
asf->packet_size_left--;
asf->packet_multi_size--;
if (asf->packet_multi_size < asf->packet_obj_size)
{
asf->packet_time_start = 0;
avio_skip(pb, asf->packet_multi_size);
asf->packet_size_left -= asf->packet_multi_size;
continue;
}
asf->packet_multi_size -= asf->packet_obj_size;
//printf("COMPRESS size %d %d %d ms:%d\n", asf->packet_obj_size, asf->packet_frag_timestamp, asf->packet_size_left, asf->packet_multi_size);
}
if( /*asf->packet_frag_size == asf->packet_obj_size*/
asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size
&& asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
asf_st->frag_offset, asf->packet_frag_size,
asf->packet_obj_size, asf_st->pkt.size);
asf->packet_obj_size= asf_st->pkt.size;
}
if ( asf_st->pkt.size != asf->packet_obj_size
|| asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) { //FIXME is this condition sufficient?
if(asf_st->pkt.data){
av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size);
asf_st->frag_offset = 0;
av_free_packet(&asf_st->pkt);
}
/* new packet */
av_new_packet(&asf_st->pkt, asf->packet_obj_size);
asf_st->seq = asf->packet_seq;
asf_st->pkt.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
asf_st->pkt.stream_index = asf->stream_index;
asf_st->pkt.pos =
asf_st->packet_pos= asf->packet_pos;
if (asf_st->pkt.data && asf_st->palette_changed) {
uint8_t *pal;
pal = av_packet_new_side_data(&asf_st->pkt, AV_PKT_DATA_PALETTE,
AVPALETTE_SIZE);
if (!pal) {
av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
} else {
memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
asf_st->palette_changed = 0;
}
}
//printf("new packet: stream:%d key:%d packet_key:%d audio:%d size:%d\n",
//asf->stream_index, asf->packet_key_frame, asf_st->pkt.flags & AV_PKT_FLAG_KEY,
//s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO, asf->packet_obj_size);
if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
asf->packet_key_frame = 1;
if (asf->packet_key_frame)
asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
}
/* read data */
//printf("READ PACKET s:%d os:%d o:%d,%d l:%d DATA:%p\n",
// s->packet_size, asf_st->pkt.size, asf->packet_frag_offset,
// asf_st->frag_offset, asf->packet_frag_size, asf_st->pkt.data);
asf->packet_size_left -= asf->packet_frag_size;
if (asf->packet_size_left < 0)
continue;
if( asf->packet_frag_offset >= asf_st->pkt.size
|| asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){
av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size);
continue;
}
ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
asf->packet_frag_size);
if (ret != asf->packet_frag_size) {
if (ret < 0 || asf->packet_frag_offset + ret == 0)
return ret < 0 ? ret : AVERROR_EOF;
if (asf_st->ds_span > 1) {
// scrambling, we can either drop it completely or fill the remainder
// TODO: should we fill the whole packet instead of just the current
// fragment?
memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
asf->packet_frag_size - ret);
ret = asf->packet_frag_size;
} else
// no scrambling, so we can return partial packets
av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
}
if (s->key && s->keylen == 20)
ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
ret);
asf_st->frag_offset += ret;
/* test if whole packet is read */
if (asf_st->frag_offset == asf_st->pkt.size) {
//workaround for macroshit radio DVR-MS files
if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
&& asf_st->pkt.size > 100){
int i;
for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++);
if(i == asf_st->pkt.size){
av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
asf_st->frag_offset = 0;
av_free_packet(&asf_st->pkt);
continue;
}
}
/* return packet */
if (asf_st->ds_span > 1) {
if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){
av_log(s, AV_LOG_ERROR, "pkt.size != ds_packet_size * ds_span (%d %d %d)\n", asf_st->pkt.size, asf_st->ds_packet_size, asf_st->ds_span);
}else{
/* packet descrambling */
uint8_t *newdata = av_malloc(asf_st->pkt.size + FF_INPUT_BUFFER_PADDING_SIZE);
if (newdata) {
int offset = 0;
memset(newdata + asf_st->pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
while (offset < asf_st->pkt.size) {
int off = offset / asf_st->ds_chunk_size;
int row = off / asf_st->ds_span;
int col = off % asf_st->ds_span;
int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
//printf("off:%d row:%d col:%d idx:%d\n", off, row, col, idx);
assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
memcpy(newdata + offset,
asf_st->pkt.data + idx * asf_st->ds_chunk_size,
asf_st->ds_chunk_size);
offset += asf_st->ds_chunk_size;
}
av_free(asf_st->pkt.data);
asf_st->pkt.data = newdata;
}
}
}
asf_st->frag_offset = 0;
*pkt= asf_st->pkt;
//printf("packet %d %d\n", asf_st->pkt.size, asf->packet_frag_size);
asf_st->pkt.size = 0;
asf_st->pkt.data = 0;
break; // packet completed
}
}
return 0;
} | true | FFmpeg | e73c6aaabff1169899184c382385fe9afae5b068 | static int ff_asf_parse_packet(AVFormatContext *s, AVIOContext *pb, AVPacket *pkt)
{
ASFContext *asf = s->priv_data;
ASFStream *asf_st = 0;
for (;;) {
int ret;
if(pb->eof_reached)
return AVERROR_EOF;
if (asf->packet_size_left < FRAME_HEADER_SIZE
|| asf->packet_segments < 1) {
int ret = asf->packet_size_left + asf->packet_padsize;
assert(ret>=0);
avio_skip(pb, ret);
asf->packet_pos= avio_tell(pb);
if (asf->data_object_size != (uint64_t)-1 &&
(asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
return AVERROR_EOF;
return 1;
}
if (asf->packet_time_start == 0) {
if(asf_read_frame_header(s, pb) < 0){
asf->packet_segments= 0;
continue;
}
if (asf->stream_index < 0
|| s->streams[asf->stream_index]->discard >= AVDISCARD_ALL
|| (!asf->packet_key_frame && s->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
) {
asf->packet_time_start = 0;
avio_skip(pb, asf->packet_frag_size);
asf->packet_size_left -= asf->packet_frag_size;
if(asf->stream_index < 0)
av_log(s, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
continue;
}
asf->asf_st = s->streams[asf->stream_index]->priv_data;
}
asf_st = asf->asf_st;
if (asf->packet_replic_size == 1) {
asf->packet_frag_timestamp = asf->packet_time_start;
asf->packet_time_start += asf->packet_time_delta;
asf->packet_obj_size = asf->packet_frag_size = avio_r8(pb);
asf->packet_size_left--;
asf->packet_multi_size--;
if (asf->packet_multi_size < asf->packet_obj_size)
{
asf->packet_time_start = 0;
avio_skip(pb, asf->packet_multi_size);
asf->packet_size_left -= asf->packet_multi_size;
continue;
}
asf->packet_multi_size -= asf->packet_obj_size;
}
if(
asf_st->frag_offset + asf->packet_frag_size <= asf_st->pkt.size
&& asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
av_log(s, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
asf_st->frag_offset, asf->packet_frag_size,
asf->packet_obj_size, asf_st->pkt.size);
asf->packet_obj_size= asf_st->pkt.size;
}
if ( asf_st->pkt.size != asf->packet_obj_size
|| asf_st->frag_offset + asf->packet_frag_size > asf_st->pkt.size) {
if(asf_st->pkt.data){
av_log(s, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->pkt.size, asf->packet_obj_size);
asf_st->frag_offset = 0;
av_free_packet(&asf_st->pkt);
}
av_new_packet(&asf_st->pkt, asf->packet_obj_size);
asf_st->seq = asf->packet_seq;
asf_st->pkt.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
asf_st->pkt.stream_index = asf->stream_index;
asf_st->pkt.pos =
asf_st->packet_pos= asf->packet_pos;
if (asf_st->pkt.data && asf_st->palette_changed) {
uint8_t *pal;
pal = av_packet_new_side_data(&asf_st->pkt, AV_PKT_DATA_PALETTE,
AVPALETTE_SIZE);
if (!pal) {
av_log(s, AV_LOG_ERROR, "Cannot append palette to packet\n");
} else {
memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
asf_st->palette_changed = 0;
}
}
if (s->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
asf->packet_key_frame = 1;
if (asf->packet_key_frame)
asf_st->pkt.flags |= AV_PKT_FLAG_KEY;
}
asf->packet_size_left -= asf->packet_frag_size;
if (asf->packet_size_left < 0)
continue;
if( asf->packet_frag_offset >= asf_st->pkt.size
|| asf->packet_frag_size > asf_st->pkt.size - asf->packet_frag_offset){
av_log(s, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
asf->packet_frag_offset, asf->packet_frag_size, asf_st->pkt.size);
continue;
}
ret = avio_read(pb, asf_st->pkt.data + asf->packet_frag_offset,
asf->packet_frag_size);
if (ret != asf->packet_frag_size) {
if (ret < 0 || asf->packet_frag_offset + ret == 0)
return ret < 0 ? ret : AVERROR_EOF;
if (asf_st->ds_span > 1) {
memset(asf_st->pkt.data + asf->packet_frag_offset + ret, 0,
asf->packet_frag_size - ret);
ret = asf->packet_frag_size;
} else
av_shrink_packet(&asf_st->pkt, asf->packet_frag_offset + ret);
}
if (s->key && s->keylen == 20)
ff_asfcrypt_dec(s->key, asf_st->pkt.data + asf->packet_frag_offset,
ret);
asf_st->frag_offset += ret;
if (asf_st->frag_offset == asf_st->pkt.size) {
if( s->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
&& asf_st->pkt.size > 100){
int i;
for(i=0; i<asf_st->pkt.size && !asf_st->pkt.data[i]; i++);
if(i == asf_st->pkt.size){
av_log(s, AV_LOG_DEBUG, "discarding ms fart\n");
asf_st->frag_offset = 0;
av_free_packet(&asf_st->pkt);
continue;
}
}
if (asf_st->ds_span > 1) {
if(asf_st->pkt.size != asf_st->ds_packet_size * asf_st->ds_span){
av_log(s, AV_LOG_ERROR, "pkt.size != ds_packet_size * ds_span (%d %d %d)\n", asf_st->pkt.size, asf_st->ds_packet_size, asf_st->ds_span);
}else{
uint8_t *newdata = av_malloc(asf_st->pkt.size + FF_INPUT_BUFFER_PADDING_SIZE);
if (newdata) {
int offset = 0;
memset(newdata + asf_st->pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
while (offset < asf_st->pkt.size) {
int off = offset / asf_st->ds_chunk_size;
int row = off / asf_st->ds_span;
int col = off % asf_st->ds_span;
int idx = row + col * asf_st->ds_packet_size / asf_st->ds_chunk_size;
assert(offset + asf_st->ds_chunk_size <= asf_st->pkt.size);
assert(idx+1 <= asf_st->pkt.size / asf_st->ds_chunk_size);
memcpy(newdata + offset,
asf_st->pkt.data + idx * asf_st->ds_chunk_size,
asf_st->ds_chunk_size);
offset += asf_st->ds_chunk_size;
}
av_free(asf_st->pkt.data);
asf_st->pkt.data = newdata;
}
}
}
asf_st->frag_offset = 0;
*pkt= asf_st->pkt;
asf_st->pkt.size = 0;
asf_st->pkt.data = 0;
break;
}
}
return 0;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1, AVPacket *VAR_2)
{
ASFContext *asf = VAR_0->priv_data;
ASFStream *asf_st = 0;
for (;;) {
int VAR_4;
if(VAR_1->eof_reached)
return AVERROR_EOF;
if (asf->packet_size_left < FRAME_HEADER_SIZE
|| asf->packet_segments < 1) {
int VAR_4 = asf->packet_size_left + asf->packet_padsize;
assert(VAR_4>=0);
avio_skip(VAR_1, VAR_4);
asf->packet_pos= avio_tell(VAR_1);
if (asf->data_object_size != (uint64_t)-1 &&
(asf->packet_pos - asf->data_object_offset >= asf->data_object_size))
return AVERROR_EOF;
return 1;
}
if (asf->packet_time_start == 0) {
if(asf_read_frame_header(VAR_0, VAR_1) < 0){
asf->packet_segments= 0;
continue;
}
if (asf->stream_index < 0
|| VAR_0->streams[asf->stream_index]->discard >= AVDISCARD_ALL
|| (!asf->packet_key_frame && VAR_0->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)
) {
asf->packet_time_start = 0;
avio_skip(VAR_1, asf->packet_frag_size);
asf->packet_size_left -= asf->packet_frag_size;
if(asf->stream_index < 0)
av_log(VAR_0, AV_LOG_ERROR, "ff asf skip %d (unknown stream)\n", asf->packet_frag_size);
continue;
}
asf->asf_st = VAR_0->streams[asf->stream_index]->priv_data;
}
asf_st = asf->asf_st;
if (asf->packet_replic_size == 1) {
asf->packet_frag_timestamp = asf->packet_time_start;
asf->packet_time_start += asf->packet_time_delta;
asf->packet_obj_size = asf->packet_frag_size = avio_r8(VAR_1);
asf->packet_size_left--;
asf->packet_multi_size--;
if (asf->packet_multi_size < asf->packet_obj_size)
{
asf->packet_time_start = 0;
avio_skip(VAR_1, asf->packet_multi_size);
asf->packet_size_left -= asf->packet_multi_size;
continue;
}
asf->packet_multi_size -= asf->packet_obj_size;
}
if(
asf_st->frag_offset + asf->packet_frag_size <= asf_st->VAR_2.size
&& asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){
av_log(VAR_0, AV_LOG_INFO, "ignoring invalid packet_obj_size (%d %d %d %d)\n",
asf_st->frag_offset, asf->packet_frag_size,
asf->packet_obj_size, asf_st->VAR_2.size);
asf->packet_obj_size= asf_st->VAR_2.size;
}
if ( asf_st->VAR_2.size != asf->packet_obj_size
|| asf_st->frag_offset + asf->packet_frag_size > asf_st->VAR_2.size) {
if(asf_st->VAR_2.data){
av_log(VAR_0, AV_LOG_INFO, "freeing incomplete packet size %d, new %d\n", asf_st->VAR_2.size, asf->packet_obj_size);
asf_st->frag_offset = 0;
av_free_packet(&asf_st->VAR_2);
}
av_new_packet(&asf_st->VAR_2, asf->packet_obj_size);
asf_st->seq = asf->packet_seq;
asf_st->VAR_2.dts = asf->packet_frag_timestamp - asf->hdr.preroll;
asf_st->VAR_2.stream_index = asf->stream_index;
asf_st->VAR_2.pos =
asf_st->packet_pos= asf->packet_pos;
if (asf_st->VAR_2.data && asf_st->palette_changed) {
uint8_t *pal;
pal = av_packet_new_side_data(&asf_st->VAR_2, AV_PKT_DATA_PALETTE,
AVPALETTE_SIZE);
if (!pal) {
av_log(VAR_0, AV_LOG_ERROR, "Cannot append palette to packet\n");
} else {
memcpy(pal, asf_st->palette, AVPALETTE_SIZE);
asf_st->palette_changed = 0;
}
}
if (VAR_0->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
asf->packet_key_frame = 1;
if (asf->packet_key_frame)
asf_st->VAR_2.flags |= AV_PKT_FLAG_KEY;
}
asf->packet_size_left -= asf->packet_frag_size;
if (asf->packet_size_left < 0)
continue;
if( asf->packet_frag_offset >= asf_st->VAR_2.size
|| asf->packet_frag_size > asf_st->VAR_2.size - asf->packet_frag_offset){
av_log(VAR_0, AV_LOG_ERROR, "packet fragment position invalid %u,%u not in %u\n",
asf->packet_frag_offset, asf->packet_frag_size, asf_st->VAR_2.size);
continue;
}
VAR_4 = avio_read(VAR_1, asf_st->VAR_2.data + asf->packet_frag_offset,
asf->packet_frag_size);
if (VAR_4 != asf->packet_frag_size) {
if (VAR_4 < 0 || asf->packet_frag_offset + VAR_4 == 0)
return VAR_4 < 0 ? VAR_4 : AVERROR_EOF;
if (asf_st->ds_span > 1) {
memset(asf_st->VAR_2.data + asf->packet_frag_offset + VAR_4, 0,
asf->packet_frag_size - VAR_4);
VAR_4 = asf->packet_frag_size;
} else
av_shrink_packet(&asf_st->VAR_2, asf->packet_frag_offset + VAR_4);
}
if (VAR_0->key && VAR_0->keylen == 20)
ff_asfcrypt_dec(VAR_0->key, asf_st->VAR_2.data + asf->packet_frag_offset,
VAR_4);
asf_st->frag_offset += VAR_4;
if (asf_st->frag_offset == asf_st->VAR_2.size) {
if( VAR_0->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO
&& asf_st->VAR_2.size > 100){
int VAR_4;
for(VAR_4=0; VAR_4<asf_st->VAR_2.size && !asf_st->VAR_2.data[VAR_4]; VAR_4++);
if(VAR_4 == asf_st->VAR_2.size){
av_log(VAR_0, AV_LOG_DEBUG, "discarding ms fart\n");
asf_st->frag_offset = 0;
av_free_packet(&asf_st->VAR_2);
continue;
}
}
if (asf_st->ds_span > 1) {
if(asf_st->VAR_2.size != asf_st->ds_packet_size * asf_st->ds_span){
av_log(VAR_0, AV_LOG_ERROR, "VAR_2.size != ds_packet_size * ds_span (%d %d %d)\n", asf_st->VAR_2.size, asf_st->ds_packet_size, asf_st->ds_span);
}else{
uint8_t *newdata = av_malloc(asf_st->VAR_2.size + FF_INPUT_BUFFER_PADDING_SIZE);
if (newdata) {
int VAR_5 = 0;
memset(newdata + asf_st->VAR_2.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
while (VAR_5 < asf_st->VAR_2.size) {
int VAR_6 = VAR_5 / asf_st->ds_chunk_size;
int VAR_7 = VAR_6 / asf_st->ds_span;
int VAR_8 = VAR_6 % asf_st->ds_span;
int VAR_9 = VAR_7 + VAR_8 * asf_st->ds_packet_size / asf_st->ds_chunk_size;
assert(VAR_5 + asf_st->ds_chunk_size <= asf_st->VAR_2.size);
assert(VAR_9+1 <= asf_st->VAR_2.size / asf_st->ds_chunk_size);
memcpy(newdata + VAR_5,
asf_st->VAR_2.data + VAR_9 * asf_st->ds_chunk_size,
asf_st->ds_chunk_size);
VAR_5 += asf_st->ds_chunk_size;
}
av_free(asf_st->VAR_2.data);
asf_st->VAR_2.data = newdata;
}
}
}
asf_st->frag_offset = 0;
*VAR_2= asf_st->VAR_2;
asf_st->VAR_2.size = 0;
asf_st->VAR_2.data = 0;
break;
}
}
return 0;
} | [
"static int FUNC_0(AVFormatContext *VAR_0, AVIOContext *VAR_1, AVPacket *VAR_2)\n{",
"ASFContext *asf = VAR_0->priv_data;",
"ASFStream *asf_st = 0;",
"for (;;) {",
"int VAR_4;",
"if(VAR_1->eof_reached)\nreturn AVERROR_EOF;",
"if (asf->packet_size_left < FRAME_HEADER_SIZE\n|| asf->packet_segments < 1) {",
"int VAR_4 = asf->packet_size_left + asf->packet_padsize;",
"assert(VAR_4>=0);",
"avio_skip(VAR_1, VAR_4);",
"asf->packet_pos= avio_tell(VAR_1);",
"if (asf->data_object_size != (uint64_t)-1 &&\n(asf->packet_pos - asf->data_object_offset >= asf->data_object_size))\nreturn AVERROR_EOF;",
"return 1;",
"}",
"if (asf->packet_time_start == 0) {",
"if(asf_read_frame_header(VAR_0, VAR_1) < 0){",
"asf->packet_segments= 0;",
"continue;",
"}",
"if (asf->stream_index < 0\n|| VAR_0->streams[asf->stream_index]->discard >= AVDISCARD_ALL\n|| (!asf->packet_key_frame && VAR_0->streams[asf->stream_index]->discard >= AVDISCARD_NONKEY)\n) {",
"asf->packet_time_start = 0;",
"avio_skip(VAR_1, asf->packet_frag_size);",
"asf->packet_size_left -= asf->packet_frag_size;",
"if(asf->stream_index < 0)\nav_log(VAR_0, AV_LOG_ERROR, \"ff asf skip %d (unknown stream)\\n\", asf->packet_frag_size);",
"continue;",
"}",
"asf->asf_st = VAR_0->streams[asf->stream_index]->priv_data;",
"}",
"asf_st = asf->asf_st;",
"if (asf->packet_replic_size == 1) {",
"asf->packet_frag_timestamp = asf->packet_time_start;",
"asf->packet_time_start += asf->packet_time_delta;",
"asf->packet_obj_size = asf->packet_frag_size = avio_r8(VAR_1);",
"asf->packet_size_left--;",
"asf->packet_multi_size--;",
"if (asf->packet_multi_size < asf->packet_obj_size)\n{",
"asf->packet_time_start = 0;",
"avio_skip(VAR_1, asf->packet_multi_size);",
"asf->packet_size_left -= asf->packet_multi_size;",
"continue;",
"}",
"asf->packet_multi_size -= asf->packet_obj_size;",
"}",
"if(\nasf_st->frag_offset + asf->packet_frag_size <= asf_st->VAR_2.size\n&& asf_st->frag_offset + asf->packet_frag_size > asf->packet_obj_size){",
"av_log(VAR_0, AV_LOG_INFO, \"ignoring invalid packet_obj_size (%d %d %d %d)\\n\",\nasf_st->frag_offset, asf->packet_frag_size,\nasf->packet_obj_size, asf_st->VAR_2.size);",
"asf->packet_obj_size= asf_st->VAR_2.size;",
"}",
"if ( asf_st->VAR_2.size != asf->packet_obj_size\n|| asf_st->frag_offset + asf->packet_frag_size > asf_st->VAR_2.size) {",
"if(asf_st->VAR_2.data){",
"av_log(VAR_0, AV_LOG_INFO, \"freeing incomplete packet size %d, new %d\\n\", asf_st->VAR_2.size, asf->packet_obj_size);",
"asf_st->frag_offset = 0;",
"av_free_packet(&asf_st->VAR_2);",
"}",
"av_new_packet(&asf_st->VAR_2, asf->packet_obj_size);",
"asf_st->seq = asf->packet_seq;",
"asf_st->VAR_2.dts = asf->packet_frag_timestamp - asf->hdr.preroll;",
"asf_st->VAR_2.stream_index = asf->stream_index;",
"asf_st->VAR_2.pos =\nasf_st->packet_pos= asf->packet_pos;",
"if (asf_st->VAR_2.data && asf_st->palette_changed) {",
"uint8_t *pal;",
"pal = av_packet_new_side_data(&asf_st->VAR_2, AV_PKT_DATA_PALETTE,\nAVPALETTE_SIZE);",
"if (!pal) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Cannot append palette to packet\\n\");",
"} else {",
"memcpy(pal, asf_st->palette, AVPALETTE_SIZE);",
"asf_st->palette_changed = 0;",
"}",
"}",
"if (VAR_0->streams[asf->stream_index]->codec->codec_type == AVMEDIA_TYPE_AUDIO)\nasf->packet_key_frame = 1;",
"if (asf->packet_key_frame)\nasf_st->VAR_2.flags |= AV_PKT_FLAG_KEY;",
"}",
"asf->packet_size_left -= asf->packet_frag_size;",
"if (asf->packet_size_left < 0)\ncontinue;",
"if( asf->packet_frag_offset >= asf_st->VAR_2.size\n|| asf->packet_frag_size > asf_st->VAR_2.size - asf->packet_frag_offset){",
"av_log(VAR_0, AV_LOG_ERROR, \"packet fragment position invalid %u,%u not in %u\\n\",\nasf->packet_frag_offset, asf->packet_frag_size, asf_st->VAR_2.size);",
"continue;",
"}",
"VAR_4 = avio_read(VAR_1, asf_st->VAR_2.data + asf->packet_frag_offset,\nasf->packet_frag_size);",
"if (VAR_4 != asf->packet_frag_size) {",
"if (VAR_4 < 0 || asf->packet_frag_offset + VAR_4 == 0)\nreturn VAR_4 < 0 ? VAR_4 : AVERROR_EOF;",
"if (asf_st->ds_span > 1) {",
"memset(asf_st->VAR_2.data + asf->packet_frag_offset + VAR_4, 0,\nasf->packet_frag_size - VAR_4);",
"VAR_4 = asf->packet_frag_size;",
"} else",
"av_shrink_packet(&asf_st->VAR_2, asf->packet_frag_offset + VAR_4);",
"}",
"if (VAR_0->key && VAR_0->keylen == 20)\nff_asfcrypt_dec(VAR_0->key, asf_st->VAR_2.data + asf->packet_frag_offset,\nVAR_4);",
"asf_st->frag_offset += VAR_4;",
"if (asf_st->frag_offset == asf_st->VAR_2.size) {",
"if( VAR_0->streams[asf->stream_index]->codec->codec_id == CODEC_ID_MPEG2VIDEO\n&& asf_st->VAR_2.size > 100){",
"int VAR_4;",
"for(VAR_4=0; VAR_4<asf_st->VAR_2.size && !asf_st->VAR_2.data[VAR_4]; VAR_4++);",
"if(VAR_4 == asf_st->VAR_2.size){",
"av_log(VAR_0, AV_LOG_DEBUG, \"discarding ms fart\\n\");",
"asf_st->frag_offset = 0;",
"av_free_packet(&asf_st->VAR_2);",
"continue;",
"}",
"}",
"if (asf_st->ds_span > 1) {",
"if(asf_st->VAR_2.size != asf_st->ds_packet_size * asf_st->ds_span){",
"av_log(VAR_0, AV_LOG_ERROR, \"VAR_2.size != ds_packet_size * ds_span (%d %d %d)\\n\", asf_st->VAR_2.size, asf_st->ds_packet_size, asf_st->ds_span);",
"}else{",
"uint8_t *newdata = av_malloc(asf_st->VAR_2.size + FF_INPUT_BUFFER_PADDING_SIZE);",
"if (newdata) {",
"int VAR_5 = 0;",
"memset(newdata + asf_st->VAR_2.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);",
"while (VAR_5 < asf_st->VAR_2.size) {",
"int VAR_6 = VAR_5 / asf_st->ds_chunk_size;",
"int VAR_7 = VAR_6 / asf_st->ds_span;",
"int VAR_8 = VAR_6 % asf_st->ds_span;",
"int VAR_9 = VAR_7 + VAR_8 * asf_st->ds_packet_size / asf_st->ds_chunk_size;",
"assert(VAR_5 + asf_st->ds_chunk_size <= asf_st->VAR_2.size);",
"assert(VAR_9+1 <= asf_st->VAR_2.size / asf_st->ds_chunk_size);",
"memcpy(newdata + VAR_5,\nasf_st->VAR_2.data + VAR_9 * asf_st->ds_chunk_size,\nasf_st->ds_chunk_size);",
"VAR_5 += asf_st->ds_chunk_size;",
"}",
"av_free(asf_st->VAR_2.data);",
"asf_st->VAR_2.data = newdata;",
"}",
"}",
"}",
"asf_st->frag_offset = 0;",
"*VAR_2= asf_st->VAR_2;",
"asf_st->VAR_2.size = 0;",
"asf_st->VAR_2.data = 0;",
"break;",
"}",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17,
19
],
[
23
],
[
27
],
[
31
],
[
35
],
[
37,
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57,
59,
61,
63
],
[
65
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
121
],
[
123,
125,
127
],
[
129,
131,
133
],
[
135
],
[
137
],
[
141,
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165,
167
],
[
169
],
[
171
],
[
173,
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
197,
199
],
[
201,
203
],
[
205
],
[
217
],
[
219,
221
],
[
225,
227
],
[
229,
231
],
[
233
],
[
235
],
[
239,
241
],
[
243
],
[
245,
247
],
[
249
],
[
257,
259
],
[
261
],
[
263
],
[
267
],
[
269
],
[
271,
273,
275
],
[
277
],
[
281
],
[
285,
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303
],
[
305
],
[
311
],
[
313
],
[
315
],
[
317
],
[
321
],
[
323
],
[
325
],
[
327
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
343
],
[
345
],
[
347,
349,
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
373
],
[
375
],
[
379
],
[
381
],
[
383
],
[
385
],
[
387
]
]
|
12,806 | static int h264_slice_header_init(H264Context *h, int reinit)
{
MpegEncContext *const s = &h->s;
int i, ret;
if( FFALIGN(s->avctx->width , 16 ) == s->width
&& FFALIGN(s->avctx->height, 16*(2 - h->sps.frame_mbs_only_flag)) == s->height
&& !h->sps.crop_right && !h->sps.crop_bottom
&& (s->avctx->width != s->width || s->avctx->height && s->height)
) {
av_log(h->s.avctx, AV_LOG_DEBUG, "Using externally provided dimensions\n");
s->avctx->coded_width = s->width;
s->avctx->coded_height = s->height;
} else{
avcodec_set_dimensions(s->avctx, s->width, s->height);
s->avctx->width -= (2>>CHROMA444)*FFMIN(h->sps.crop_right, (8<<CHROMA444)-1);
s->avctx->height -= (1<<s->chroma_y_shift)*FFMIN(h->sps.crop_bottom, (16>>s->chroma_y_shift)-1) * (2 - h->sps.frame_mbs_only_flag);
}
s->avctx->sample_aspect_ratio = h->sps.sar;
av_assert0(s->avctx->sample_aspect_ratio.den);
if (h->sps.timing_info_present_flag) {
int64_t den = h->sps.time_scale;
if (h->x264_build < 44U)
den *= 2;
av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
h->sps.num_units_in_tick, den, 1 << 30);
}
s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
if (reinit) {
free_tables(h, 0);
if ((ret = ff_MPV_common_frame_size_change(s)) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "ff_MPV_common_frame_size_change() failed.\n");
return ret;
}
} else {
if ((ret = ff_MPV_common_init(s) < 0)) {
av_log(h->s.avctx, AV_LOG_ERROR, "ff_MPV_common_init() failed.\n");
return ret;
}
}
s->first_field = 0;
h->prev_interlaced_frame = 1;
init_scan_tables(h);
if (ff_h264_alloc_tables(h) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR,
"Could not allocate memory for h264\n");
return AVERROR(ENOMEM);
}
if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_SLICE)) {
if (context_init(h) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1;
}
} else {
for (i = 1; i < s->slice_context_count; i++) {
H264Context *c;
c = h->thread_context[i] = av_malloc(sizeof(H264Context));
memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
c->h264dsp = h->h264dsp;
c->sps = h->sps;
c->pps = h->pps;
c->pixel_shift = h->pixel_shift;
c->cur_chroma_format_idc = h->cur_chroma_format_idc;
init_scan_tables(c);
clone_tables(c, h, i);
}
for (i = 0; i < s->slice_context_count; i++)
if (context_init(h->thread_context[i]) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1;
}
}
return 0;
}
| true | FFmpeg | c13e4e288c84ba0629ead15e1460c0e498ee2bce | static int h264_slice_header_init(H264Context *h, int reinit)
{
MpegEncContext *const s = &h->s;
int i, ret;
if( FFALIGN(s->avctx->width , 16 ) == s->width
&& FFALIGN(s->avctx->height, 16*(2 - h->sps.frame_mbs_only_flag)) == s->height
&& !h->sps.crop_right && !h->sps.crop_bottom
&& (s->avctx->width != s->width || s->avctx->height && s->height)
) {
av_log(h->s.avctx, AV_LOG_DEBUG, "Using externally provided dimensions\n");
s->avctx->coded_width = s->width;
s->avctx->coded_height = s->height;
} else{
avcodec_set_dimensions(s->avctx, s->width, s->height);
s->avctx->width -= (2>>CHROMA444)*FFMIN(h->sps.crop_right, (8<<CHROMA444)-1);
s->avctx->height -= (1<<s->chroma_y_shift)*FFMIN(h->sps.crop_bottom, (16>>s->chroma_y_shift)-1) * (2 - h->sps.frame_mbs_only_flag);
}
s->avctx->sample_aspect_ratio = h->sps.sar;
av_assert0(s->avctx->sample_aspect_ratio.den);
if (h->sps.timing_info_present_flag) {
int64_t den = h->sps.time_scale;
if (h->x264_build < 44U)
den *= 2;
av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
h->sps.num_units_in_tick, den, 1 << 30);
}
s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
if (reinit) {
free_tables(h, 0);
if ((ret = ff_MPV_common_frame_size_change(s)) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "ff_MPV_common_frame_size_change() failed.\n");
return ret;
}
} else {
if ((ret = ff_MPV_common_init(s) < 0)) {
av_log(h->s.avctx, AV_LOG_ERROR, "ff_MPV_common_init() failed.\n");
return ret;
}
}
s->first_field = 0;
h->prev_interlaced_frame = 1;
init_scan_tables(h);
if (ff_h264_alloc_tables(h) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR,
"Could not allocate memory for h264\n");
return AVERROR(ENOMEM);
}
if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_SLICE)) {
if (context_init(h) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1;
}
} else {
for (i = 1; i < s->slice_context_count; i++) {
H264Context *c;
c = h->thread_context[i] = av_malloc(sizeof(H264Context));
memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
c->h264dsp = h->h264dsp;
c->sps = h->sps;
c->pps = h->pps;
c->pixel_shift = h->pixel_shift;
c->cur_chroma_format_idc = h->cur_chroma_format_idc;
init_scan_tables(c);
clone_tables(c, h, i);
}
for (i = 0; i < s->slice_context_count; i++)
if (context_init(h->thread_context[i]) < 0) {
av_log(h->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1;
}
}
return 0;
}
| {
"code": [
" if ((ret = ff_MPV_common_init(s) < 0)) {"
],
"line_no": [
79
]
} | static int FUNC_0(H264Context *VAR_0, int VAR_1)
{
MpegEncContext *const s = &VAR_0->s;
int VAR_2, VAR_3;
if( FFALIGN(s->avctx->width , 16 ) == s->width
&& FFALIGN(s->avctx->height, 16*(2 - VAR_0->sps.frame_mbs_only_flag)) == s->height
&& !VAR_0->sps.crop_right && !VAR_0->sps.crop_bottom
&& (s->avctx->width != s->width || s->avctx->height && s->height)
) {
av_log(VAR_0->s.avctx, AV_LOG_DEBUG, "Using externally provided dimensions\n");
s->avctx->coded_width = s->width;
s->avctx->coded_height = s->height;
} else{
avcodec_set_dimensions(s->avctx, s->width, s->height);
s->avctx->width -= (2>>CHROMA444)*FFMIN(VAR_0->sps.crop_right, (8<<CHROMA444)-1);
s->avctx->height -= (1<<s->chroma_y_shift)*FFMIN(VAR_0->sps.crop_bottom, (16>>s->chroma_y_shift)-1) * (2 - VAR_0->sps.frame_mbs_only_flag);
}
s->avctx->sample_aspect_ratio = VAR_0->sps.sar;
av_assert0(s->avctx->sample_aspect_ratio.den);
if (VAR_0->sps.timing_info_present_flag) {
int64_t den = VAR_0->sps.time_scale;
if (VAR_0->x264_build < 44U)
den *= 2;
av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,
VAR_0->sps.num_units_in_tick, den, 1 << 30);
}
s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);
if (VAR_1) {
free_tables(VAR_0, 0);
if ((VAR_3 = ff_MPV_common_frame_size_change(s)) < 0) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "ff_MPV_common_frame_size_change() failed.\n");
return VAR_3;
}
} else {
if ((VAR_3 = ff_MPV_common_init(s) < 0)) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "ff_MPV_common_init() failed.\n");
return VAR_3;
}
}
s->first_field = 0;
VAR_0->prev_interlaced_frame = 1;
init_scan_tables(VAR_0);
if (ff_h264_alloc_tables(VAR_0) < 0) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR,
"Could not allocate memory for h264\n");
return AVERROR(ENOMEM);
}
if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_SLICE)) {
if (context_init(VAR_0) < 0) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1;
}
} else {
for (VAR_2 = 1; VAR_2 < s->slice_context_count; VAR_2++) {
H264Context *c;
c = VAR_0->thread_context[VAR_2] = av_malloc(sizeof(H264Context));
memcpy(c, VAR_0->s.thread_context[VAR_2], sizeof(MpegEncContext));
memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
c->h264dsp = VAR_0->h264dsp;
c->sps = VAR_0->sps;
c->pps = VAR_0->pps;
c->pixel_shift = VAR_0->pixel_shift;
c->cur_chroma_format_idc = VAR_0->cur_chroma_format_idc;
init_scan_tables(c);
clone_tables(c, VAR_0, VAR_2);
}
for (VAR_2 = 0; VAR_2 < s->slice_context_count; VAR_2++)
if (context_init(VAR_0->thread_context[VAR_2]) < 0) {
av_log(VAR_0->s.avctx, AV_LOG_ERROR, "context_init() failed.\n");
return -1;
}
}
return 0;
}
| [
"static int FUNC_0(H264Context *VAR_0, int VAR_1)\n{",
"MpegEncContext *const s = &VAR_0->s;",
"int VAR_2, VAR_3;",
"if( FFALIGN(s->avctx->width , 16 ) == s->width\n&& FFALIGN(s->avctx->height, 16*(2 - VAR_0->sps.frame_mbs_only_flag)) == s->height\n&& !VAR_0->sps.crop_right && !VAR_0->sps.crop_bottom\n&& (s->avctx->width != s->width || s->avctx->height && s->height)\n) {",
"av_log(VAR_0->s.avctx, AV_LOG_DEBUG, \"Using externally provided dimensions\\n\");",
"s->avctx->coded_width = s->width;",
"s->avctx->coded_height = s->height;",
"} else{",
"avcodec_set_dimensions(s->avctx, s->width, s->height);",
"s->avctx->width -= (2>>CHROMA444)*FFMIN(VAR_0->sps.crop_right, (8<<CHROMA444)-1);",
"s->avctx->height -= (1<<s->chroma_y_shift)*FFMIN(VAR_0->sps.crop_bottom, (16>>s->chroma_y_shift)-1) * (2 - VAR_0->sps.frame_mbs_only_flag);",
"}",
"s->avctx->sample_aspect_ratio = VAR_0->sps.sar;",
"av_assert0(s->avctx->sample_aspect_ratio.den);",
"if (VAR_0->sps.timing_info_present_flag) {",
"int64_t den = VAR_0->sps.time_scale;",
"if (VAR_0->x264_build < 44U)\nden *= 2;",
"av_reduce(&s->avctx->time_base.num, &s->avctx->time_base.den,\nVAR_0->sps.num_units_in_tick, den, 1 << 30);",
"}",
"s->avctx->hwaccel = ff_find_hwaccel(s->avctx->codec->id, s->avctx->pix_fmt);",
"if (VAR_1) {",
"free_tables(VAR_0, 0);",
"if ((VAR_3 = ff_MPV_common_frame_size_change(s)) < 0) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"ff_MPV_common_frame_size_change() failed.\\n\");",
"return VAR_3;",
"}",
"} else {",
"if ((VAR_3 = ff_MPV_common_init(s) < 0)) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"ff_MPV_common_init() failed.\\n\");",
"return VAR_3;",
"}",
"}",
"s->first_field = 0;",
"VAR_0->prev_interlaced_frame = 1;",
"init_scan_tables(VAR_0);",
"if (ff_h264_alloc_tables(VAR_0) < 0) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR,\n\"Could not allocate memory for h264\\n\");",
"return AVERROR(ENOMEM);",
"}",
"if (!HAVE_THREADS || !(s->avctx->active_thread_type & FF_THREAD_SLICE)) {",
"if (context_init(VAR_0) < 0) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"context_init() failed.\\n\");",
"return -1;",
"}",
"} else {",
"for (VAR_2 = 1; VAR_2 < s->slice_context_count; VAR_2++) {",
"H264Context *c;",
"c = VAR_0->thread_context[VAR_2] = av_malloc(sizeof(H264Context));",
"memcpy(c, VAR_0->s.thread_context[VAR_2], sizeof(MpegEncContext));",
"memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));",
"c->h264dsp = VAR_0->h264dsp;",
"c->sps = VAR_0->sps;",
"c->pps = VAR_0->pps;",
"c->pixel_shift = VAR_0->pixel_shift;",
"c->cur_chroma_format_idc = VAR_0->cur_chroma_format_idc;",
"init_scan_tables(c);",
"clone_tables(c, VAR_0, VAR_2);",
"}",
"for (VAR_2 = 0; VAR_2 < s->slice_context_count; VAR_2++)",
"if (context_init(VAR_0->thread_context[VAR_2]) < 0) {",
"av_log(VAR_0->s.avctx, AV_LOG_ERROR, \"context_init() failed.\\n\");",
"return -1;",
"}",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11,
13,
15,
17,
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49,
51
],
[
53,
55
],
[
57
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99,
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
163
],
[
165
]
]
|
12,807 | void qpci_io_writeb(QPCIDevice *dev, void *data, uint8_t value)
{
uintptr_t addr = (uintptr_t)data;
if (addr < QPCI_PIO_LIMIT) {
dev->bus->pio_writeb(dev->bus, addr, value);
} else {
dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));
}
}
| true | qemu | b4ba67d9a702507793c2724e56f98e9b0f7be02b | void qpci_io_writeb(QPCIDevice *dev, void *data, uint8_t value)
{
uintptr_t addr = (uintptr_t)data;
if (addr < QPCI_PIO_LIMIT) {
dev->bus->pio_writeb(dev->bus, addr, value);
} else {
dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));
}
}
| {
"code": [
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
"void qpci_io_writeb(QPCIDevice *dev, void *data, uint8_t value)",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" dev->bus->pio_writeb(dev->bus, addr, value);",
" dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));",
" uintptr_t addr = (uintptr_t)data;",
" if (addr < QPCI_PIO_LIMIT) {",
" dev->bus->memwrite(dev->bus, addr, &value, sizeof(value));",
" uintptr_t addr = (uintptr_t)data;",
" uintptr_t addr = (uintptr_t)data;"
],
"line_no": [
5,
9,
5,
9,
5,
9,
5,
9,
1,
5,
9,
11,
15,
5,
9,
15,
5,
9,
15,
5,
9,
15,
5,
5
]
} | void FUNC_0(QPCIDevice *VAR_0, void *VAR_1, uint8_t VAR_2)
{
uintptr_t addr = (uintptr_t)VAR_1;
if (addr < QPCI_PIO_LIMIT) {
VAR_0->bus->pio_writeb(VAR_0->bus, addr, VAR_2);
} else {
VAR_0->bus->memwrite(VAR_0->bus, addr, &VAR_2, sizeof(VAR_2));
}
}
| [
"void FUNC_0(QPCIDevice *VAR_0, void *VAR_1, uint8_t VAR_2)\n{",
"uintptr_t addr = (uintptr_t)VAR_1;",
"if (addr < QPCI_PIO_LIMIT) {",
"VAR_0->bus->pio_writeb(VAR_0->bus, addr, VAR_2);",
"} else {",
"VAR_0->bus->memwrite(VAR_0->bus, addr, &VAR_2, sizeof(VAR_2));",
"}",
"}"
]
| [
1,
1,
1,
1,
0,
1,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
]
|
12,808 | static inline void RENAME(hyscale)(uint16_t *dst, long dstWidth, uint8_t *src, int srcW, int xInc,
int flags, int canMMX2BeUsed, int16_t *hLumFilter,
int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode,
int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,
int32_t *mmx2FilterPos, uint8_t *pal)
{
if(srcFormat==PIX_FMT_YUYV422 || srcFormat==PIX_FMT_GRAY16BE)
{
RENAME(yuy2ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_UYVY422 || srcFormat==PIX_FMT_GRAY16LE)
{
RENAME(uyvyToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB32)
{
RENAME(bgr32ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR24)
{
RENAME(bgr24ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR565)
{
RENAME(bgr16ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR555)
{
RENAME(bgr15ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR32)
{
RENAME(rgb32ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB24)
{
RENAME(rgb24ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB565)
{
RENAME(rgb16ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB555)
{
RENAME(rgb15ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)
{
RENAME(palToY)(formatConvBuffer, src, srcW, pal);
src= formatConvBuffer;
}
#ifdef HAVE_MMX
// use the new MMX scaler if the mmx2 can't be used (its faster than the x86asm one)
if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
if(!(flags&SWS_FAST_BILINEAR))
#endif
{
RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
}
else // Fast Bilinear upscale / crap downscale
{
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
int i;
#if defined(PIC)
uint64_t ebxsave __attribute__((aligned(8)));
#endif
if(canMMX2BeUsed)
{
asm volatile(
#if defined(PIC)
"mov %%"REG_b", %5 \n\t"
#endif
"pxor %%mm7, %%mm7 \n\t"
"mov %0, %%"REG_c" \n\t"
"mov %1, %%"REG_D" \n\t"
"mov %2, %%"REG_d" \n\t"
"mov %3, %%"REG_b" \n\t"
"xor %%"REG_a", %%"REG_a" \n\t" // i
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
#ifdef ARCH_X86_64
#define FUNNY_Y_CODE \
"movl (%%"REG_b"), %%esi \n\t"\
"call *%4 \n\t"\
"movl (%%"REG_b", %%"REG_a"), %%esi\n\t"\
"add %%"REG_S", %%"REG_c" \n\t"\
"add %%"REG_a", %%"REG_D" \n\t"\
"xor %%"REG_a", %%"REG_a" \n\t"\
#else
#define FUNNY_Y_CODE \
"movl (%%"REG_b"), %%esi \n\t"\
"call *%4 \n\t"\
"addl (%%"REG_b", %%"REG_a"), %%"REG_c"\n\t"\
"add %%"REG_a", %%"REG_D" \n\t"\
"xor %%"REG_a", %%"REG_a" \n\t"\
#endif
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
#if defined(PIC)
"mov %5, %%"REG_b" \n\t"
#endif
:: "m" (src), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),
"m" (funnyYCode)
#if defined(PIC)
,"m" (ebxsave)
#endif
: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
#if !defined(PIC)
,"%"REG_b
#endif
);
for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;
}
else
{
#endif
long xInc_shr16 = xInc >> 16;
uint16_t xInc_mask = xInc & 0xffff;
//NO MMX just normal asm ...
asm volatile(
"xor %%"REG_a", %%"REG_a" \n\t" // i
"xor %%"REG_d", %%"REG_d" \n\t" // xx
"xorl %%ecx, %%ecx \n\t" // 2*xalpha
ASMALIGN(4)
"1: \n\t"
"movzbl (%0, %%"REG_d"), %%edi \n\t" //src[xx]
"movzbl 1(%0, %%"REG_d"), %%esi \n\t" //src[xx+1]
"subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]
"imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha
"shll $16, %%edi \n\t"
"addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)
"mov %1, %%"REG_D" \n\t"
"shrl $9, %%esi \n\t"
"movw %%si, (%%"REG_D", %%"REG_a", 2)\n\t"
"addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF
"adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry
"movzbl (%0, %%"REG_d"), %%edi \n\t" //src[xx]
"movzbl 1(%0, %%"REG_d"), %%esi \n\t" //src[xx+1]
"subl %%edi, %%esi \n\t" //src[xx+1] - src[xx]
"imull %%ecx, %%esi \n\t" //(src[xx+1] - src[xx])*2*xalpha
"shll $16, %%edi \n\t"
"addl %%edi, %%esi \n\t" //src[xx+1]*2*xalpha + src[xx]*(1-2*xalpha)
"mov %1, %%"REG_D" \n\t"
"shrl $9, %%esi \n\t"
"movw %%si, 2(%%"REG_D", %%"REG_a", 2)\n\t"
"addw %4, %%cx \n\t" //2*xalpha += xInc&0xFF
"adc %3, %%"REG_d" \n\t" //xx+= xInc>>8 + carry
"add $2, %%"REG_a" \n\t"
"cmp %2, %%"REG_a" \n\t"
" jb 1b \n\t"
:: "r" (src), "m" (dst), "m" (dstWidth), "m" (xInc_shr16), "m" (xInc_mask)
: "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"
);
#ifdef HAVE_MMX2
} //if MMX2 can't be used
#endif
#else
int i;
unsigned int xpos=0;
for(i=0;i<dstWidth;i++)
{
register unsigned int xx=xpos>>16;
register unsigned int xalpha=(xpos&0xFFFF)>>9;
dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;
xpos+=xInc;
}
#endif
}
}
| true | FFmpeg | 2da0d70d5eebe42f9fcd27ee554419ebe2a5da06 | static inline void RENAME(hyscale)(uint16_t *dst, long dstWidth, uint8_t *src, int srcW, int xInc,
int flags, int canMMX2BeUsed, int16_t *hLumFilter,
int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode,
int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,
int32_t *mmx2FilterPos, uint8_t *pal)
{
if(srcFormat==PIX_FMT_YUYV422 || srcFormat==PIX_FMT_GRAY16BE)
{
RENAME(yuy2ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_UYVY422 || srcFormat==PIX_FMT_GRAY16LE)
{
RENAME(uyvyToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB32)
{
RENAME(bgr32ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR24)
{
RENAME(bgr24ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR565)
{
RENAME(bgr16ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR555)
{
RENAME(bgr15ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR32)
{
RENAME(rgb32ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB24)
{
RENAME(rgb24ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB565)
{
RENAME(rgb16ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB555)
{
RENAME(rgb15ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)
{
RENAME(palToY)(formatConvBuffer, src, srcW, pal);
src= formatConvBuffer;
}
#ifdef HAVE_MMX
if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
if(!(flags&SWS_FAST_BILINEAR))
#endif
{
RENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
}
else
{
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
int i;
#if defined(PIC)
uint64_t ebxsave __attribute__((aligned(8)));
#endif
if(canMMX2BeUsed)
{
asm volatile(
#if defined(PIC)
"mov %%"REG_b", %5 \n\t"
#endif
"pxor %%mm7, %%mm7 \n\t"
"mov %0, %%"REG_c" \n\t"
"mov %1, %%"REG_D" \n\t"
"mov %2, %%"REG_d" \n\t"
"mov %3, %%"REG_b" \n\t"
"xor %%"REG_a", %%"REG_a" \n\t"
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
#ifdef ARCH_X86_64
#define FUNNY_Y_CODE \
"movl (%%"REG_b"), %%esi \n\t"\
"call *%4 \n\t"\
"movl (%%"REG_b", %%"REG_a"), %%esi\n\t"\
"add %%"REG_S", %%"REG_c" \n\t"\
"add %%"REG_a", %%"REG_D" \n\t"\
"xor %%"REG_a", %%"REG_a" \n\t"\
#else
#define FUNNY_Y_CODE \
"movl (%%"REG_b"), %%esi \n\t"\
"call *%4 \n\t"\
"addl (%%"REG_b", %%"REG_a"), %%"REG_c"\n\t"\
"add %%"REG_a", %%"REG_D" \n\t"\
"xor %%"REG_a", %%"REG_a" \n\t"\
#endif
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
#if defined(PIC)
"mov %5, %%"REG_b" \n\t"
#endif
:: "m" (src), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),
"m" (funnyYCode)
#if defined(PIC)
,"m" (ebxsave)
#endif
: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
#if !defined(PIC)
,"%"REG_b
#endif
);
for(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;
}
else
{
#endif
long xInc_shr16 = xInc >> 16;
uint16_t xInc_mask = xInc & 0xffff;
asm volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
"xor %%"REG_d", %%"REG_d" \n\t"
"xorl %%ecx, %%ecx \n\t"
ASMALIGN(4)
"1: \n\t"
"movzbl (%0, %%"REG_d"), %%edi \n\t"
"movzbl 1(%0, %%"REG_d"), %%esi \n\t"
"subl %%edi, %%esi \n\t" - src[xx]
"imull %%ecx, %%esi \n\t"
"shll $16, %%edi \n\t"
"addl %%edi, %%esi \n\t" *2*xalpha + src[xx]*(1-2*xalpha)
"mov %1, %%"REG_D" \n\t"
"shrl $9, %%esi \n\t"
"movw %%si, (%%"REG_D", %%"REG_a", 2)\n\t"
"addw %4, %%cx \n\t"
"adc %3, %%"REG_d" \n\t"
"movzbl (%0, %%"REG_d"), %%edi \n\t"
"movzbl 1(%0, %%"REG_d"), %%esi \n\t"
"subl %%edi, %%esi \n\t" - src[xx]
"imull %%ecx, %%esi \n\t"
"shll $16, %%edi \n\t"
"addl %%edi, %%esi \n\t" *2*xalpha + src[xx]*(1-2*xalpha)
"mov %1, %%"REG_D" \n\t"
"shrl $9, %%esi \n\t"
"movw %%si, 2(%%"REG_D", %%"REG_a", 2)\n\t"
"addw %4, %%cx \n\t"
"adc %3, %%"REG_d" \n\t"
"add $2, %%"REG_a" \n\t"
"cmp %2, %%"REG_a" \n\t"
" jb 1b \n\t"
:: "r" (src), "m" (dst), "m" (dstWidth), "m" (xInc_shr16), "m" (xInc_mask)
: "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"
);
#ifdef HAVE_MMX2
}
#endif
#else
int i;
unsigned int xpos=0;
for(i=0;i<dstWidth;i++)
{
register unsigned int xx=xpos>>16;
register unsigned int xalpha=(xpos&0xFFFF)>>9;
dst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;
xpos+=xInc;
}
#endif
}
}
| {
"code": [
"\t\t\t\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\",
"\t\t\t\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\",
"\t\tasm volatile(",
"\t\tasm volatile(",
"\tasm volatile(",
"\tint i;",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"\tint i;",
"#endif",
"#endif",
"#endif",
"#endif",
"\tint i;",
"#endif",
"#endif",
"#endif",
"#endif",
"#endif",
"\tasm volatile(",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"\tint i;",
"\tasm volatile(",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"\tint i;",
"#endif",
"\tasm volatile(",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"\tint i;",
"\tasm volatile(",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"\tint i;",
"#endif",
"\tint i;",
"\tint i;",
"\tasm volatile(",
"\t\tASMALIGN(4)",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"#endif",
"#endif",
"\tint i;",
"\tasm volatile(",
"\t\tASMALIGN(4)",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"#endif",
"#endif",
"#endif",
"#endif",
"\tint i;",
"#endif",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\tint i;",
"\t\tasm volatile(",
"#endif",
"\t\t\t\"pxor %%mm7, %%mm7\t\t\\n\\t\"",
"#endif",
"\t\t);",
"\t\tasm volatile(",
"#endif",
"\t\t\t\"pxor %%mm7, %%mm7\t\t\\n\\t\"",
"#endif",
"\t\t);",
"\t\tasm volatile(",
"\t\t\t\"pxor %%mm7, %%mm7\t\t\\n\\t\"",
"\t\t);",
"\tint i;",
"\t\t\t\t int flags, int canMMX2BeUsed, int16_t *hLumFilter,",
"\t\t\t\t int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode,",
"\t\t\t\t int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,",
"\t\t\t\t int32_t *mmx2FilterPos, uint8_t *pal)",
" if(srcFormat==PIX_FMT_YUYV422 || srcFormat==PIX_FMT_GRAY16BE)",
"\tRENAME(yuy2ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_UYVY422 || srcFormat==PIX_FMT_GRAY16LE)",
"\tRENAME(uyvyToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_RGB32)",
"\tRENAME(bgr32ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_BGR24)",
"\tRENAME(bgr24ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_BGR565)",
"\tRENAME(bgr16ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_BGR555)",
"\tRENAME(bgr15ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_BGR32)",
"\tRENAME(rgb32ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_RGB24)",
"\tRENAME(rgb24ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_RGB565)",
"\tRENAME(rgb16ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_RGB555)",
"\tRENAME(rgb15ToY)(formatConvBuffer, src, srcW);",
"\tsrc= formatConvBuffer;",
" else if(srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)",
"\tRENAME(palToY)(formatConvBuffer, src, srcW, pal);",
"\tsrc= formatConvBuffer;",
" if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))",
" if(!(flags&SWS_FAST_BILINEAR))",
" \tRENAME(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);",
"\tint i;",
"\tuint64_t ebxsave __attribute__((aligned(8)));",
"\tif(canMMX2BeUsed)",
"\t\tasm volatile(",
"\t\t\t\"mov %%\"REG_b\", %5 \\n\\t\"",
"#endif",
"\t\t\t\"pxor %%mm7, %%mm7\t\t\\n\\t\"",
"\t\t\t\"mov %0, %%\"REG_c\"\t\t\\n\\t\"",
"\t\t\t\"mov %1, %%\"REG_D\"\t\t\\n\\t\"",
"\t\t\t\"mov %2, %%\"REG_d\"\t\t\\n\\t\"",
"\t\t\t\"mov %3, %%\"REG_b\"\t\t\\n\\t\"",
"\t\t\tPREFETCH\" (%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\tPREFETCH\" 32(%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\tPREFETCH\" 64(%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\t\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\",
"\t\t\t\"call *%4\t\t\t\\n\\t\"\\",
"\t\t\t\"movl (%%\"REG_b\", %%\"REG_a\"), %%esi\\n\\t\"\\",
"\t\t\t\"add %%\"REG_S\", %%\"REG_c\"\t\\n\\t\"\\",
"\t\t\t\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\",
"\t\t\t\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\",
"\t\t\t\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\",
"\t\t\t\"call *%4\t\t\t\\n\\t\"\\",
"\t\t\t\"addl (%%\"REG_b\", %%\"REG_a\"), %%\"REG_c\"\\n\\t\"\\",
"\t\t\t\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\",
"\t\t\t\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\",
"\t\t\t\"mov %5, %%\"REG_b\" \\n\\t\"",
"\t\t\t:: \"m\" (src), \"m\" (dst), \"m\" (mmx2Filter), \"m\" (mmx2FilterPos),",
"\t\t\t\"m\" (funnyYCode)",
"\t\t\t,\"m\" (ebxsave)",
"\t\t\t: \"%\"REG_a, \"%\"REG_c, \"%\"REG_d, \"%\"REG_S, \"%\"REG_D",
"\t\t\t,\"%\"REG_b",
"#endif",
"\t\t);",
"\t\tfor(i=dstWidth-1; (i*xInc)>>16 >=srcW-1; i--) dst[i] = src[srcW-1]*128;",
"#endif",
"\tlong xInc_shr16 = xInc >> 16;",
"\tuint16_t xInc_mask = xInc & 0xffff;",
"\tasm volatile(",
"\t\tASMALIGN(4)",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"\t\t\"shll $16, %%edi\t\t\\n\\t\"",
"\t\t\"mov %1, %%\"REG_D\"\t\t\\n\\t\"",
"\t\t\"shrl $9, %%esi\t\t\t\\n\\t\"",
"\t\t\"movw %%si, (%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"",
"\t\t\"shll $16, %%edi\t\t\\n\\t\"",
"\t\t\"mov %1, %%\"REG_D\"\t\t\\n\\t\"",
"\t\t\"shrl $9, %%esi\t\t\t\\n\\t\"",
"\t\t\"movw %%si, 2(%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"",
"\t\t\"add $2, %%\"REG_a\"\t\t\\n\\t\"",
"\t\t\"cmp %2, %%\"REG_a\"\t\t\\n\\t\"",
"\t\t\" jb 1b\t\t\t\t\\n\\t\"",
"\t\t:: \"r\" (src), \"m\" (dst), \"m\" (dstWidth), \"m\" (xInc_shr16), \"m\" (xInc_mask)",
"\t\t: \"%\"REG_a, \"%\"REG_d, \"%ecx\", \"%\"REG_D, \"%esi\"",
"\t\t);",
"\tint i;",
"\tunsigned int xpos=0;",
"\tfor(i=0;i<dstWidth;i++)",
"\t\tregister unsigned int xx=xpos>>16;",
"\t\tregister unsigned int xalpha=(xpos&0xFFFF)>>9;",
"\t\tdst[i]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;",
"\t\txpos+=xInc;",
"\t\t\t\t int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,",
"\t\t\t\t int32_t *mmx2FilterPos, uint8_t *pal)",
" else if(srcFormat==PIX_FMT_RGB32)",
" else if(srcFormat==PIX_FMT_BGR24)",
" else if(srcFormat==PIX_FMT_BGR565)",
" else if(srcFormat==PIX_FMT_BGR555)",
" else if(srcFormat==PIX_FMT_BGR32)",
" else if(srcFormat==PIX_FMT_RGB24)",
" else if(srcFormat==PIX_FMT_RGB565)",
" else if(srcFormat==PIX_FMT_RGB555)",
" else if(srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)",
" if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))",
" if(!(flags&SWS_FAST_BILINEAR))",
"\tint i;",
"\tuint64_t ebxsave __attribute__((aligned(8)));",
"\tif(canMMX2BeUsed)",
"\t\tasm volatile(",
"#endif",
"\t\t\t\"pxor %%mm7, %%mm7\t\t\\n\\t\"",
"\t\t\t\"mov %0, %%\"REG_c\"\t\t\\n\\t\"",
"\t\t\t\"mov %1, %%\"REG_D\"\t\t\\n\\t\"",
"\t\t\t\"mov %2, %%\"REG_d\"\t\t\\n\\t\"",
"\t\t\t\"mov %3, %%\"REG_b\"\t\t\\n\\t\"",
"\t\t\tPREFETCH\" (%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\tPREFETCH\" 32(%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\tPREFETCH\" 64(%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\t\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\",
"\t\t\t\"call *%4\t\t\t\\n\\t\"\\",
"\t\t\t\"movl (%%\"REG_b\", %%\"REG_a\"), %%esi\\n\\t\"\\",
"\t\t\t\"add %%\"REG_S\", %%\"REG_c\"\t\\n\\t\"\\",
"\t\t\t\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\",
"\t\t\t\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\",
"\t\t\t\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\",
"\t\t\t\"call *%4\t\t\t\\n\\t\"\\",
"\t\t\t\"addl (%%\"REG_b\", %%\"REG_a\"), %%\"REG_c\"\\n\\t\"\\",
"\t\t\t\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\",
"\t\t\t\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\",
"\t\t\tPREFETCH\" (%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\tPREFETCH\" 32(%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\tPREFETCH\" 64(%%\"REG_c\")\t\t\\n\\t\"",
"\t\t\t,\"m\" (ebxsave)",
"\t\t\t: \"%\"REG_a, \"%\"REG_c, \"%\"REG_d, \"%\"REG_S, \"%\"REG_D",
"#endif",
"\t\t);",
"#endif",
"\tuint16_t xInc_mask = xInc & 0xffff;",
"\tasm volatile(",
"\t\tASMALIGN(4)",
"\t\t\"1:\t\t\t\t\\n\\t\"",
"\t\t\"shll $16, %%edi\t\t\\n\\t\"",
"\t\t\"mov %1, %%\"REG_D\"\t\t\\n\\t\"",
"\t\t\"shrl $9, %%esi\t\t\t\\n\\t\"",
"\t\t\"movw %%si, (%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"",
"\t\t\"shll $16, %%edi\t\t\\n\\t\"",
"\t\t\"mov %1, %%\"REG_D\"\t\t\\n\\t\"",
"\t\t\"shrl $9, %%esi\t\t\t\\n\\t\"",
"\t\t\"cmp %2, %%\"REG_a\"\t\t\\n\\t\"",
"\t\t\" jb 1b\t\t\t\t\\n\\t\"",
"\t\t: \"%\"REG_a, \"%\"REG_d, \"%ecx\", \"%\"REG_D, \"%esi\"",
"\t\t);",
"\tint i;",
"\tunsigned int xpos=0;",
"\tfor(i=0;i<dstWidth;i++)",
"\t\tregister unsigned int xx=xpos>>16;",
"\t\tregister unsigned int xalpha=(xpos&0xFFFF)>>9;",
"\t\txpos+=xInc;",
"#endif"
],
"line_no": [
207,
207,
163,
163,
293,
151,
135,
135,
135,
135,
135,
151,
135,
135,
135,
135,
151,
135,
135,
135,
135,
135,
293,
303,
151,
293,
303,
151,
135,
293,
303,
151,
293,
303,
151,
135,
151,
151,
293,
301,
303,
135,
135,
151,
293,
301,
303,
135,
135,
135,
135,
151,
135,
151,
151,
151,
151,
151,
151,
151,
151,
151,
151,
151,
151,
151,
151,
163,
135,
171,
135,
275,
163,
135,
171,
135,
275,
163,
171,
275,
151,
3,
5,
7,
9,
13,
17,
19,
23,
27,
19,
33,
37,
19,
43,
47,
19,
53,
57,
19,
63,
67,
19,
73,
77,
19,
83,
87,
19,
93,
97,
19,
103,
107,
19,
113,
117,
19,
129,
133,
139,
151,
155,
159,
163,
167,
135,
171,
173,
175,
177,
179,
183,
185,
187,
197,
199,
201,
203,
205,
207,
197,
199,
221,
205,
207,
253,
257,
259,
263,
267,
271,
135,
275,
277,
135,
287,
289,
293,
301,
303,
313,
317,
319,
321,
313,
317,
319,
345,
355,
357,
359,
365,
367,
275,
151,
381,
383,
387,
389,
391,
393,
7,
9,
33,
43,
53,
63,
73,
83,
93,
103,
113,
129,
133,
151,
155,
159,
163,
135,
171,
173,
175,
177,
179,
183,
185,
187,
197,
199,
201,
203,
205,
207,
197,
199,
221,
205,
207,
183,
185,
187,
263,
267,
135,
275,
135,
289,
293,
301,
303,
313,
317,
319,
321,
313,
317,
319,
357,
359,
367,
275,
151,
381,
383,
387,
389,
393,
135
]
} | static inline void FUNC_0(hyscale)(uint16_t *dst, long dstWidth, uint8_t *src, int srcW, int xInc,
int flags, int canMMX2BeUsed, int16_t *hLumFilter,
int16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode,
int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,
int32_t *mmx2FilterPos, uint8_t *pal)
{
if(srcFormat==PIX_FMT_YUYV422 || srcFormat==PIX_FMT_GRAY16BE)
{
FUNC_0(yuy2ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_UYVY422 || srcFormat==PIX_FMT_GRAY16LE)
{
FUNC_0(uyvyToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB32)
{
FUNC_0(bgr32ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR24)
{
FUNC_0(bgr24ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR565)
{
FUNC_0(bgr16ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR555)
{
FUNC_0(bgr15ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_BGR32)
{
FUNC_0(rgb32ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB24)
{
FUNC_0(rgb24ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB565)
{
FUNC_0(rgb16ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB555)
{
FUNC_0(rgb15ToY)(formatConvBuffer, src, srcW);
src= formatConvBuffer;
}
else if(srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)
{
FUNC_0(palToY)(formatConvBuffer, src, srcW, pal);
src= formatConvBuffer;
}
#ifdef HAVE_MMX
if(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))
#else
if(!(flags&SWS_FAST_BILINEAR))
#endif
{
FUNC_0(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);
}
else
{
#if defined(ARCH_X86)
#ifdef HAVE_MMX2
int VAR_0;
#if defined(PIC)
uint64_t ebxsave __attribute__((aligned(8)));
#endif
if(canMMX2BeUsed)
{
asm volatile(
#if defined(PIC)
"mov %%"REG_b", %5 \n\t"
#endif
"pxor %%mm7, %%mm7 \n\t"
"mov %0, %%"REG_c" \n\t"
"mov %1, %%"REG_D" \n\t"
"mov %2, %%"REG_d" \n\t"
"mov %3, %%"REG_b" \n\t"
"xor %%"REG_a", %%"REG_a" \n\t"
PREFETCH" (%%"REG_c") \n\t"
PREFETCH" 32(%%"REG_c") \n\t"
PREFETCH" 64(%%"REG_c") \n\t"
#ifdef ARCH_X86_64
#define FUNNY_Y_CODE \
"movl (%%"REG_b"), %%esi \n\t"\
"call *%4 \n\t"\
"movl (%%"REG_b", %%"REG_a"), %%esi\n\t"\
"add %%"REG_S", %%"REG_c" \n\t"\
"add %%"REG_a", %%"REG_D" \n\t"\
"xor %%"REG_a", %%"REG_a" \n\t"\
#else
#define FUNNY_Y_CODE \
"movl (%%"REG_b"), %%esi \n\t"\
"call *%4 \n\t"\
"addl (%%"REG_b", %%"REG_a"), %%"REG_c"\n\t"\
"add %%"REG_a", %%"REG_D" \n\t"\
"xor %%"REG_a", %%"REG_a" \n\t"\
#endif
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
FUNNY_Y_CODE
#if defined(PIC)
"mov %5, %%"REG_b" \n\t"
#endif
:: "m" (src), "m" (dst), "m" (mmx2Filter), "m" (mmx2FilterPos),
"m" (funnyYCode)
#if defined(PIC)
,"m" (ebxsave)
#endif
: "%"REG_a, "%"REG_c, "%"REG_d, "%"REG_S, "%"REG_D
#if !defined(PIC)
,"%"REG_b
#endif
);
for(VAR_0=dstWidth-1; (VAR_0*xInc)>>16 >=srcW-1; VAR_0--) dst[VAR_0] = src[srcW-1]*128;
}
else
{
#endif
long xInc_shr16 = xInc >> 16;
uint16_t xInc_mask = xInc & 0xffff;
asm volatile(
"xor %%"REG_a", %%"REG_a" \n\t"
"xor %%"REG_d", %%"REG_d" \n\t"
"xorl %%ecx, %%ecx \n\t"
ASMALIGN(4)
"1: \n\t"
"movzbl (%0, %%"REG_d"), %%edi \n\t"
"movzbl 1(%0, %%"REG_d"), %%esi \n\t"
"subl %%edi, %%esi \n\t" - src[xx]
"imull %%ecx, %%esi \n\t"
"shll $16, %%edi \n\t"
"addl %%edi, %%esi \n\t" *2*xalpha + src[xx]*(1-2*xalpha)
"mov %1, %%"REG_D" \n\t"
"shrl $9, %%esi \n\t"
"movw %%si, (%%"REG_D", %%"REG_a", 2)\n\t"
"addw %4, %%cx \n\t"
"adc %3, %%"REG_d" \n\t"
"movzbl (%0, %%"REG_d"), %%edi \n\t"
"movzbl 1(%0, %%"REG_d"), %%esi \n\t"
"subl %%edi, %%esi \n\t" - src[xx]
"imull %%ecx, %%esi \n\t"
"shll $16, %%edi \n\t"
"addl %%edi, %%esi \n\t" *2*xalpha + src[xx]*(1-2*xalpha)
"mov %1, %%"REG_D" \n\t"
"shrl $9, %%esi \n\t"
"movw %%si, 2(%%"REG_D", %%"REG_a", 2)\n\t"
"addw %4, %%cx \n\t"
"adc %3, %%"REG_d" \n\t"
"add $2, %%"REG_a" \n\t"
"cmp %2, %%"REG_a" \n\t"
" jb 1b \n\t"
:: "r" (src), "m" (dst), "m" (dstWidth), "m" (xInc_shr16), "m" (xInc_mask)
: "%"REG_a, "%"REG_d, "%ecx", "%"REG_D, "%esi"
);
#ifdef HAVE_MMX2
}
#endif
#else
int VAR_0;
unsigned int VAR_1=0;
for(VAR_0=0;VAR_0<dstWidth;VAR_0++)
{
register unsigned int xx=VAR_1>>16;
register unsigned int xalpha=(VAR_1&0xFFFF)>>9;
dst[VAR_0]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;
VAR_1+=xInc;
}
#endif
}
}
| [
"static inline void FUNC_0(hyscale)(uint16_t *dst, long dstWidth, uint8_t *src, int srcW, int xInc,\nint flags, int canMMX2BeUsed, int16_t *hLumFilter,\nint16_t *hLumFilterPos, int hLumFilterSize, void *funnyYCode,\nint srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,\nint32_t *mmx2FilterPos, uint8_t *pal)\n{",
"if(srcFormat==PIX_FMT_YUYV422 || srcFormat==PIX_FMT_GRAY16BE)\n{",
"FUNC_0(yuy2ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_UYVY422 || srcFormat==PIX_FMT_GRAY16LE)\n{",
"FUNC_0(uyvyToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_RGB32)\n{",
"FUNC_0(bgr32ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_BGR24)\n{",
"FUNC_0(bgr24ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_BGR565)\n{",
"FUNC_0(bgr16ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_BGR555)\n{",
"FUNC_0(bgr15ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_BGR32)\n{",
"FUNC_0(rgb32ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_RGB24)\n{",
"FUNC_0(rgb24ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_RGB565)\n{",
"FUNC_0(rgb16ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_RGB555)\n{",
"FUNC_0(rgb15ToY)(formatConvBuffer, src, srcW);",
"src= formatConvBuffer;",
"}",
"else if(srcFormat==PIX_FMT_RGB8 || srcFormat==PIX_FMT_BGR8 || srcFormat==PIX_FMT_PAL8 || srcFormat==PIX_FMT_BGR4_BYTE || srcFormat==PIX_FMT_RGB4_BYTE)\n{",
"FUNC_0(palToY)(formatConvBuffer, src, srcW, pal);",
"src= formatConvBuffer;",
"}",
"#ifdef HAVE_MMX\nif(!(flags&SWS_FAST_BILINEAR) || (!canMMX2BeUsed))\n#else\nif(!(flags&SWS_FAST_BILINEAR))\n#endif\n{",
"FUNC_0(hScale)(dst, dstWidth, src, srcW, xInc, hLumFilter, hLumFilterPos, hLumFilterSize);",
"}",
"else\n{",
"#if defined(ARCH_X86)\n#ifdef HAVE_MMX2\nint VAR_0;",
"#if defined(PIC)\nuint64_t ebxsave __attribute__((aligned(8)));",
"#endif\nif(canMMX2BeUsed)\n{",
"asm volatile(\n#if defined(PIC)\n\"mov %%\"REG_b\", %5 \\n\\t\"\n#endif\n\"pxor %%mm7, %%mm7\t\t\\n\\t\"\n\"mov %0, %%\"REG_c\"\t\t\\n\\t\"\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"mov %2, %%\"REG_d\"\t\t\\n\\t\"\n\"mov %3, %%\"REG_b\"\t\t\\n\\t\"\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\nPREFETCH\" (%%\"REG_c\")\t\t\\n\\t\"\nPREFETCH\" 32(%%\"REG_c\")\t\t\\n\\t\"\nPREFETCH\" 64(%%\"REG_c\")\t\t\\n\\t\"\n#ifdef ARCH_X86_64\n#define FUNNY_Y_CODE \\\n\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\\n\"call *%4\t\t\t\\n\\t\"\\\n\"movl (%%\"REG_b\", %%\"REG_a\"), %%esi\\n\\t\"\\\n\"add %%\"REG_S\", %%\"REG_c\"\t\\n\\t\"\\\n\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\\n#else\n#define FUNNY_Y_CODE \\\n\"movl (%%\"REG_b\"), %%esi\t\\n\\t\"\\\n\"call *%4\t\t\t\\n\\t\"\\\n\"addl (%%\"REG_b\", %%\"REG_a\"), %%\"REG_c\"\\n\\t\"\\\n\"add %%\"REG_a\", %%\"REG_D\"\t\\n\\t\"\\\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\\\n#endif\nFUNNY_Y_CODE\nFUNNY_Y_CODE\nFUNNY_Y_CODE\nFUNNY_Y_CODE\nFUNNY_Y_CODE\nFUNNY_Y_CODE\nFUNNY_Y_CODE\nFUNNY_Y_CODE\n#if defined(PIC)\n\"mov %5, %%\"REG_b\" \\n\\t\"\n#endif\n:: \"m\" (src), \"m\" (dst), \"m\" (mmx2Filter), \"m\" (mmx2FilterPos),\n\"m\" (funnyYCode)\n#if defined(PIC)\n,\"m\" (ebxsave)\n#endif\n: \"%\"REG_a, \"%\"REG_c, \"%\"REG_d, \"%\"REG_S, \"%\"REG_D\n#if !defined(PIC)\n,\"%\"REG_b\n#endif\n);",
"for(VAR_0=dstWidth-1; (VAR_0*xInc)>>16 >=srcW-1; VAR_0--) dst[VAR_0] = src[srcW-1]*128;",
"}",
"else\n{",
"#endif\nlong xInc_shr16 = xInc >> 16;",
"uint16_t xInc_mask = xInc & 0xffff;",
"asm volatile(\n\"xor %%\"REG_a\", %%\"REG_a\"\t\\n\\t\"\n\"xor %%\"REG_d\", %%\"REG_d\"\t\\n\\t\"\n\"xorl %%ecx, %%ecx\t\t\\n\\t\"\nASMALIGN(4)\n\"1:\t\t\t\t\\n\\t\"\n\"movzbl (%0, %%\"REG_d\"), %%edi\t\\n\\t\"\n\"movzbl 1(%0, %%\"REG_d\"), %%esi\t\\n\\t\"\n\"subl %%edi, %%esi\t\t\\n\\t\" - src[xx]\n\"imull %%ecx, %%esi\t\t\\n\\t\"\n\"shll $16, %%edi\t\t\\n\\t\"\n\"addl %%edi, %%esi\t\t\\n\\t\" *2*xalpha + src[xx]*(1-2*xalpha)\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"shrl $9, %%esi\t\t\t\\n\\t\"\n\"movw %%si, (%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"\n\"addw %4, %%cx\t\t\t\\n\\t\"\n\"adc %3, %%\"REG_d\"\t\t\\n\\t\"\n\"movzbl (%0, %%\"REG_d\"), %%edi\t\\n\\t\"\n\"movzbl 1(%0, %%\"REG_d\"), %%esi\t\\n\\t\"\n\"subl %%edi, %%esi\t\t\\n\\t\" - src[xx]\n\"imull %%ecx, %%esi\t\t\\n\\t\"\n\"shll $16, %%edi\t\t\\n\\t\"\n\"addl %%edi, %%esi\t\t\\n\\t\" *2*xalpha + src[xx]*(1-2*xalpha)\n\"mov %1, %%\"REG_D\"\t\t\\n\\t\"\n\"shrl $9, %%esi\t\t\t\\n\\t\"\n\"movw %%si, 2(%%\"REG_D\", %%\"REG_a\", 2)\\n\\t\"\n\"addw %4, %%cx\t\t\t\\n\\t\"\n\"adc %3, %%\"REG_d\"\t\t\\n\\t\"\n\"add $2, %%\"REG_a\"\t\t\\n\\t\"\n\"cmp %2, %%\"REG_a\"\t\t\\n\\t\"\n\" jb 1b\t\t\t\t\\n\\t\"\n:: \"r\" (src), \"m\" (dst), \"m\" (dstWidth), \"m\" (xInc_shr16), \"m\" (xInc_mask)\n: \"%\"REG_a, \"%\"REG_d, \"%ecx\", \"%\"REG_D, \"%esi\"\n);",
"#ifdef HAVE_MMX2\n}",
"#endif\n#else\nint VAR_0;",
"unsigned int VAR_1=0;",
"for(VAR_0=0;VAR_0<dstWidth;VAR_0++)",
"{",
"register unsigned int xx=VAR_1>>16;",
"register unsigned int xalpha=(VAR_1&0xFFFF)>>9;",
"dst[VAR_0]= (src[xx]<<7) + (src[xx+1] - src[xx])*xalpha;",
"VAR_1+=xInc;",
"}",
"#endif\n}",
"}"
]
| [
1,
1,
1,
1,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
0,
0,
1,
1,
1,
1,
1,
0,
0,
1,
1,
1,
0,
0,
1,
1,
0,
1,
1,
1,
1,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9,
11
],
[
13,
15
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
47
],
[
49
],
[
51
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[
63,
65
],
[
67
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
119
],
[
121
],
[
125,
129,
131,
133,
135,
137
],
[
139
],
[
141
],
[
143,
145
],
[
147,
149,
151
],
[
153,
155
],
[
157,
159,
161
],
[
163,
165,
167,
169,
171,
173,
175,
177,
179,
181,
183,
185,
187,
191,
195,
197,
199,
201,
203,
205,
207,
211,
215,
217,
219,
221,
223,
225,
229,
233,
235,
237,
239,
241,
243,
245,
247,
251,
253,
255,
257,
259,
261,
263,
265,
267,
269,
271,
273,
275
],
[
277
],
[
279
],
[
281,
283
],
[
285,
287
],
[
289
],
[
293,
295,
297,
299,
301,
303,
305,
307,
309,
311,
313,
315,
317,
319,
321,
323,
325,
329,
331,
333,
335,
337,
339,
341,
343,
345,
347,
349,
355,
357,
359,
365,
367,
369
],
[
371,
373
],
[
375,
377,
379
],
[
381
],
[
383
],
[
385
],
[
387
],
[
389
],
[
391
],
[
393
],
[
395
],
[
397,
399
],
[
401
]
]
|
12,811 | static void ich9_smb_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->vendor_id = PCI_VENDOR_ID_INTEL;
k->device_id = PCI_DEVICE_ID_INTEL_ICH9_6;
k->revision = ICH9_A2_SMB_REVISION;
k->class_id = PCI_CLASS_SERIAL_SMBUS;
dc->no_user = 1;
dc->vmsd = &vmstate_ich9_smbus;
dc->desc = "ICH9 SMBUS Bridge";
k->init = ich9_smbus_initfn;
k->config_write = ich9_smbus_write_config;
}
| true | qemu | efec3dd631d94160288392721a5f9c39e50fb2bc | static void ich9_smb_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
k->vendor_id = PCI_VENDOR_ID_INTEL;
k->device_id = PCI_DEVICE_ID_INTEL_ICH9_6;
k->revision = ICH9_A2_SMB_REVISION;
k->class_id = PCI_CLASS_SERIAL_SMBUS;
dc->no_user = 1;
dc->vmsd = &vmstate_ich9_smbus;
dc->desc = "ICH9 SMBUS Bridge";
k->init = ich9_smbus_initfn;
k->config_write = ich9_smbus_write_config;
}
| {
"code": [
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;",
" dc->no_user = 1;"
],
"line_no": [
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19,
19
]
} | static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)
{
DeviceClass *dc = DEVICE_CLASS(VAR_0);
PCIDeviceClass *k = PCI_DEVICE_CLASS(VAR_0);
k->vendor_id = PCI_VENDOR_ID_INTEL;
k->device_id = PCI_DEVICE_ID_INTEL_ICH9_6;
k->revision = ICH9_A2_SMB_REVISION;
k->class_id = PCI_CLASS_SERIAL_SMBUS;
dc->no_user = 1;
dc->vmsd = &vmstate_ich9_smbus;
dc->desc = "ICH9 SMBUS Bridge";
k->init = ich9_smbus_initfn;
k->config_write = ich9_smbus_write_config;
}
| [
"static void FUNC_0(ObjectClass *VAR_0, void *VAR_1)\n{",
"DeviceClass *dc = DEVICE_CLASS(VAR_0);",
"PCIDeviceClass *k = PCI_DEVICE_CLASS(VAR_0);",
"k->vendor_id = PCI_VENDOR_ID_INTEL;",
"k->device_id = PCI_DEVICE_ID_INTEL_ICH9_6;",
"k->revision = ICH9_A2_SMB_REVISION;",
"k->class_id = PCI_CLASS_SERIAL_SMBUS;",
"dc->no_user = 1;",
"dc->vmsd = &vmstate_ich9_smbus;",
"dc->desc = \"ICH9 SMBUS Bridge\";",
"k->init = ich9_smbus_initfn;",
"k->config_write = ich9_smbus_write_config;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
]
]
|
12,812 | bool qemu_file_mode_is_not_valid(const char *mode)
{
if (mode == NULL ||
(mode[0] != 'r' && mode[0] != 'w') ||
mode[1] != 'b' || mode[2] != 0) {
fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
return true;
}
return false;
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | bool qemu_file_mode_is_not_valid(const char *mode)
{
if (mode == NULL ||
(mode[0] != 'r' && mode[0] != 'w') ||
mode[1] != 'b' || mode[2] != 0) {
fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
return true;
}
return false;
}
| {
"code": [],
"line_no": []
} | bool FUNC_0(const char *mode)
{
if (mode == NULL ||
(mode[0] != 'r' && mode[0] != 'w') ||
mode[1] != 'b' || mode[2] != 0) {
fprintf(stderr, "qemu_fopen: Argument validity check failed\n");
return true;
}
return false;
}
| [
"bool FUNC_0(const char *mode)\n{",
"if (mode == NULL ||\n(mode[0] != 'r' && mode[0] != 'w') ||\nmode[1] != 'b' || mode[2] != 0) {",
"fprintf(stderr, \"qemu_fopen: Argument validity check failed\\n\");",
"return true;",
"}",
"return false;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
]
]
|
12,813 | void qemu_mutex_unlock(QemuMutex *mutex)
{
assert(mutex->owner == GetCurrentThreadId());
mutex->owner = 0;
LeaveCriticalSection(&mutex->lock);
}
| true | qemu | 12f8def0e02232d7c6416ad9b66640f973c531d1 | void qemu_mutex_unlock(QemuMutex *mutex)
{
assert(mutex->owner == GetCurrentThreadId());
mutex->owner = 0;
LeaveCriticalSection(&mutex->lock);
}
| {
"code": [
" mutex->owner = 0;",
" assert(mutex->owner == GetCurrentThreadId());",
" mutex->owner = 0;",
" LeaveCriticalSection(&mutex->lock);"
],
"line_no": [
7,
5,
7,
9
]
} | void FUNC_0(QemuMutex *VAR_0)
{
assert(VAR_0->owner == GetCurrentThreadId());
VAR_0->owner = 0;
LeaveCriticalSection(&VAR_0->lock);
}
| [
"void FUNC_0(QemuMutex *VAR_0)\n{",
"assert(VAR_0->owner == GetCurrentThreadId());",
"VAR_0->owner = 0;",
"LeaveCriticalSection(&VAR_0->lock);",
"}"
]
| [
0,
1,
1,
1,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
]
|
12,815 | void register_watchdogs(void)
{
wdt_ib700_init();
wdt_i6300esb_init();
}
| true | qemu | 09aaa1602f9381c0e0fb539390b1793e51bdfc7b | void register_watchdogs(void)
{
wdt_ib700_init();
wdt_i6300esb_init();
}
| {
"code": [
"void register_watchdogs(void)",
" wdt_ib700_init();",
" wdt_i6300esb_init();"
],
"line_no": [
1,
5,
7
]
} | void FUNC_0(void)
{
wdt_ib700_init();
wdt_i6300esb_init();
}
| [
"void FUNC_0(void)\n{",
"wdt_ib700_init();",
"wdt_i6300esb_init();",
"}"
]
| [
1,
1,
1,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
]
]
|
12,816 | static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
{
RTMPContext *rt = s->priv_data;
int size_temp = size;
int pktsize, pkttype;
uint32_t ts;
const uint8_t *buf_temp = buf;
uint8_t c;
int ret;
do {
if (rt->skip_bytes) {
int skip = FFMIN(rt->skip_bytes, size_temp);
buf_temp += skip;
size_temp -= skip;
rt->skip_bytes -= skip;
continue;
if (rt->flv_header_bytes < 11) {
const uint8_t *header = rt->flv_header;
int copy = FFMIN(11 - rt->flv_header_bytes, size_temp);
bytestream_get_buffer(&buf_temp, rt->flv_header + rt->flv_header_bytes, copy);
rt->flv_header_bytes += copy;
size_temp -= copy;
if (rt->flv_header_bytes < 11)
break;
pkttype = bytestream_get_byte(&header);
pktsize = bytestream_get_be24(&header);
ts = bytestream_get_be24(&header);
ts |= bytestream_get_byte(&header) << 24;
bytestream_get_be24(&header);
rt->flv_size = pktsize;
//force 12bytes header
if (((pkttype == RTMP_PT_VIDEO || pkttype == RTMP_PT_AUDIO) && ts == 0) ||
pkttype == RTMP_PT_NOTIFY) {
if (pkttype == RTMP_PT_NOTIFY)
pktsize += 16;
rt->prev_pkt[1][RTMP_SOURCE_CHANNEL].channel_id = 0;
//this can be a big packet, it's better to send it right here
if ((ret = ff_rtmp_packet_create(&rt->out_pkt, RTMP_SOURCE_CHANNEL,
pkttype, ts, pktsize)) < 0)
rt->out_pkt.extra = rt->main_channel_id;
rt->flv_data = rt->out_pkt.data;
if (pkttype == RTMP_PT_NOTIFY)
ff_amf_write_string(&rt->flv_data, "@setDataFrame");
if (rt->flv_size - rt->flv_off > size_temp) {
bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, size_temp);
rt->flv_off += size_temp;
size_temp = 0;
} else {
bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);
size_temp -= rt->flv_size - rt->flv_off;
rt->flv_off += rt->flv_size - rt->flv_off;
if (rt->flv_off == rt->flv_size) {
rt->skip_bytes = 4;
if ((ret = ff_rtmp_packet_write(rt->stream, &rt->out_pkt,
rt->chunk_size, rt->prev_pkt[1])) < 0)
ff_rtmp_packet_destroy(&rt->out_pkt);
rt->flv_size = 0;
rt->flv_off = 0;
rt->flv_header_bytes = 0;
} while (buf_temp - buf < size); | true | FFmpeg | 7dc747f50b0adeaf2bcf6413e291dc4bffa54f9a | static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
{
RTMPContext *rt = s->priv_data;
int size_temp = size;
int pktsize, pkttype;
uint32_t ts;
const uint8_t *buf_temp = buf;
uint8_t c;
int ret;
do {
if (rt->skip_bytes) {
int skip = FFMIN(rt->skip_bytes, size_temp);
buf_temp += skip;
size_temp -= skip;
rt->skip_bytes -= skip;
continue;
if (rt->flv_header_bytes < 11) {
const uint8_t *header = rt->flv_header;
int copy = FFMIN(11 - rt->flv_header_bytes, size_temp);
bytestream_get_buffer(&buf_temp, rt->flv_header + rt->flv_header_bytes, copy);
rt->flv_header_bytes += copy;
size_temp -= copy;
if (rt->flv_header_bytes < 11)
break;
pkttype = bytestream_get_byte(&header);
pktsize = bytestream_get_be24(&header);
ts = bytestream_get_be24(&header);
ts |= bytestream_get_byte(&header) << 24;
bytestream_get_be24(&header);
rt->flv_size = pktsize;
if (((pkttype == RTMP_PT_VIDEO || pkttype == RTMP_PT_AUDIO) && ts == 0) ||
pkttype == RTMP_PT_NOTIFY) {
if (pkttype == RTMP_PT_NOTIFY)
pktsize += 16;
rt->prev_pkt[1][RTMP_SOURCE_CHANNEL].channel_id = 0;
if ((ret = ff_rtmp_packet_create(&rt->out_pkt, RTMP_SOURCE_CHANNEL,
pkttype, ts, pktsize)) < 0)
rt->out_pkt.extra = rt->main_channel_id;
rt->flv_data = rt->out_pkt.data;
if (pkttype == RTMP_PT_NOTIFY)
ff_amf_write_string(&rt->flv_data, "@setDataFrame");
if (rt->flv_size - rt->flv_off > size_temp) {
bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, size_temp);
rt->flv_off += size_temp;
size_temp = 0;
} else {
bytestream_get_buffer(&buf_temp, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);
size_temp -= rt->flv_size - rt->flv_off;
rt->flv_off += rt->flv_size - rt->flv_off;
if (rt->flv_off == rt->flv_size) {
rt->skip_bytes = 4;
if ((ret = ff_rtmp_packet_write(rt->stream, &rt->out_pkt,
rt->chunk_size, rt->prev_pkt[1])) < 0)
ff_rtmp_packet_destroy(&rt->out_pkt);
rt->flv_size = 0;
rt->flv_off = 0;
rt->flv_header_bytes = 0;
} while (buf_temp - buf < size); | {
"code": [],
"line_no": []
} | static int FUNC_0(URLContext *VAR_0, const uint8_t *VAR_1, int VAR_2)
{
RTMPContext *rt = VAR_0->priv_data;
int VAR_3 = VAR_2;
int VAR_4, VAR_5;
uint32_t ts;
const uint8_t *VAR_6 = VAR_1;
uint8_t c;
int VAR_7;
do {
if (rt->skip_bytes) {
int skip = FFMIN(rt->skip_bytes, VAR_3);
VAR_6 += skip;
VAR_3 -= skip;
rt->skip_bytes -= skip;
continue;
if (rt->flv_header_bytes < 11) {
const uint8_t *header = rt->flv_header;
int copy = FFMIN(11 - rt->flv_header_bytes, VAR_3);
bytestream_get_buffer(&VAR_6, rt->flv_header + rt->flv_header_bytes, copy);
rt->flv_header_bytes += copy;
VAR_3 -= copy;
if (rt->flv_header_bytes < 11)
break;
VAR_5 = bytestream_get_byte(&header);
VAR_4 = bytestream_get_be24(&header);
ts = bytestream_get_be24(&header);
ts |= bytestream_get_byte(&header) << 24;
bytestream_get_be24(&header);
rt->flv_size = VAR_4;
if (((VAR_5 == RTMP_PT_VIDEO || VAR_5 == RTMP_PT_AUDIO) && ts == 0) ||
VAR_5 == RTMP_PT_NOTIFY) {
if (VAR_5 == RTMP_PT_NOTIFY)
VAR_4 += 16;
rt->prev_pkt[1][RTMP_SOURCE_CHANNEL].channel_id = 0;
if ((VAR_7 = ff_rtmp_packet_create(&rt->out_pkt, RTMP_SOURCE_CHANNEL,
VAR_5, ts, VAR_4)) < 0)
rt->out_pkt.extra = rt->main_channel_id;
rt->flv_data = rt->out_pkt.data;
if (VAR_5 == RTMP_PT_NOTIFY)
ff_amf_write_string(&rt->flv_data, "@setDataFrame");
if (rt->flv_size - rt->flv_off > VAR_3) {
bytestream_get_buffer(&VAR_6, rt->flv_data + rt->flv_off, VAR_3);
rt->flv_off += VAR_3;
VAR_3 = 0;
} else {
bytestream_get_buffer(&VAR_6, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);
VAR_3 -= rt->flv_size - rt->flv_off;
rt->flv_off += rt->flv_size - rt->flv_off;
if (rt->flv_off == rt->flv_size) {
rt->skip_bytes = 4;
if ((VAR_7 = ff_rtmp_packet_write(rt->stream, &rt->out_pkt,
rt->chunk_size, rt->prev_pkt[1])) < 0)
ff_rtmp_packet_destroy(&rt->out_pkt);
rt->flv_size = 0;
rt->flv_off = 0;
rt->flv_header_bytes = 0;
} while (VAR_6 - VAR_1 < VAR_2); | [
"static int FUNC_0(URLContext *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{",
"RTMPContext *rt = VAR_0->priv_data;",
"int VAR_3 = VAR_2;",
"int VAR_4, VAR_5;",
"uint32_t ts;",
"const uint8_t *VAR_6 = VAR_1;",
"uint8_t c;",
"int VAR_7;",
"do {",
"if (rt->skip_bytes) {",
"int skip = FFMIN(rt->skip_bytes, VAR_3);",
"VAR_6 += skip;",
"VAR_3 -= skip;",
"rt->skip_bytes -= skip;",
"continue;",
"if (rt->flv_header_bytes < 11) {",
"const uint8_t *header = rt->flv_header;",
"int copy = FFMIN(11 - rt->flv_header_bytes, VAR_3);",
"bytestream_get_buffer(&VAR_6, rt->flv_header + rt->flv_header_bytes, copy);",
"rt->flv_header_bytes += copy;",
"VAR_3 -= copy;",
"if (rt->flv_header_bytes < 11)\nbreak;",
"VAR_5 = bytestream_get_byte(&header);",
"VAR_4 = bytestream_get_be24(&header);",
"ts = bytestream_get_be24(&header);",
"ts |= bytestream_get_byte(&header) << 24;",
"bytestream_get_be24(&header);",
"rt->flv_size = VAR_4;",
"if (((VAR_5 == RTMP_PT_VIDEO || VAR_5 == RTMP_PT_AUDIO) && ts == 0) ||\nVAR_5 == RTMP_PT_NOTIFY) {",
"if (VAR_5 == RTMP_PT_NOTIFY)\nVAR_4 += 16;",
"rt->prev_pkt[1][RTMP_SOURCE_CHANNEL].channel_id = 0;",
"if ((VAR_7 = ff_rtmp_packet_create(&rt->out_pkt, RTMP_SOURCE_CHANNEL,\nVAR_5, ts, VAR_4)) < 0)\nrt->out_pkt.extra = rt->main_channel_id;",
"rt->flv_data = rt->out_pkt.data;",
"if (VAR_5 == RTMP_PT_NOTIFY)\nff_amf_write_string(&rt->flv_data, \"@setDataFrame\");",
"if (rt->flv_size - rt->flv_off > VAR_3) {",
"bytestream_get_buffer(&VAR_6, rt->flv_data + rt->flv_off, VAR_3);",
"rt->flv_off += VAR_3;",
"VAR_3 = 0;",
"} else {",
"bytestream_get_buffer(&VAR_6, rt->flv_data + rt->flv_off, rt->flv_size - rt->flv_off);",
"VAR_3 -= rt->flv_size - rt->flv_off;",
"rt->flv_off += rt->flv_size - rt->flv_off;",
"if (rt->flv_off == rt->flv_size) {",
"rt->skip_bytes = 4;",
"if ((VAR_7 = ff_rtmp_packet_write(rt->stream, &rt->out_pkt,\nrt->chunk_size, rt->prev_pkt[1])) < 0)\nff_rtmp_packet_destroy(&rt->out_pkt);",
"rt->flv_size = 0;",
"rt->flv_off = 0;",
"rt->flv_header_bytes = 0;",
"} while (VAR_6 - VAR_1 < VAR_2);"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22
],
[
23,
24
],
[
25
],
[
26
],
[
27
],
[
28
],
[
29
],
[
30
],
[
32,
33
],
[
34,
35
],
[
36
],
[
38,
39,
40
],
[
41
],
[
42,
43
],
[
44
],
[
45
],
[
46
],
[
47
],
[
48
],
[
49
],
[
50
],
[
51
],
[
52
],
[
53
],
[
54,
55,
56
],
[
57
],
[
58
],
[
59
],
[
60
]
]
|
12,818 | void ff_thread_flush(AVCodecContext *avctx)
{
FrameThreadContext *fctx = avctx->thread_opaque;
if (!avctx->thread_opaque) return;
park_frame_worker_threads(fctx, avctx->thread_count);
if (fctx->prev_thread)
update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0);
fctx->next_decoding = fctx->next_finished = 0;
fctx->delaying = 1;
fctx->prev_thread = NULL;
}
| true | FFmpeg | d1cf45911935cc4fed9afd3a37d99616d31eb9da | void ff_thread_flush(AVCodecContext *avctx)
{
FrameThreadContext *fctx = avctx->thread_opaque;
if (!avctx->thread_opaque) return;
park_frame_worker_threads(fctx, avctx->thread_count);
if (fctx->prev_thread)
update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0);
fctx->next_decoding = fctx->next_finished = 0;
fctx->delaying = 1;
fctx->prev_thread = NULL;
}
| {
"code": [
" if (fctx->prev_thread)",
" update_context_from_thread(fctx->threads->avctx, fctx->prev_thread->avctx, 0);"
],
"line_no": [
17,
19
]
} | void FUNC_0(AVCodecContext *VAR_0)
{
FrameThreadContext *fctx = VAR_0->thread_opaque;
if (!VAR_0->thread_opaque) return;
park_frame_worker_threads(fctx, VAR_0->thread_count);
if (fctx->prev_thread)
update_context_from_thread(fctx->threads->VAR_0, fctx->prev_thread->VAR_0, 0);
fctx->next_decoding = fctx->next_finished = 0;
fctx->delaying = 1;
fctx->prev_thread = NULL;
}
| [
"void FUNC_0(AVCodecContext *VAR_0)\n{",
"FrameThreadContext *fctx = VAR_0->thread_opaque;",
"if (!VAR_0->thread_opaque) return;",
"park_frame_worker_threads(fctx, VAR_0->thread_count);",
"if (fctx->prev_thread)\nupdate_context_from_thread(fctx->threads->VAR_0, fctx->prev_thread->VAR_0, 0);",
"fctx->next_decoding = fctx->next_finished = 0;",
"fctx->delaying = 1;",
"fctx->prev_thread = NULL;",
"}"
]
| [
0,
0,
0,
0,
1,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
17,
19
],
[
23
],
[
25
],
[
27
],
[
29
]
]
|
12,819 | static int check_strtox_error(const char **next, char *endptr,
int err)
{
if (!next && *endptr) {
return -EINVAL;
}
if (next) {
*next = endptr;
}
return -err;
}
| true | qemu | 47d4be12c3997343e436c6cca89aefbbbeb70863 | static int check_strtox_error(const char **next, char *endptr,
int err)
{
if (!next && *endptr) {
return -EINVAL;
}
if (next) {
*next = endptr;
}
return -err;
}
| {
"code": [
"static int check_strtox_error(const char **next, char *endptr,"
],
"line_no": [
1
]
} | static int FUNC_0(const char **VAR_0, char *VAR_1,
int VAR_2)
{
if (!VAR_0 && *VAR_1) {
return -EINVAL;
}
if (VAR_0) {
*VAR_0 = VAR_1;
}
return -VAR_2;
}
| [
"static int FUNC_0(const char **VAR_0, char *VAR_1,\nint VAR_2)\n{",
"if (!VAR_0 && *VAR_1) {",
"return -EINVAL;",
"}",
"if (VAR_0) {",
"*VAR_0 = VAR_1;",
"}",
"return -VAR_2;",
"}"
]
| [
1,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
]
|
12,820 | static void pc_init1(MachineState *machine,
const char *host_type, const char *pci_type)
{
PCMachineState *pcms = PC_MACHINE(machine);
PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int i;
PCIBus *pci_bus;
ISABus *isa_bus;
PCII440FXState *i440fx_state;
int piix3_devfn = -1;
qemu_irq *gsi;
qemu_irq *i8259;
qemu_irq smi_irq;
GSIState *gsi_state;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
BusState *idebus[MAX_IDE_BUS];
ISADevice *rtc_state;
MemoryRegion *ram_memory;
MemoryRegion *pci_memory;
MemoryRegion *rom_memory;
ram_addr_t lowmem;
/*
* Calculate ram split, for memory below and above 4G. It's a bit
* complicated for backward compatibility reasons ...
*
* - Traditional split is 3.5G (lowmem = 0xe0000000). This is the
* default value for max_ram_below_4g now.
*
* - Then, to gigabyte align the memory, we move the split to 3G
* (lowmem = 0xc0000000). But only in case we have to split in
* the first place, i.e. ram_size is larger than (traditional)
* lowmem. And for new machine types (gigabyte_align = true)
* only, for live migration compatibility reasons.
*
* - Next the max-ram-below-4g option was added, which allowed to
* reduce lowmem to a smaller value, to allow a larger PCI I/O
* window below 4G. qemu doesn't enforce gigabyte alignment here,
* but prints a warning.
*
* - Finally max-ram-below-4g got updated to also allow raising lowmem,
* so legacy non-PAE guests can get as much memory as possible in
* the 32bit address space below 4G.
*
* - Note that Xen has its own ram setp code in xen_ram_init(),
* called via xen_hvm_init().
*
* Examples:
* qemu -M pc-1.7 -m 4G (old default) -> 3584M low, 512M high
* qemu -M pc -m 4G (new default) -> 3072M low, 1024M high
* qemu -M pc,max-ram-below-4g=2G -m 4G -> 2048M low, 2048M high
* qemu -M pc,max-ram-below-4g=4G -m 3968M -> 3968M low (=4G-128M)
*/
if (xen_enabled()) {
xen_hvm_init(pcms, &ram_memory);
} else {
if (!pcms->max_ram_below_4g) {
pcms->max_ram_below_4g = 0xe0000000; /* default: 3.5G */
}
lowmem = pcms->max_ram_below_4g;
if (machine->ram_size >= pcms->max_ram_below_4g) {
if (pcmc->gigabyte_align) {
if (lowmem > 0xc0000000) {
lowmem = 0xc0000000;
}
if (lowmem & ((1ULL << 30) - 1)) {
error_report("Warning: Large machine and max_ram_below_4g "
"(%" PRIu64 ") not a multiple of 1G; "
"possible bad performance.",
pcms->max_ram_below_4g);
}
}
}
if (machine->ram_size >= lowmem) {
pcms->above_4g_mem_size = machine->ram_size - lowmem;
pcms->below_4g_mem_size = lowmem;
} else {
pcms->above_4g_mem_size = 0;
pcms->below_4g_mem_size = machine->ram_size;
}
}
pc_cpus_init(pcms);
if (kvm_enabled() && pcmc->kvmclock_enabled) {
kvmclock_create();
}
if (pcmc->pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
memory_region_init(pci_memory, NULL, "pci", UINT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
pc_guest_info_init(pcms);
if (pcmc->smbios_defaults) {
MachineClass *mc = MACHINE_GET_CLASS(machine);
/* These values are guest ABI, do not change */
smbios_set_defaults("QEMU", "Standard PC (i440FX + PIIX, 1996)",
mc->name, pcmc->smbios_legacy_mode,
pcmc->smbios_uuid_encoded,
SMBIOS_ENTRY_POINT_21);
}
/* allocate ram and load rom/bios */
if (!xen_enabled()) {
pc_memory_init(pcms, system_memory,
rom_memory, &ram_memory);
} else if (machine->kernel_filename != NULL) {
/* For xen HVM direct kernel boot, load linux here */
xen_load_linux(pcms);
}
gsi_state = g_malloc0(sizeof(*gsi_state));
if (kvm_ioapic_in_kernel()) {
kvm_pc_setup_irq_routing(pcmc->pci_enabled);
gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,
GSI_NUM_PINS);
} else {
gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
}
if (pcmc->pci_enabled) {
pci_bus = i440fx_init(host_type,
pci_type,
&i440fx_state, &piix3_devfn, &isa_bus, gsi,
system_memory, system_io, machine->ram_size,
pcms->below_4g_mem_size,
pcms->above_4g_mem_size,
pci_memory, ram_memory);
pcms->bus = pci_bus;
} else {
pci_bus = NULL;
i440fx_state = NULL;
isa_bus = isa_bus_new(NULL, get_system_memory(), system_io,
&error_abort);
no_hpet = 1;
}
isa_bus_irqs(isa_bus, gsi);
if (kvm_pic_in_kernel()) {
i8259 = kvm_i8259_init(isa_bus);
} else if (xen_enabled()) {
i8259 = xen_interrupt_controller_init();
} else {
i8259 = i8259_init(isa_bus, pc_allocate_cpu_irq());
}
for (i = 0; i < ISA_NUM_IRQS; i++) {
gsi_state->i8259_irq[i] = i8259[i];
}
g_free(i8259);
if (pcmc->pci_enabled) {
ioapic_init_gsi(gsi_state, "i440fx");
}
pc_register_ferr_irq(gsi[13]);
pc_vga_init(isa_bus, pcmc->pci_enabled ? pci_bus : NULL);
assert(pcms->vmport != ON_OFF_AUTO__MAX);
if (pcms->vmport == ON_OFF_AUTO_AUTO) {
pcms->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;
}
/* init basic PC hardware */
pc_basic_device_init(isa_bus, gsi, &rtc_state, true,
(pcms->vmport != ON_OFF_AUTO_ON), 0x4);
pc_nic_init(isa_bus, pci_bus);
ide_drive_get(hd, ARRAY_SIZE(hd));
if (pcmc->pci_enabled) {
PCIDevice *dev;
if (xen_enabled()) {
dev = pci_piix3_xen_ide_init(pci_bus, hd, piix3_devfn + 1);
} else {
dev = pci_piix3_ide_init(pci_bus, hd, piix3_devfn + 1);
}
idebus[0] = qdev_get_child_bus(&dev->qdev, "ide.0");
idebus[1] = qdev_get_child_bus(&dev->qdev, "ide.1");
} else {
for(i = 0; i < MAX_IDE_BUS; i++) {
ISADevice *dev;
char busname[] = "ide.0";
dev = isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i],
ide_irq[i],
hd[MAX_IDE_DEVS * i], hd[MAX_IDE_DEVS * i + 1]);
/*
* The ide bus name is ide.0 for the first bus and ide.1 for the
* second one.
*/
busname[4] = '0' + i;
idebus[i] = qdev_get_child_bus(DEVICE(dev), busname);
}
}
pc_cmos_init(pcms, idebus[0], idebus[1], rtc_state);
if (pcmc->pci_enabled && machine_usb(machine)) {
pci_create_simple(pci_bus, piix3_devfn + 2, "piix3-usb-uhci");
}
if (pcmc->pci_enabled && acpi_enabled) {
DeviceState *piix4_pm;
I2CBus *smbus;
smi_irq = qemu_allocate_irq(pc_acpi_smi_interrupt, first_cpu, 0);
/* TODO: Populate SPD eeprom data. */
smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
gsi[9], smi_irq,
pc_machine_is_smm_enabled(pcms),
&piix4_pm);
smbus_eeprom_init(smbus, 8, NULL, 0);
object_property_add_link(OBJECT(machine), PC_MACHINE_ACPI_DEVICE_PROP,
TYPE_HOTPLUG_HANDLER,
(Object **)&pcms->acpi_dev,
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);
object_property_set_link(OBJECT(machine), OBJECT(piix4_pm),
PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
}
if (pcmc->pci_enabled) {
pc_pci_device_init(pci_bus);
}
if (pcms->acpi_nvdimm_state.is_enabled) {
nvdimm_init_acpi_state(&pcms->acpi_nvdimm_state, system_io,
pcms->fw_cfg, OBJECT(pcms));
}
}
| true | qemu | 3e6c0c4c2cc4d5ee77f6f2746c4608f077e10f62 | static void pc_init1(MachineState *machine,
const char *host_type, const char *pci_type)
{
PCMachineState *pcms = PC_MACHINE(machine);
PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int i;
PCIBus *pci_bus;
ISABus *isa_bus;
PCII440FXState *i440fx_state;
int piix3_devfn = -1;
qemu_irq *gsi;
qemu_irq *i8259;
qemu_irq smi_irq;
GSIState *gsi_state;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
BusState *idebus[MAX_IDE_BUS];
ISADevice *rtc_state;
MemoryRegion *ram_memory;
MemoryRegion *pci_memory;
MemoryRegion *rom_memory;
ram_addr_t lowmem;
if (xen_enabled()) {
xen_hvm_init(pcms, &ram_memory);
} else {
if (!pcms->max_ram_below_4g) {
pcms->max_ram_below_4g = 0xe0000000;
}
lowmem = pcms->max_ram_below_4g;
if (machine->ram_size >= pcms->max_ram_below_4g) {
if (pcmc->gigabyte_align) {
if (lowmem > 0xc0000000) {
lowmem = 0xc0000000;
}
if (lowmem & ((1ULL << 30) - 1)) {
error_report("Warning: Large machine and max_ram_below_4g "
"(%" PRIu64 ") not a multiple of 1G; "
"possible bad performance.",
pcms->max_ram_below_4g);
}
}
}
if (machine->ram_size >= lowmem) {
pcms->above_4g_mem_size = machine->ram_size - lowmem;
pcms->below_4g_mem_size = lowmem;
} else {
pcms->above_4g_mem_size = 0;
pcms->below_4g_mem_size = machine->ram_size;
}
}
pc_cpus_init(pcms);
if (kvm_enabled() && pcmc->kvmclock_enabled) {
kvmclock_create();
}
if (pcmc->pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
memory_region_init(pci_memory, NULL, "pci", UINT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
pc_guest_info_init(pcms);
if (pcmc->smbios_defaults) {
MachineClass *mc = MACHINE_GET_CLASS(machine);
smbios_set_defaults("QEMU", "Standard PC (i440FX + PIIX, 1996)",
mc->name, pcmc->smbios_legacy_mode,
pcmc->smbios_uuid_encoded,
SMBIOS_ENTRY_POINT_21);
}
if (!xen_enabled()) {
pc_memory_init(pcms, system_memory,
rom_memory, &ram_memory);
} else if (machine->kernel_filename != NULL) {
xen_load_linux(pcms);
}
gsi_state = g_malloc0(sizeof(*gsi_state));
if (kvm_ioapic_in_kernel()) {
kvm_pc_setup_irq_routing(pcmc->pci_enabled);
gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,
GSI_NUM_PINS);
} else {
gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
}
if (pcmc->pci_enabled) {
pci_bus = i440fx_init(host_type,
pci_type,
&i440fx_state, &piix3_devfn, &isa_bus, gsi,
system_memory, system_io, machine->ram_size,
pcms->below_4g_mem_size,
pcms->above_4g_mem_size,
pci_memory, ram_memory);
pcms->bus = pci_bus;
} else {
pci_bus = NULL;
i440fx_state = NULL;
isa_bus = isa_bus_new(NULL, get_system_memory(), system_io,
&error_abort);
no_hpet = 1;
}
isa_bus_irqs(isa_bus, gsi);
if (kvm_pic_in_kernel()) {
i8259 = kvm_i8259_init(isa_bus);
} else if (xen_enabled()) {
i8259 = xen_interrupt_controller_init();
} else {
i8259 = i8259_init(isa_bus, pc_allocate_cpu_irq());
}
for (i = 0; i < ISA_NUM_IRQS; i++) {
gsi_state->i8259_irq[i] = i8259[i];
}
g_free(i8259);
if (pcmc->pci_enabled) {
ioapic_init_gsi(gsi_state, "i440fx");
}
pc_register_ferr_irq(gsi[13]);
pc_vga_init(isa_bus, pcmc->pci_enabled ? pci_bus : NULL);
assert(pcms->vmport != ON_OFF_AUTO__MAX);
if (pcms->vmport == ON_OFF_AUTO_AUTO) {
pcms->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;
}
pc_basic_device_init(isa_bus, gsi, &rtc_state, true,
(pcms->vmport != ON_OFF_AUTO_ON), 0x4);
pc_nic_init(isa_bus, pci_bus);
ide_drive_get(hd, ARRAY_SIZE(hd));
if (pcmc->pci_enabled) {
PCIDevice *dev;
if (xen_enabled()) {
dev = pci_piix3_xen_ide_init(pci_bus, hd, piix3_devfn + 1);
} else {
dev = pci_piix3_ide_init(pci_bus, hd, piix3_devfn + 1);
}
idebus[0] = qdev_get_child_bus(&dev->qdev, "ide.0");
idebus[1] = qdev_get_child_bus(&dev->qdev, "ide.1");
} else {
for(i = 0; i < MAX_IDE_BUS; i++) {
ISADevice *dev;
char busname[] = "ide.0";
dev = isa_ide_init(isa_bus, ide_iobase[i], ide_iobase2[i],
ide_irq[i],
hd[MAX_IDE_DEVS * i], hd[MAX_IDE_DEVS * i + 1]);
busname[4] = '0' + i;
idebus[i] = qdev_get_child_bus(DEVICE(dev), busname);
}
}
pc_cmos_init(pcms, idebus[0], idebus[1], rtc_state);
if (pcmc->pci_enabled && machine_usb(machine)) {
pci_create_simple(pci_bus, piix3_devfn + 2, "piix3-usb-uhci");
}
if (pcmc->pci_enabled && acpi_enabled) {
DeviceState *piix4_pm;
I2CBus *smbus;
smi_irq = qemu_allocate_irq(pc_acpi_smi_interrupt, first_cpu, 0);
smbus = piix4_pm_init(pci_bus, piix3_devfn + 3, 0xb100,
gsi[9], smi_irq,
pc_machine_is_smm_enabled(pcms),
&piix4_pm);
smbus_eeprom_init(smbus, 8, NULL, 0);
object_property_add_link(OBJECT(machine), PC_MACHINE_ACPI_DEVICE_PROP,
TYPE_HOTPLUG_HANDLER,
(Object **)&pcms->acpi_dev,
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);
object_property_set_link(OBJECT(machine), OBJECT(piix4_pm),
PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
}
if (pcmc->pci_enabled) {
pc_pci_device_init(pci_bus);
}
if (pcms->acpi_nvdimm_state.is_enabled) {
nvdimm_init_acpi_state(&pcms->acpi_nvdimm_state, system_io,
pcms->fw_cfg, OBJECT(pcms));
}
}
| {
"code": [
" qemu_irq *gsi;",
" gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,",
" GSI_NUM_PINS);",
" gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);",
" &i440fx_state, &piix3_devfn, &isa_bus, gsi,",
" isa_bus_irqs(isa_bus, gsi);",
" pc_register_ferr_irq(gsi[13]);",
" pc_basic_device_init(isa_bus, gsi, &rtc_state, true,",
" gsi[9], smi_irq,",
" qemu_irq *gsi;",
" gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,",
" GSI_NUM_PINS);",
" gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);",
" pc_register_ferr_irq(gsi[13]);"
],
"line_no": [
25,
247,
249,
253,
265,
291,
327,
347,
435,
25,
247,
249,
253,
327
]
} | static void FUNC_0(MachineState *VAR_0,
const char *VAR_1, const char *VAR_2)
{
PCMachineState *pcms = PC_MACHINE(VAR_0);
PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int VAR_3;
PCIBus *pci_bus;
ISABus *isa_bus;
PCII440FXState *i440fx_state;
int VAR_4 = -1;
qemu_irq *gsi;
qemu_irq *i8259;
qemu_irq smi_irq;
GSIState *gsi_state;
DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];
BusState *idebus[MAX_IDE_BUS];
ISADevice *rtc_state;
MemoryRegion *ram_memory;
MemoryRegion *pci_memory;
MemoryRegion *rom_memory;
ram_addr_t lowmem;
if (xen_enabled()) {
xen_hvm_init(pcms, &ram_memory);
} else {
if (!pcms->max_ram_below_4g) {
pcms->max_ram_below_4g = 0xe0000000;
}
lowmem = pcms->max_ram_below_4g;
if (VAR_0->ram_size >= pcms->max_ram_below_4g) {
if (pcmc->gigabyte_align) {
if (lowmem > 0xc0000000) {
lowmem = 0xc0000000;
}
if (lowmem & ((1ULL << 30) - 1)) {
error_report("Warning: Large VAR_0 and max_ram_below_4g "
"(%" PRIu64 ") not a multiple of 1G; "
"possible bad performance.",
pcms->max_ram_below_4g);
}
}
}
if (VAR_0->ram_size >= lowmem) {
pcms->above_4g_mem_size = VAR_0->ram_size - lowmem;
pcms->below_4g_mem_size = lowmem;
} else {
pcms->above_4g_mem_size = 0;
pcms->below_4g_mem_size = VAR_0->ram_size;
}
}
pc_cpus_init(pcms);
if (kvm_enabled() && pcmc->kvmclock_enabled) {
kvmclock_create();
}
if (pcmc->pci_enabled) {
pci_memory = g_new(MemoryRegion, 1);
memory_region_init(pci_memory, NULL, "pci", UINT64_MAX);
rom_memory = pci_memory;
} else {
pci_memory = NULL;
rom_memory = system_memory;
}
pc_guest_info_init(pcms);
if (pcmc->smbios_defaults) {
MachineClass *mc = MACHINE_GET_CLASS(VAR_0);
smbios_set_defaults("QEMU", "Standard PC (i440FX + PIIX, 1996)",
mc->name, pcmc->smbios_legacy_mode,
pcmc->smbios_uuid_encoded,
SMBIOS_ENTRY_POINT_21);
}
if (!xen_enabled()) {
pc_memory_init(pcms, system_memory,
rom_memory, &ram_memory);
} else if (VAR_0->kernel_filename != NULL) {
xen_load_linux(pcms);
}
gsi_state = g_malloc0(sizeof(*gsi_state));
if (kvm_ioapic_in_kernel()) {
kvm_pc_setup_irq_routing(pcmc->pci_enabled);
gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,
GSI_NUM_PINS);
} else {
gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);
}
if (pcmc->pci_enabled) {
pci_bus = i440fx_init(VAR_1,
VAR_2,
&i440fx_state, &VAR_4, &isa_bus, gsi,
system_memory, system_io, VAR_0->ram_size,
pcms->below_4g_mem_size,
pcms->above_4g_mem_size,
pci_memory, ram_memory);
pcms->bus = pci_bus;
} else {
pci_bus = NULL;
i440fx_state = NULL;
isa_bus = isa_bus_new(NULL, get_system_memory(), system_io,
&error_abort);
no_hpet = 1;
}
isa_bus_irqs(isa_bus, gsi);
if (kvm_pic_in_kernel()) {
i8259 = kvm_i8259_init(isa_bus);
} else if (xen_enabled()) {
i8259 = xen_interrupt_controller_init();
} else {
i8259 = i8259_init(isa_bus, pc_allocate_cpu_irq());
}
for (VAR_3 = 0; VAR_3 < ISA_NUM_IRQS; VAR_3++) {
gsi_state->i8259_irq[VAR_3] = i8259[VAR_3];
}
g_free(i8259);
if (pcmc->pci_enabled) {
ioapic_init_gsi(gsi_state, "i440fx");
}
pc_register_ferr_irq(gsi[13]);
pc_vga_init(isa_bus, pcmc->pci_enabled ? pci_bus : NULL);
assert(pcms->vmport != ON_OFF_AUTO__MAX);
if (pcms->vmport == ON_OFF_AUTO_AUTO) {
pcms->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;
}
pc_basic_device_init(isa_bus, gsi, &rtc_state, true,
(pcms->vmport != ON_OFF_AUTO_ON), 0x4);
pc_nic_init(isa_bus, pci_bus);
ide_drive_get(hd, ARRAY_SIZE(hd));
if (pcmc->pci_enabled) {
PCIDevice *dev;
if (xen_enabled()) {
dev = pci_piix3_xen_ide_init(pci_bus, hd, VAR_4 + 1);
} else {
dev = pci_piix3_ide_init(pci_bus, hd, VAR_4 + 1);
}
idebus[0] = qdev_get_child_bus(&dev->qdev, "ide.0");
idebus[1] = qdev_get_child_bus(&dev->qdev, "ide.1");
} else {
for(VAR_3 = 0; VAR_3 < MAX_IDE_BUS; VAR_3++) {
ISADevice *dev;
char busname[] = "ide.0";
dev = isa_ide_init(isa_bus, ide_iobase[VAR_3], ide_iobase2[VAR_3],
ide_irq[VAR_3],
hd[MAX_IDE_DEVS * VAR_3], hd[MAX_IDE_DEVS * VAR_3 + 1]);
busname[4] = '0' + VAR_3;
idebus[VAR_3] = qdev_get_child_bus(DEVICE(dev), busname);
}
}
pc_cmos_init(pcms, idebus[0], idebus[1], rtc_state);
if (pcmc->pci_enabled && machine_usb(VAR_0)) {
pci_create_simple(pci_bus, VAR_4 + 2, "piix3-usb-uhci");
}
if (pcmc->pci_enabled && acpi_enabled) {
DeviceState *piix4_pm;
I2CBus *smbus;
smi_irq = qemu_allocate_irq(pc_acpi_smi_interrupt, first_cpu, 0);
smbus = piix4_pm_init(pci_bus, VAR_4 + 3, 0xb100,
gsi[9], smi_irq,
pc_machine_is_smm_enabled(pcms),
&piix4_pm);
smbus_eeprom_init(smbus, 8, NULL, 0);
object_property_add_link(OBJECT(VAR_0), PC_MACHINE_ACPI_DEVICE_PROP,
TYPE_HOTPLUG_HANDLER,
(Object **)&pcms->acpi_dev,
object_property_allow_set_link,
OBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);
object_property_set_link(OBJECT(VAR_0), OBJECT(piix4_pm),
PC_MACHINE_ACPI_DEVICE_PROP, &error_abort);
}
if (pcmc->pci_enabled) {
pc_pci_device_init(pci_bus);
}
if (pcms->acpi_nvdimm_state.is_enabled) {
nvdimm_init_acpi_state(&pcms->acpi_nvdimm_state, system_io,
pcms->fw_cfg, OBJECT(pcms));
}
}
| [
"static void FUNC_0(MachineState *VAR_0,\nconst char *VAR_1, const char *VAR_2)\n{",
"PCMachineState *pcms = PC_MACHINE(VAR_0);",
"PCMachineClass *pcmc = PC_MACHINE_GET_CLASS(pcms);",
"MemoryRegion *system_memory = get_system_memory();",
"MemoryRegion *system_io = get_system_io();",
"int VAR_3;",
"PCIBus *pci_bus;",
"ISABus *isa_bus;",
"PCII440FXState *i440fx_state;",
"int VAR_4 = -1;",
"qemu_irq *gsi;",
"qemu_irq *i8259;",
"qemu_irq smi_irq;",
"GSIState *gsi_state;",
"DriveInfo *hd[MAX_IDE_BUS * MAX_IDE_DEVS];",
"BusState *idebus[MAX_IDE_BUS];",
"ISADevice *rtc_state;",
"MemoryRegion *ram_memory;",
"MemoryRegion *pci_memory;",
"MemoryRegion *rom_memory;",
"ram_addr_t lowmem;",
"if (xen_enabled()) {",
"xen_hvm_init(pcms, &ram_memory);",
"} else {",
"if (!pcms->max_ram_below_4g) {",
"pcms->max_ram_below_4g = 0xe0000000;",
"}",
"lowmem = pcms->max_ram_below_4g;",
"if (VAR_0->ram_size >= pcms->max_ram_below_4g) {",
"if (pcmc->gigabyte_align) {",
"if (lowmem > 0xc0000000) {",
"lowmem = 0xc0000000;",
"}",
"if (lowmem & ((1ULL << 30) - 1)) {",
"error_report(\"Warning: Large VAR_0 and max_ram_below_4g \"\n\"(%\" PRIu64 \") not a multiple of 1G; \"",
"\"possible bad performance.\",\npcms->max_ram_below_4g);",
"}",
"}",
"}",
"if (VAR_0->ram_size >= lowmem) {",
"pcms->above_4g_mem_size = VAR_0->ram_size - lowmem;",
"pcms->below_4g_mem_size = lowmem;",
"} else {",
"pcms->above_4g_mem_size = 0;",
"pcms->below_4g_mem_size = VAR_0->ram_size;",
"}",
"}",
"pc_cpus_init(pcms);",
"if (kvm_enabled() && pcmc->kvmclock_enabled) {",
"kvmclock_create();",
"}",
"if (pcmc->pci_enabled) {",
"pci_memory = g_new(MemoryRegion, 1);",
"memory_region_init(pci_memory, NULL, \"pci\", UINT64_MAX);",
"rom_memory = pci_memory;",
"} else {",
"pci_memory = NULL;",
"rom_memory = system_memory;",
"}",
"pc_guest_info_init(pcms);",
"if (pcmc->smbios_defaults) {",
"MachineClass *mc = MACHINE_GET_CLASS(VAR_0);",
"smbios_set_defaults(\"QEMU\", \"Standard PC (i440FX + PIIX, 1996)\",\nmc->name, pcmc->smbios_legacy_mode,\npcmc->smbios_uuid_encoded,\nSMBIOS_ENTRY_POINT_21);",
"}",
"if (!xen_enabled()) {",
"pc_memory_init(pcms, system_memory,\nrom_memory, &ram_memory);",
"} else if (VAR_0->kernel_filename != NULL) {",
"xen_load_linux(pcms);",
"}",
"gsi_state = g_malloc0(sizeof(*gsi_state));",
"if (kvm_ioapic_in_kernel()) {",
"kvm_pc_setup_irq_routing(pcmc->pci_enabled);",
"gsi = qemu_allocate_irqs(kvm_pc_gsi_handler, gsi_state,\nGSI_NUM_PINS);",
"} else {",
"gsi = qemu_allocate_irqs(gsi_handler, gsi_state, GSI_NUM_PINS);",
"}",
"if (pcmc->pci_enabled) {",
"pci_bus = i440fx_init(VAR_1,\nVAR_2,\n&i440fx_state, &VAR_4, &isa_bus, gsi,\nsystem_memory, system_io, VAR_0->ram_size,\npcms->below_4g_mem_size,\npcms->above_4g_mem_size,\npci_memory, ram_memory);",
"pcms->bus = pci_bus;",
"} else {",
"pci_bus = NULL;",
"i440fx_state = NULL;",
"isa_bus = isa_bus_new(NULL, get_system_memory(), system_io,\n&error_abort);",
"no_hpet = 1;",
"}",
"isa_bus_irqs(isa_bus, gsi);",
"if (kvm_pic_in_kernel()) {",
"i8259 = kvm_i8259_init(isa_bus);",
"} else if (xen_enabled()) {",
"i8259 = xen_interrupt_controller_init();",
"} else {",
"i8259 = i8259_init(isa_bus, pc_allocate_cpu_irq());",
"}",
"for (VAR_3 = 0; VAR_3 < ISA_NUM_IRQS; VAR_3++) {",
"gsi_state->i8259_irq[VAR_3] = i8259[VAR_3];",
"}",
"g_free(i8259);",
"if (pcmc->pci_enabled) {",
"ioapic_init_gsi(gsi_state, \"i440fx\");",
"}",
"pc_register_ferr_irq(gsi[13]);",
"pc_vga_init(isa_bus, pcmc->pci_enabled ? pci_bus : NULL);",
"assert(pcms->vmport != ON_OFF_AUTO__MAX);",
"if (pcms->vmport == ON_OFF_AUTO_AUTO) {",
"pcms->vmport = xen_enabled() ? ON_OFF_AUTO_OFF : ON_OFF_AUTO_ON;",
"}",
"pc_basic_device_init(isa_bus, gsi, &rtc_state, true,\n(pcms->vmport != ON_OFF_AUTO_ON), 0x4);",
"pc_nic_init(isa_bus, pci_bus);",
"ide_drive_get(hd, ARRAY_SIZE(hd));",
"if (pcmc->pci_enabled) {",
"PCIDevice *dev;",
"if (xen_enabled()) {",
"dev = pci_piix3_xen_ide_init(pci_bus, hd, VAR_4 + 1);",
"} else {",
"dev = pci_piix3_ide_init(pci_bus, hd, VAR_4 + 1);",
"}",
"idebus[0] = qdev_get_child_bus(&dev->qdev, \"ide.0\");",
"idebus[1] = qdev_get_child_bus(&dev->qdev, \"ide.1\");",
"} else {",
"for(VAR_3 = 0; VAR_3 < MAX_IDE_BUS; VAR_3++) {",
"ISADevice *dev;",
"char busname[] = \"ide.0\";",
"dev = isa_ide_init(isa_bus, ide_iobase[VAR_3], ide_iobase2[VAR_3],\nide_irq[VAR_3],\nhd[MAX_IDE_DEVS * VAR_3], hd[MAX_IDE_DEVS * VAR_3 + 1]);",
"busname[4] = '0' + VAR_3;",
"idebus[VAR_3] = qdev_get_child_bus(DEVICE(dev), busname);",
"}",
"}",
"pc_cmos_init(pcms, idebus[0], idebus[1], rtc_state);",
"if (pcmc->pci_enabled && machine_usb(VAR_0)) {",
"pci_create_simple(pci_bus, VAR_4 + 2, \"piix3-usb-uhci\");",
"}",
"if (pcmc->pci_enabled && acpi_enabled) {",
"DeviceState *piix4_pm;",
"I2CBus *smbus;",
"smi_irq = qemu_allocate_irq(pc_acpi_smi_interrupt, first_cpu, 0);",
"smbus = piix4_pm_init(pci_bus, VAR_4 + 3, 0xb100,\ngsi[9], smi_irq,\npc_machine_is_smm_enabled(pcms),\n&piix4_pm);",
"smbus_eeprom_init(smbus, 8, NULL, 0);",
"object_property_add_link(OBJECT(VAR_0), PC_MACHINE_ACPI_DEVICE_PROP,\nTYPE_HOTPLUG_HANDLER,\n(Object **)&pcms->acpi_dev,\nobject_property_allow_set_link,\nOBJ_PROP_LINK_UNREF_ON_RELEASE, &error_abort);",
"object_property_set_link(OBJECT(VAR_0), OBJECT(piix4_pm),\nPC_MACHINE_ACPI_DEVICE_PROP, &error_abort);",
"}",
"if (pcmc->pci_enabled) {",
"pc_pci_device_init(pci_bus);",
"}",
"if (pcms->acpi_nvdimm_state.is_enabled) {",
"nvdimm_init_acpi_state(&pcms->acpi_nvdimm_state, system_io,\npcms->fw_cfg, OBJECT(pcms));",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137,
139
],
[
141,
143
],
[
145
],
[
147
],
[
149
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
171
],
[
175
],
[
177
],
[
179
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201
],
[
205
],
[
207
],
[
211,
213,
215,
217
],
[
219
],
[
225
],
[
227,
229
],
[
231
],
[
235
],
[
237
],
[
241
],
[
243
],
[
245
],
[
247,
249
],
[
251
],
[
253
],
[
255
],
[
259
],
[
261,
263,
265,
267,
269,
271,
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283,
285
],
[
287
],
[
289
],
[
291
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303
],
[
305
],
[
307
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
321
],
[
323
],
[
327
],
[
331
],
[
335
],
[
337
],
[
339
],
[
341
],
[
347,
349
],
[
353
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
371
],
[
373
],
[
375
],
[
377
],
[
379
],
[
381
],
[
383
],
[
385,
387,
389
],
[
399
],
[
401
],
[
403
],
[
405
],
[
409
],
[
413
],
[
415
],
[
417
],
[
421
],
[
423
],
[
425
],
[
429
],
[
433,
435,
437,
439
],
[
441
],
[
445,
447,
449,
451,
453
],
[
455,
457
],
[
459
],
[
463
],
[
465
],
[
467
],
[
471
],
[
473,
475
],
[
477
],
[
479
]
]
|
12,821 | static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
struct bdrv_iterate_context context = { mon, 0 };
bdrv_iterate(encrypted_bdrv_it, &context);
/* only resume the vm if all keys are set and valid */
if (!context.err) {
vm_start();
return 0;
} else {
| true | qemu | 8e84865e54cb66fd7b57bb18c312ad3d56b6e276 | static int do_cont(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
struct bdrv_iterate_context context = { mon, 0 };
bdrv_iterate(encrypted_bdrv_it, &context);
if (!context.err) {
vm_start();
return 0;
} else {
| {
"code": [],
"line_no": []
} | static int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)
{
struct bdrv_iterate_context VAR_3 = { VAR_0, 0 };
bdrv_iterate(encrypted_bdrv_it, &VAR_3);
if (!VAR_3.err) {
vm_start();
return 0;
} else {
| [
"static int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)\n{",
"struct bdrv_iterate_context VAR_3 = { VAR_0, 0 };",
"bdrv_iterate(encrypted_bdrv_it, &VAR_3);",
"if (!VAR_3.err) {",
"vm_start();",
"return 0;",
"} else {"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
]
]
|
12,822 | static void colo_old_packet_check(void *opaque)
{
CompareState *s = opaque;
g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL);
}
| true | qemu | d25a7dabf242163ce95b60f6f75cf017b1715d55 | static void colo_old_packet_check(void *opaque)
{
CompareState *s = opaque;
g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL);
}
| {
"code": [
" g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL);"
],
"line_no": [
9
]
} | static void FUNC_0(void *VAR_0)
{
CompareState *s = VAR_0;
g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL);
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"CompareState *s = VAR_0;",
"g_queue_foreach(&s->conn_list, colo_old_packet_check_one_conn, NULL);",
"}"
]
| [
0,
0,
1,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
]
]
|
12,824 | int pci_add_capability(PCIDevice *pdev, uint8_t cap_id,
uint8_t offset, uint8_t size)
{
int ret;
Error *local_err = NULL;
ret = pci_add_capability2(pdev, cap_id, offset, size, &local_err);
if (local_err) {
assert(ret < 0);
error_report_err(local_err);
} else {
/* success implies a positive offset in config space */
assert(ret > 0);
}
return ret;
}
| true | qemu | 673b0d7ccc34e9617d99ed4c29caa964f19a4c5a | int pci_add_capability(PCIDevice *pdev, uint8_t cap_id,
uint8_t offset, uint8_t size)
{
int ret;
Error *local_err = NULL;
ret = pci_add_capability2(pdev, cap_id, offset, size, &local_err);
if (local_err) {
assert(ret < 0);
error_report_err(local_err);
} else {
assert(ret > 0);
}
return ret;
}
| {
"code": [
" if (local_err) {",
" assert(ret < 0);",
" } else {",
" assert(ret > 0);"
],
"line_no": [
15,
17,
21,
25
]
} | int FUNC_0(PCIDevice *VAR_0, uint8_t VAR_1,
uint8_t VAR_2, uint8_t VAR_3)
{
int VAR_4;
Error *local_err = NULL;
VAR_4 = pci_add_capability2(VAR_0, VAR_1, VAR_2, VAR_3, &local_err);
if (local_err) {
assert(VAR_4 < 0);
error_report_err(local_err);
} else {
assert(VAR_4 > 0);
}
return VAR_4;
}
| [
"int FUNC_0(PCIDevice *VAR_0, uint8_t VAR_1,\nuint8_t VAR_2, uint8_t VAR_3)\n{",
"int VAR_4;",
"Error *local_err = NULL;",
"VAR_4 = pci_add_capability2(VAR_0, VAR_1, VAR_2, VAR_3, &local_err);",
"if (local_err) {",
"assert(VAR_4 < 0);",
"error_report_err(local_err);",
"} else {",
"assert(VAR_4 > 0);",
"}",
"return VAR_4;",
"}"
]
| [
0,
0,
0,
0,
1,
1,
0,
0,
1,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
]
]
|
12,825 | static void write_bootloader(uint8_t *base, int64_t run_addr,
int64_t kernel_entry)
{
uint32_t *p;
/* Small bootloader */
p = (uint32_t *)base;
stl_p(p++, 0x08000000 | /* j 0x1fc00580 */
((run_addr + 0x580) & 0x0fffffff) >> 2);
stl_p(p++, 0x00000000); /* nop */
/* YAMON service vector */
stl_p(base + 0x500, run_addr + 0x0580); /* start: */
stl_p(base + 0x504, run_addr + 0x083c); /* print_count: */
stl_p(base + 0x520, run_addr + 0x0580); /* start: */
stl_p(base + 0x52c, run_addr + 0x0800); /* flush_cache: */
stl_p(base + 0x534, run_addr + 0x0808); /* print: */
stl_p(base + 0x538, run_addr + 0x0800); /* reg_cpu_isr: */
stl_p(base + 0x53c, run_addr + 0x0800); /* unred_cpu_isr: */
stl_p(base + 0x540, run_addr + 0x0800); /* reg_ic_isr: */
stl_p(base + 0x544, run_addr + 0x0800); /* unred_ic_isr: */
stl_p(base + 0x548, run_addr + 0x0800); /* reg_esr: */
stl_p(base + 0x54c, run_addr + 0x0800); /* unreg_esr: */
stl_p(base + 0x550, run_addr + 0x0800); /* getchar: */
stl_p(base + 0x554, run_addr + 0x0800); /* syscon_read: */
/* Second part of the bootloader */
p = (uint32_t *) (base + 0x580);
if (semihosting_get_argc()) {
/* Preserve a0 content as arguments have been passed */
stl_p(p++, 0x00000000); /* nop */
} else {
stl_p(p++, 0x24040002); /* addiu a0, zero, 2 */
}
stl_p(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff)); /* lui sp, high(ENVP_ADDR) */
stl_p(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff)); /* ori sp, sp, low(ENVP_ADDR) */
stl_p(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff)); /* lui a1, high(ENVP_ADDR) */
stl_p(p++, 0x34a50000 | (ENVP_ADDR & 0xffff)); /* ori a1, a1, low(ENVP_ADDR) */
stl_p(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff)); /* lui a2, high(ENVP_ADDR + 8) */
stl_p(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff)); /* ori a2, a2, low(ENVP_ADDR + 8) */
stl_p(p++, 0x3c070000 | (loaderparams.ram_low_size >> 16)); /* lui a3, high(ram_low_size) */
stl_p(p++, 0x34e70000 | (loaderparams.ram_low_size & 0xffff)); /* ori a3, a3, low(ram_low_size) */
/* Load BAR registers as done by YAMON */
stl_p(p++, 0x3c09b400); /* lui t1, 0xb400 */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08df00); /* lui t0, 0xdf00 */
#else
stl_p(p++, 0x340800df); /* ori t0, r0, 0x00df */
#endif
stl_p(p++, 0xad280068); /* sw t0, 0x0068(t1) */
stl_p(p++, 0x3c09bbe0); /* lui t1, 0xbbe0 */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08c000); /* lui t0, 0xc000 */
#else
stl_p(p++, 0x340800c0); /* ori t0, r0, 0x00c0 */
#endif
stl_p(p++, 0xad280048); /* sw t0, 0x0048(t1) */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c084000); /* lui t0, 0x4000 */
#else
stl_p(p++, 0x34080040); /* ori t0, r0, 0x0040 */
#endif
stl_p(p++, 0xad280050); /* sw t0, 0x0050(t1) */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c088000); /* lui t0, 0x8000 */
#else
stl_p(p++, 0x34080080); /* ori t0, r0, 0x0080 */
#endif
stl_p(p++, 0xad280058); /* sw t0, 0x0058(t1) */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c083f00); /* lui t0, 0x3f00 */
#else
stl_p(p++, 0x3408003f); /* ori t0, r0, 0x003f */
#endif
stl_p(p++, 0xad280060); /* sw t0, 0x0060(t1) */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08c100); /* lui t0, 0xc100 */
#else
stl_p(p++, 0x340800c1); /* ori t0, r0, 0x00c1 */
#endif
stl_p(p++, 0xad280080); /* sw t0, 0x0080(t1) */
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c085e00); /* lui t0, 0x5e00 */
#else
stl_p(p++, 0x3408005e); /* ori t0, r0, 0x005e */
#endif
stl_p(p++, 0xad280088); /* sw t0, 0x0088(t1) */
/* Jump to kernel code */
stl_p(p++, 0x3c1f0000 | ((kernel_entry >> 16) & 0xffff)); /* lui ra, high(kernel_entry) */
stl_p(p++, 0x37ff0000 | (kernel_entry & 0xffff)); /* ori ra, ra, low(kernel_entry) */
stl_p(p++, 0x03e00009); /* jalr ra */
stl_p(p++, 0x00000000); /* nop */
/* YAMON subroutines */
p = (uint32_t *) (base + 0x800);
stl_p(p++, 0x03e00009); /* jalr ra */
stl_p(p++, 0x24020000); /* li v0,0 */
/* 808 YAMON print */
stl_p(p++, 0x03e06821); /* move t5,ra */
stl_p(p++, 0x00805821); /* move t3,a0 */
stl_p(p++, 0x00a05021); /* move t2,a1 */
stl_p(p++, 0x91440000); /* lbu a0,0(t2) */
stl_p(p++, 0x254a0001); /* addiu t2,t2,1 */
stl_p(p++, 0x10800005); /* beqz a0,834 */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x0ff0021c); /* jal 870 */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x08000205); /* j 814 */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x01a00009); /* jalr t5 */
stl_p(p++, 0x01602021); /* move a0,t3 */
/* 0x83c YAMON print_count */
stl_p(p++, 0x03e06821); /* move t5,ra */
stl_p(p++, 0x00805821); /* move t3,a0 */
stl_p(p++, 0x00a05021); /* move t2,a1 */
stl_p(p++, 0x00c06021); /* move t4,a2 */
stl_p(p++, 0x91440000); /* lbu a0,0(t2) */
stl_p(p++, 0x0ff0021c); /* jal 870 */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x254a0001); /* addiu t2,t2,1 */
stl_p(p++, 0x258cffff); /* addiu t4,t4,-1 */
stl_p(p++, 0x1580fffa); /* bnez t4,84c */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x01a00009); /* jalr t5 */
stl_p(p++, 0x01602021); /* move a0,t3 */
/* 0x870 */
stl_p(p++, 0x3c08b800); /* lui t0,0xb400 */
stl_p(p++, 0x350803f8); /* ori t0,t0,0x3f8 */
stl_p(p++, 0x91090005); /* lbu t1,5(t0) */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x31290040); /* andi t1,t1,0x40 */
stl_p(p++, 0x1120fffc); /* beqz t1,878 <outch+0x8> */
stl_p(p++, 0x00000000); /* nop */
stl_p(p++, 0x03e00009); /* jalr ra */
stl_p(p++, 0xa1040000); /* sb a0,0(t0) */
}
| true | qemu | 7f81dbb9a0e89b5306c1337e0cd0e1cea8a03f6d | static void write_bootloader(uint8_t *base, int64_t run_addr,
int64_t kernel_entry)
{
uint32_t *p;
p = (uint32_t *)base;
stl_p(p++, 0x08000000 |
((run_addr + 0x580) & 0x0fffffff) >> 2);
stl_p(p++, 0x00000000);
stl_p(base + 0x500, run_addr + 0x0580);
stl_p(base + 0x504, run_addr + 0x083c);
stl_p(base + 0x520, run_addr + 0x0580);
stl_p(base + 0x52c, run_addr + 0x0800);
stl_p(base + 0x534, run_addr + 0x0808);
stl_p(base + 0x538, run_addr + 0x0800);
stl_p(base + 0x53c, run_addr + 0x0800);
stl_p(base + 0x540, run_addr + 0x0800);
stl_p(base + 0x544, run_addr + 0x0800);
stl_p(base + 0x548, run_addr + 0x0800);
stl_p(base + 0x54c, run_addr + 0x0800);
stl_p(base + 0x550, run_addr + 0x0800);
stl_p(base + 0x554, run_addr + 0x0800);
p = (uint32_t *) (base + 0x580);
if (semihosting_get_argc()) {
stl_p(p++, 0x00000000);
} else {
stl_p(p++, 0x24040002);
}
stl_p(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff));
stl_p(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff));
stl_p(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));
stl_p(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));
stl_p(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff));
stl_p(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));
stl_p(p++, 0x3c070000 | (loaderparams.ram_low_size >> 16));
stl_p(p++, 0x34e70000 | (loaderparams.ram_low_size & 0xffff));
stl_p(p++, 0x3c09b400);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08df00);
#else
stl_p(p++, 0x340800df);
#endif
stl_p(p++, 0xad280068);
stl_p(p++, 0x3c09bbe0);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08c000);
#else
stl_p(p++, 0x340800c0);
#endif
stl_p(p++, 0xad280048);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c084000);
#else
stl_p(p++, 0x34080040);
#endif
stl_p(p++, 0xad280050);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c088000);
#else
stl_p(p++, 0x34080080);
#endif
stl_p(p++, 0xad280058);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c083f00);
#else
stl_p(p++, 0x3408003f);
#endif
stl_p(p++, 0xad280060);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08c100);
#else
stl_p(p++, 0x340800c1);
#endif
stl_p(p++, 0xad280080);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c085e00);
#else
stl_p(p++, 0x3408005e);
#endif
stl_p(p++, 0xad280088);
stl_p(p++, 0x3c1f0000 | ((kernel_entry >> 16) & 0xffff));
stl_p(p++, 0x37ff0000 | (kernel_entry & 0xffff));
stl_p(p++, 0x03e00009);
stl_p(p++, 0x00000000);
p = (uint32_t *) (base + 0x800);
stl_p(p++, 0x03e00009);
stl_p(p++, 0x24020000);
stl_p(p++, 0x03e06821);
stl_p(p++, 0x00805821);
stl_p(p++, 0x00a05021);
stl_p(p++, 0x91440000);
stl_p(p++, 0x254a0001);
stl_p(p++, 0x10800005);
stl_p(p++, 0x00000000);
stl_p(p++, 0x0ff0021c);
stl_p(p++, 0x00000000);
stl_p(p++, 0x08000205);
stl_p(p++, 0x00000000);
stl_p(p++, 0x01a00009);
stl_p(p++, 0x01602021);
stl_p(p++, 0x03e06821);
stl_p(p++, 0x00805821);
stl_p(p++, 0x00a05021);
stl_p(p++, 0x00c06021);
stl_p(p++, 0x91440000);
stl_p(p++, 0x0ff0021c);
stl_p(p++, 0x00000000);
stl_p(p++, 0x254a0001);
stl_p(p++, 0x258cffff);
stl_p(p++, 0x1580fffa);
stl_p(p++, 0x00000000);
stl_p(p++, 0x01a00009);
stl_p(p++, 0x01602021);
stl_p(p++, 0x3c08b800);
stl_p(p++, 0x350803f8);
stl_p(p++, 0x91090005);
stl_p(p++, 0x00000000);
stl_p(p++, 0x31290040);
stl_p(p++, 0x1120fffc);
stl_p(p++, 0x00000000);
stl_p(p++, 0x03e00009);
stl_p(p++, 0xa1040000);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(uint8_t *VAR_0, int64_t VAR_1,
int64_t VAR_2)
{
uint32_t *p;
p = (uint32_t *)VAR_0;
stl_p(p++, 0x08000000 |
((VAR_1 + 0x580) & 0x0fffffff) >> 2);
stl_p(p++, 0x00000000);
stl_p(VAR_0 + 0x500, VAR_1 + 0x0580);
stl_p(VAR_0 + 0x504, VAR_1 + 0x083c);
stl_p(VAR_0 + 0x520, VAR_1 + 0x0580);
stl_p(VAR_0 + 0x52c, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x534, VAR_1 + 0x0808);
stl_p(VAR_0 + 0x538, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x53c, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x540, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x544, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x548, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x54c, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x550, VAR_1 + 0x0800);
stl_p(VAR_0 + 0x554, VAR_1 + 0x0800);
p = (uint32_t *) (VAR_0 + 0x580);
if (semihosting_get_argc()) {
stl_p(p++, 0x00000000);
} else {
stl_p(p++, 0x24040002);
}
stl_p(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff));
stl_p(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff));
stl_p(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));
stl_p(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));
stl_p(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff));
stl_p(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));
stl_p(p++, 0x3c070000 | (loaderparams.ram_low_size >> 16));
stl_p(p++, 0x34e70000 | (loaderparams.ram_low_size & 0xffff));
stl_p(p++, 0x3c09b400);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08df00);
#else
stl_p(p++, 0x340800df);
#endif
stl_p(p++, 0xad280068);
stl_p(p++, 0x3c09bbe0);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08c000);
#else
stl_p(p++, 0x340800c0);
#endif
stl_p(p++, 0xad280048);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c084000);
#else
stl_p(p++, 0x34080040);
#endif
stl_p(p++, 0xad280050);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c088000);
#else
stl_p(p++, 0x34080080);
#endif
stl_p(p++, 0xad280058);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c083f00);
#else
stl_p(p++, 0x3408003f);
#endif
stl_p(p++, 0xad280060);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c08c100);
#else
stl_p(p++, 0x340800c1);
#endif
stl_p(p++, 0xad280080);
#ifdef TARGET_WORDS_BIGENDIAN
stl_p(p++, 0x3c085e00);
#else
stl_p(p++, 0x3408005e);
#endif
stl_p(p++, 0xad280088);
stl_p(p++, 0x3c1f0000 | ((VAR_2 >> 16) & 0xffff));
stl_p(p++, 0x37ff0000 | (VAR_2 & 0xffff));
stl_p(p++, 0x03e00009);
stl_p(p++, 0x00000000);
p = (uint32_t *) (VAR_0 + 0x800);
stl_p(p++, 0x03e00009);
stl_p(p++, 0x24020000);
stl_p(p++, 0x03e06821);
stl_p(p++, 0x00805821);
stl_p(p++, 0x00a05021);
stl_p(p++, 0x91440000);
stl_p(p++, 0x254a0001);
stl_p(p++, 0x10800005);
stl_p(p++, 0x00000000);
stl_p(p++, 0x0ff0021c);
stl_p(p++, 0x00000000);
stl_p(p++, 0x08000205);
stl_p(p++, 0x00000000);
stl_p(p++, 0x01a00009);
stl_p(p++, 0x01602021);
stl_p(p++, 0x03e06821);
stl_p(p++, 0x00805821);
stl_p(p++, 0x00a05021);
stl_p(p++, 0x00c06021);
stl_p(p++, 0x91440000);
stl_p(p++, 0x0ff0021c);
stl_p(p++, 0x00000000);
stl_p(p++, 0x254a0001);
stl_p(p++, 0x258cffff);
stl_p(p++, 0x1580fffa);
stl_p(p++, 0x00000000);
stl_p(p++, 0x01a00009);
stl_p(p++, 0x01602021);
stl_p(p++, 0x3c08b800);
stl_p(p++, 0x350803f8);
stl_p(p++, 0x91090005);
stl_p(p++, 0x00000000);
stl_p(p++, 0x31290040);
stl_p(p++, 0x1120fffc);
stl_p(p++, 0x00000000);
stl_p(p++, 0x03e00009);
stl_p(p++, 0xa1040000);
}
| [
"static void FUNC_0(uint8_t *VAR_0, int64_t VAR_1,\nint64_t VAR_2)\n{",
"uint32_t *p;",
"p = (uint32_t *)VAR_0;",
"stl_p(p++, 0x08000000 |\n((VAR_1 + 0x580) & 0x0fffffff) >> 2);",
"stl_p(p++, 0x00000000);",
"stl_p(VAR_0 + 0x500, VAR_1 + 0x0580);",
"stl_p(VAR_0 + 0x504, VAR_1 + 0x083c);",
"stl_p(VAR_0 + 0x520, VAR_1 + 0x0580);",
"stl_p(VAR_0 + 0x52c, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x534, VAR_1 + 0x0808);",
"stl_p(VAR_0 + 0x538, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x53c, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x540, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x544, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x548, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x54c, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x550, VAR_1 + 0x0800);",
"stl_p(VAR_0 + 0x554, VAR_1 + 0x0800);",
"p = (uint32_t *) (VAR_0 + 0x580);",
"if (semihosting_get_argc()) {",
"stl_p(p++, 0x00000000);",
"} else {",
"stl_p(p++, 0x24040002);",
"}",
"stl_p(p++, 0x3c1d0000 | (((ENVP_ADDR - 64) >> 16) & 0xffff));",
"stl_p(p++, 0x37bd0000 | ((ENVP_ADDR - 64) & 0xffff));",
"stl_p(p++, 0x3c050000 | ((ENVP_ADDR >> 16) & 0xffff));",
"stl_p(p++, 0x34a50000 | (ENVP_ADDR & 0xffff));",
"stl_p(p++, 0x3c060000 | (((ENVP_ADDR + 8) >> 16) & 0xffff));",
"stl_p(p++, 0x34c60000 | ((ENVP_ADDR + 8) & 0xffff));",
"stl_p(p++, 0x3c070000 | (loaderparams.ram_low_size >> 16));",
"stl_p(p++, 0x34e70000 | (loaderparams.ram_low_size & 0xffff));",
"stl_p(p++, 0x3c09b400);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c08df00);",
"#else\nstl_p(p++, 0x340800df);",
"#endif\nstl_p(p++, 0xad280068);",
"stl_p(p++, 0x3c09bbe0);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c08c000);",
"#else\nstl_p(p++, 0x340800c0);",
"#endif\nstl_p(p++, 0xad280048);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c084000);",
"#else\nstl_p(p++, 0x34080040);",
"#endif\nstl_p(p++, 0xad280050);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c088000);",
"#else\nstl_p(p++, 0x34080080);",
"#endif\nstl_p(p++, 0xad280058);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c083f00);",
"#else\nstl_p(p++, 0x3408003f);",
"#endif\nstl_p(p++, 0xad280060);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c08c100);",
"#else\nstl_p(p++, 0x340800c1);",
"#endif\nstl_p(p++, 0xad280080);",
"#ifdef TARGET_WORDS_BIGENDIAN\nstl_p(p++, 0x3c085e00);",
"#else\nstl_p(p++, 0x3408005e);",
"#endif\nstl_p(p++, 0xad280088);",
"stl_p(p++, 0x3c1f0000 | ((VAR_2 >> 16) & 0xffff));",
"stl_p(p++, 0x37ff0000 | (VAR_2 & 0xffff));",
"stl_p(p++, 0x03e00009);",
"stl_p(p++, 0x00000000);",
"p = (uint32_t *) (VAR_0 + 0x800);",
"stl_p(p++, 0x03e00009);",
"stl_p(p++, 0x24020000);",
"stl_p(p++, 0x03e06821);",
"stl_p(p++, 0x00805821);",
"stl_p(p++, 0x00a05021);",
"stl_p(p++, 0x91440000);",
"stl_p(p++, 0x254a0001);",
"stl_p(p++, 0x10800005);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x0ff0021c);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x08000205);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x01a00009);",
"stl_p(p++, 0x01602021);",
"stl_p(p++, 0x03e06821);",
"stl_p(p++, 0x00805821);",
"stl_p(p++, 0x00a05021);",
"stl_p(p++, 0x00c06021);",
"stl_p(p++, 0x91440000);",
"stl_p(p++, 0x0ff0021c);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x254a0001);",
"stl_p(p++, 0x258cffff);",
"stl_p(p++, 0x1580fffa);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x01a00009);",
"stl_p(p++, 0x01602021);",
"stl_p(p++, 0x3c08b800);",
"stl_p(p++, 0x350803f8);",
"stl_p(p++, 0x91090005);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x31290040);",
"stl_p(p++, 0x1120fffc);",
"stl_p(p++, 0x00000000);",
"stl_p(p++, 0x03e00009);",
"stl_p(p++, 0xa1040000);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
13
],
[
17,
19
],
[
21
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
59
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
95
],
[
99,
101
],
[
103,
105
],
[
107,
109
],
[
113
],
[
117,
119
],
[
121,
123
],
[
125,
127
],
[
129,
131
],
[
133,
135
],
[
137,
139
],
[
143,
145
],
[
147,
149
],
[
151,
153
],
[
155,
157
],
[
159,
161
],
[
163,
165
],
[
169,
171
],
[
173,
175
],
[
177,
179
],
[
181,
183
],
[
185,
187
],
[
189,
191
],
[
197
],
[
199
],
[
201
],
[
203
],
[
209
],
[
211
],
[
213
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
293
]
]
|
12,826 | static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)
{
TCPCharDriver *s = chr->opaque;
/* clear old pending fd array */
g_free(s->write_msgfds);
if (num) {
s->write_msgfds = g_malloc(num * sizeof(int));
memcpy(s->write_msgfds, fds, num * sizeof(int));
}
s->write_msgfds_num = num;
return 0;
}
| true | qemu | 2d528d45ecf5ee3c1a566a9f3d664464925ef830 | static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)
{
TCPCharDriver *s = chr->opaque;
g_free(s->write_msgfds);
if (num) {
s->write_msgfds = g_malloc(num * sizeof(int));
memcpy(s->write_msgfds, fds, num * sizeof(int));
}
s->write_msgfds_num = num;
return 0;
}
| {
"code": [
" s->write_msgfds = g_malloc(num * sizeof(int));"
],
"line_no": [
17
]
} | static int FUNC_0(CharDriverState *VAR_0, int *VAR_1, int VAR_2)
{
TCPCharDriver *s = VAR_0->opaque;
g_free(s->write_msgfds);
if (VAR_2) {
s->write_msgfds = g_malloc(VAR_2 * sizeof(int));
memcpy(s->write_msgfds, VAR_1, VAR_2 * sizeof(int));
}
s->write_msgfds_num = VAR_2;
return 0;
}
| [
"static int FUNC_0(CharDriverState *VAR_0, int *VAR_1, int VAR_2)\n{",
"TCPCharDriver *s = VAR_0->opaque;",
"g_free(s->write_msgfds);",
"if (VAR_2) {",
"s->write_msgfds = g_malloc(VAR_2 * sizeof(int));",
"memcpy(s->write_msgfds, VAR_1, VAR_2 * sizeof(int));",
"}",
"s->write_msgfds_num = VAR_2;",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
31
]
]
|
12,827 | void ff_j2k_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
{
int reslevelno, bandno, precno;
for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
for (bandno = 0; bandno < reslevel->nbands; bandno++) {
Jpeg2000Band *band = reslevel->band + bandno;
for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++) {
Jpeg2000Prec *prec = band->prec + precno;
av_freep(&prec->zerobits);
av_freep(&prec->cblkincl);
av_freep(&prec->cblk);
}
av_freep(&band->prec);
}
av_freep(&reslevel->band);
}
ff_dwt_destroy(&comp->dwt);
av_freep(&comp->reslevel);
av_freep(&comp->data);
}
| true | FFmpeg | 8bedbb82cee4463a43e60eb22674c8bf927280ef | void ff_j2k_cleanup(Jpeg2000Component *comp, Jpeg2000CodingStyle *codsty)
{
int reslevelno, bandno, precno;
for (reslevelno = 0; reslevelno < codsty->nreslevels; reslevelno++) {
Jpeg2000ResLevel *reslevel = comp->reslevel + reslevelno;
for (bandno = 0; bandno < reslevel->nbands; bandno++) {
Jpeg2000Band *band = reslevel->band + bandno;
for (precno = 0; precno < reslevel->num_precincts_x * reslevel->num_precincts_y; precno++) {
Jpeg2000Prec *prec = band->prec + precno;
av_freep(&prec->zerobits);
av_freep(&prec->cblkincl);
av_freep(&prec->cblk);
}
av_freep(&band->prec);
}
av_freep(&reslevel->band);
}
ff_dwt_destroy(&comp->dwt);
av_freep(&comp->reslevel);
av_freep(&comp->data);
}
| {
"code": [
" av_freep(&comp->data);",
" av_freep(&comp->data);"
],
"line_no": [
45,
45
]
} | void FUNC_0(Jpeg2000Component *VAR_0, Jpeg2000CodingStyle *VAR_1)
{
int VAR_2, VAR_3, VAR_4;
for (VAR_2 = 0; VAR_2 < VAR_1->nreslevels; VAR_2++) {
Jpeg2000ResLevel *reslevel = VAR_0->reslevel + VAR_2;
for (VAR_3 = 0; VAR_3 < reslevel->nbands; VAR_3++) {
Jpeg2000Band *band = reslevel->band + VAR_3;
for (VAR_4 = 0; VAR_4 < reslevel->num_precincts_x * reslevel->num_precincts_y; VAR_4++) {
Jpeg2000Prec *prec = band->prec + VAR_4;
av_freep(&prec->zerobits);
av_freep(&prec->cblkincl);
av_freep(&prec->cblk);
}
av_freep(&band->prec);
}
av_freep(&reslevel->band);
}
ff_dwt_destroy(&VAR_0->dwt);
av_freep(&VAR_0->reslevel);
av_freep(&VAR_0->data);
}
| [
"void FUNC_0(Jpeg2000Component *VAR_0, Jpeg2000CodingStyle *VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4;",
"for (VAR_2 = 0; VAR_2 < VAR_1->nreslevels; VAR_2++) {",
"Jpeg2000ResLevel *reslevel = VAR_0->reslevel + VAR_2;",
"for (VAR_3 = 0; VAR_3 < reslevel->nbands; VAR_3++) {",
"Jpeg2000Band *band = reslevel->band + VAR_3;",
"for (VAR_4 = 0; VAR_4 < reslevel->num_precincts_x * reslevel->num_precincts_y; VAR_4++) {",
"Jpeg2000Prec *prec = band->prec + VAR_4;",
"av_freep(&prec->zerobits);",
"av_freep(&prec->cblkincl);",
"av_freep(&prec->cblk);",
"}",
"av_freep(&band->prec);",
"}",
"av_freep(&reslevel->band);",
"}",
"ff_dwt_destroy(&VAR_0->dwt);",
"av_freep(&VAR_0->reslevel);",
"av_freep(&VAR_0->data);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
]
]
|
12,831 | static int get_physical_address(CPUState *env, target_phys_addr_t *physical,
int *prot, int *access_index,
target_ulong address, int rw, int mmu_idx)
{
int is_user = mmu_idx == MMU_USER_IDX;
if (rw == 2)
return get_physical_address_code(env, physical, prot, address,
is_user);
else
return get_physical_address_data(env, physical, prot, address, rw,
is_user);
}
| false | qemu | d4c430a80f000d722bb70287af4d4c184a8d7006 | static int get_physical_address(CPUState *env, target_phys_addr_t *physical,
int *prot, int *access_index,
target_ulong address, int rw, int mmu_idx)
{
int is_user = mmu_idx == MMU_USER_IDX;
if (rw == 2)
return get_physical_address_code(env, physical, prot, address,
is_user);
else
return get_physical_address_data(env, physical, prot, address, rw,
is_user);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(CPUState *VAR_0, target_phys_addr_t *VAR_1,
int *VAR_2, int *VAR_3,
target_ulong VAR_4, int VAR_5, int VAR_6)
{
int VAR_7 = VAR_6 == MMU_USER_IDX;
if (VAR_5 == 2)
return get_physical_address_code(VAR_0, VAR_1, VAR_2, VAR_4,
VAR_7);
else
return get_physical_address_data(VAR_0, VAR_1, VAR_2, VAR_4, VAR_5,
VAR_7);
}
| [
"static int FUNC_0(CPUState *VAR_0, target_phys_addr_t *VAR_1,\nint *VAR_2, int *VAR_3,\ntarget_ulong VAR_4, int VAR_5, int VAR_6)\n{",
"int VAR_7 = VAR_6 == MMU_USER_IDX;",
"if (VAR_5 == 2)\nreturn get_physical_address_code(VAR_0, VAR_1, VAR_2, VAR_4,\nVAR_7);",
"else\nreturn get_physical_address_data(VAR_0, VAR_1, VAR_2, VAR_4, VAR_5,\nVAR_7);",
"}"
]
| [
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
13,
15,
17
],
[
19,
21,
23
],
[
25
]
]
|
12,832 | void op_flush_icache_all(void) {
CALL_FROM_TB1(tb_flush, env);
RETURN();
}
| false | qemu | df1561e22df42643d769aacdcc7d6d239f243366 | void op_flush_icache_all(void) {
CALL_FROM_TB1(tb_flush, env);
RETURN();
}
| {
"code": [],
"line_no": []
} | void FUNC_0(void) {
CALL_FROM_TB1(tb_flush, env);
RETURN();
}
| [
"void FUNC_0(void) {",
"CALL_FROM_TB1(tb_flush, env);",
"RETURN();",
"}"
]
| [
0,
0,
0,
0
]
| [
[
1
],
[
3
],
[
5
],
[
7
]
]
|
12,833 | static void test_visitor_in_struct_nested(TestInputVisitorData *data,
const void *unused)
{
UserDefTwo *udp = NULL;
Visitor *v;
v = visitor_input_test_init(data, "{ 'string0': 'string0', "
"'dict1': { 'string1': 'string1', "
"'dict2': { 'userdef': { 'integer': 42, "
"'string': 'string' }, 'string': 'string2'}}}");
visit_type_UserDefTwo(v, NULL, &udp, &error_abort);
g_assert_cmpstr(udp->string0, ==, "string0");
g_assert_cmpstr(udp->dict1->string1, ==, "string1");
g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
g_assert(udp->dict1->has_dict3 == false);
qapi_free_UserDefTwo(udp);
}
| false | qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | static void test_visitor_in_struct_nested(TestInputVisitorData *data,
const void *unused)
{
UserDefTwo *udp = NULL;
Visitor *v;
v = visitor_input_test_init(data, "{ 'string0': 'string0', "
"'dict1': { 'string1': 'string1', "
"'dict2': { 'userdef': { 'integer': 42, "
"'string': 'string' }, 'string': 'string2'}}}");
visit_type_UserDefTwo(v, NULL, &udp, &error_abort);
g_assert_cmpstr(udp->string0, ==, "string0");
g_assert_cmpstr(udp->dict1->string1, ==, "string1");
g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
g_assert(udp->dict1->has_dict3 == false);
qapi_free_UserDefTwo(udp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(TestInputVisitorData *VAR_0,
const void *VAR_1)
{
UserDefTwo *udp = NULL;
Visitor *v;
v = visitor_input_test_init(VAR_0, "{ 'string0': 'string0', "
"'dict1': { 'string1': 'string1', "
"'dict2': { 'userdef': { 'integer': 42, "
"'string': 'string' }, 'string': 'string2'}}}");
visit_type_UserDefTwo(v, NULL, &udp, &error_abort);
g_assert_cmpstr(udp->string0, ==, "string0");
g_assert_cmpstr(udp->dict1->string1, ==, "string1");
g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
g_assert(udp->dict1->has_dict3 == false);
qapi_free_UserDefTwo(udp);
}
| [
"static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"UserDefTwo *udp = NULL;",
"Visitor *v;",
"v = visitor_input_test_init(VAR_0, \"{ 'string0': 'string0', \"",
"\"'dict1': { 'string1': 'string1', \"",
"\"'dict2': { 'userdef': { 'integer': 42, \"",
"\"'string': 'string' }, 'string': 'string2'}}}\");",
"visit_type_UserDefTwo(v, NULL, &udp, &error_abort);",
"g_assert_cmpstr(udp->string0, ==, \"string0\");",
"g_assert_cmpstr(udp->dict1->string1, ==, \"string1\");",
"g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);",
"g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, \"string\");",
"g_assert_cmpstr(udp->dict1->dict2->string, ==, \"string2\");",
"g_assert(udp->dict1->has_dict3 == false);",
"qapi_free_UserDefTwo(udp);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
]
]
|
12,834 | static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw,
int group_id)
{
fprintf(stderr, ": type %s effect %s",
qxl_name(qxl_draw_type, draw->type),
qxl_name(qxl_draw_effect, draw->effect));
if (draw->bitmap_offset) {
fprintf(stderr, ": bitmap %d",
draw->bitmap_offset);
qxl_log_rect(&draw->bitmap_area);
}
switch (draw->type) {
case QXL_DRAW_COPY:
qxl_log_cmd_draw_copy(qxl, &draw->u.copy, group_id);
break;
}
}
| false | qemu | fae2afb10e3fdceab612c62a2b1e8b944ff578d9 | static void qxl_log_cmd_draw_compat(PCIQXLDevice *qxl, QXLCompatDrawable *draw,
int group_id)
{
fprintf(stderr, ": type %s effect %s",
qxl_name(qxl_draw_type, draw->type),
qxl_name(qxl_draw_effect, draw->effect));
if (draw->bitmap_offset) {
fprintf(stderr, ": bitmap %d",
draw->bitmap_offset);
qxl_log_rect(&draw->bitmap_area);
}
switch (draw->type) {
case QXL_DRAW_COPY:
qxl_log_cmd_draw_copy(qxl, &draw->u.copy, group_id);
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PCIQXLDevice *VAR_0, QXLCompatDrawable *VAR_1,
int VAR_2)
{
fprintf(stderr, ": type %s effect %s",
qxl_name(qxl_draw_type, VAR_1->type),
qxl_name(qxl_draw_effect, VAR_1->effect));
if (VAR_1->bitmap_offset) {
fprintf(stderr, ": bitmap %d",
VAR_1->bitmap_offset);
qxl_log_rect(&VAR_1->bitmap_area);
}
switch (VAR_1->type) {
case QXL_DRAW_COPY:
qxl_log_cmd_draw_copy(VAR_0, &VAR_1->u.copy, VAR_2);
break;
}
}
| [
"static void FUNC_0(PCIQXLDevice *VAR_0, QXLCompatDrawable *VAR_1,\nint VAR_2)\n{",
"fprintf(stderr, \": type %s effect %s\",\nqxl_name(qxl_draw_type, VAR_1->type),\nqxl_name(qxl_draw_effect, VAR_1->effect));",
"if (VAR_1->bitmap_offset) {",
"fprintf(stderr, \": bitmap %d\",\nVAR_1->bitmap_offset);",
"qxl_log_rect(&VAR_1->bitmap_area);",
"}",
"switch (VAR_1->type) {",
"case QXL_DRAW_COPY:\nqxl_log_cmd_draw_copy(VAR_0, &VAR_1->u.copy, VAR_2);",
"break;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7,
9,
11
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33
]
]
|
12,835 | int apic_init(CPUState *env)
{
APICState *s;
if (last_apic_idx >= MAX_APICS)
return -1;
s = qemu_mallocz(sizeof(APICState));
env->apic_state = s;
s->idx = last_apic_idx++;
s->id = env->cpuid_apic_id;
s->cpu_env = env;
apic_reset(s);
msix_supported = 1;
/* XXX: mapping more APICs at the same memory location */
if (apic_io_memory == 0) {
/* NOTE: the APIC is directly connected to the CPU - it is not
on the global memory bus. */
apic_io_memory = cpu_register_io_memory(apic_mem_read,
apic_mem_write, NULL);
/* XXX: what if the base changes? */
cpu_register_physical_memory(MSI_ADDR_BASE, MSI_ADDR_SIZE,
apic_io_memory);
}
s->timer = qemu_new_timer(vm_clock, apic_timer, s);
vmstate_register(s->idx, &vmstate_apic, s);
qemu_register_reset(apic_reset, s);
local_apics[s->idx] = s;
return 0;
}
| false | qemu | c169998802505c244b8bcad562633f29de7d74a4 | int apic_init(CPUState *env)
{
APICState *s;
if (last_apic_idx >= MAX_APICS)
return -1;
s = qemu_mallocz(sizeof(APICState));
env->apic_state = s;
s->idx = last_apic_idx++;
s->id = env->cpuid_apic_id;
s->cpu_env = env;
apic_reset(s);
msix_supported = 1;
if (apic_io_memory == 0) {
apic_io_memory = cpu_register_io_memory(apic_mem_read,
apic_mem_write, NULL);
cpu_register_physical_memory(MSI_ADDR_BASE, MSI_ADDR_SIZE,
apic_io_memory);
}
s->timer = qemu_new_timer(vm_clock, apic_timer, s);
vmstate_register(s->idx, &vmstate_apic, s);
qemu_register_reset(apic_reset, s);
local_apics[s->idx] = s;
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(CPUState *VAR_0)
{
APICState *s;
if (last_apic_idx >= MAX_APICS)
return -1;
s = qemu_mallocz(sizeof(APICState));
VAR_0->apic_state = s;
s->idx = last_apic_idx++;
s->id = VAR_0->cpuid_apic_id;
s->cpu_env = VAR_0;
apic_reset(s);
msix_supported = 1;
if (apic_io_memory == 0) {
apic_io_memory = cpu_register_io_memory(apic_mem_read,
apic_mem_write, NULL);
cpu_register_physical_memory(MSI_ADDR_BASE, MSI_ADDR_SIZE,
apic_io_memory);
}
s->timer = qemu_new_timer(vm_clock, apic_timer, s);
vmstate_register(s->idx, &vmstate_apic, s);
qemu_register_reset(apic_reset, s);
local_apics[s->idx] = s;
return 0;
}
| [
"int FUNC_0(CPUState *VAR_0)\n{",
"APICState *s;",
"if (last_apic_idx >= MAX_APICS)\nreturn -1;",
"s = qemu_mallocz(sizeof(APICState));",
"VAR_0->apic_state = s;",
"s->idx = last_apic_idx++;",
"s->id = VAR_0->cpuid_apic_id;",
"s->cpu_env = VAR_0;",
"apic_reset(s);",
"msix_supported = 1;",
"if (apic_io_memory == 0) {",
"apic_io_memory = cpu_register_io_memory(apic_mem_read,\napic_mem_write, NULL);",
"cpu_register_physical_memory(MSI_ADDR_BASE, MSI_ADDR_SIZE,\napic_io_memory);",
"}",
"s->timer = qemu_new_timer(vm_clock, apic_timer, s);",
"vmstate_register(s->idx, &vmstate_apic, s);",
"qemu_register_reset(apic_reset, s);",
"local_apics[s->idx] = s;",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
33
],
[
39,
41
],
[
45,
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
]
]
|
12,836 | static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
const char *json_string,
va_list *ap)
{
visitor_input_teardown(data, NULL);
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
data->qiv = qmp_input_visitor_new(data->obj, false);
g_assert(data->qiv);
return data->qiv;
}
| false | qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
const char *json_string,
va_list *ap)
{
visitor_input_teardown(data, NULL);
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
data->qiv = qmp_input_visitor_new(data->obj, false);
g_assert(data->qiv);
return data->qiv;
}
| {
"code": [],
"line_no": []
} | static Visitor *FUNC_0(TestInputVisitorData *data,
const char *json_string,
va_list *ap)
{
visitor_input_teardown(data, NULL);
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
data->qiv = qmp_input_visitor_new(data->obj, false);
g_assert(data->qiv);
return data->qiv;
}
| [
"static Visitor *FUNC_0(TestInputVisitorData *data,\nconst char *json_string,\nva_list *ap)\n{",
"visitor_input_teardown(data, NULL);",
"data->obj = qobject_from_jsonv(json_string, ap);",
"g_assert(data->obj);",
"data->qiv = qmp_input_visitor_new(data->obj, false);",
"g_assert(data->qiv);",
"return data->qiv;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
]
]
|
12,837 | target_ulong helper_rdhwr_cc(CPUMIPSState *env)
{
if ((env->hflags & MIPS_HFLAG_CP0) ||
(env->CP0_HWREna & (1 << 2))) {
#ifdef CONFIG_USER_ONLY
return env->CP0_Count;
#else
return (int32_t)cpu_mips_get_count(env);
#endif
} else {
do_raise_exception(env, EXCP_RI, GETPC());
}
return 0;
}
| false | qemu | b00c72180c36510bf9b124e190bd520e3b7e1358 | target_ulong helper_rdhwr_cc(CPUMIPSState *env)
{
if ((env->hflags & MIPS_HFLAG_CP0) ||
(env->CP0_HWREna & (1 << 2))) {
#ifdef CONFIG_USER_ONLY
return env->CP0_Count;
#else
return (int32_t)cpu_mips_get_count(env);
#endif
} else {
do_raise_exception(env, EXCP_RI, GETPC());
}
return 0;
}
| {
"code": [],
"line_no": []
} | target_ulong FUNC_0(CPUMIPSState *env)
{
if ((env->hflags & MIPS_HFLAG_CP0) ||
(env->CP0_HWREna & (1 << 2))) {
#ifdef CONFIG_USER_ONLY
return env->CP0_Count;
#else
return (int32_t)cpu_mips_get_count(env);
#endif
} else {
do_raise_exception(env, EXCP_RI, GETPC());
}
return 0;
}
| [
"target_ulong FUNC_0(CPUMIPSState *env)\n{",
"if ((env->hflags & MIPS_HFLAG_CP0) ||\n(env->CP0_HWREna & (1 << 2))) {",
"#ifdef CONFIG_USER_ONLY\nreturn env->CP0_Count;",
"#else\nreturn (int32_t)cpu_mips_get_count(env);",
"#endif\n} else {",
"do_raise_exception(env, EXCP_RI, GETPC());",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5,
7
],
[
9,
11
],
[
13,
15
],
[
17,
19
],
[
21
],
[
23
],
[
27
],
[
29
]
]
|
12,838 | static void prstatfs_to_statfs(struct statfs *stfs, ProxyStatFS *prstfs)
{
memset(stfs, 0, sizeof(*stfs));
stfs->f_type = prstfs->f_type;
stfs->f_bsize = prstfs->f_bsize;
stfs->f_blocks = prstfs->f_blocks;
stfs->f_bfree = prstfs->f_bfree;
stfs->f_bavail = prstfs->f_bavail;
stfs->f_files = prstfs->f_files;
stfs->f_ffree = prstfs->f_ffree;
stfs->f_fsid.__val[0] = prstfs->f_fsid[0] & 0xFFFFFFFFU;
stfs->f_fsid.__val[1] = prstfs->f_fsid[1] >> 32 & 0xFFFFFFFFU;
stfs->f_namelen = prstfs->f_namelen;
stfs->f_frsize = prstfs->f_frsize;
}
| false | qemu | 494a8ebe713055d3946183f4b395f85a18b43e9e | static void prstatfs_to_statfs(struct statfs *stfs, ProxyStatFS *prstfs)
{
memset(stfs, 0, sizeof(*stfs));
stfs->f_type = prstfs->f_type;
stfs->f_bsize = prstfs->f_bsize;
stfs->f_blocks = prstfs->f_blocks;
stfs->f_bfree = prstfs->f_bfree;
stfs->f_bavail = prstfs->f_bavail;
stfs->f_files = prstfs->f_files;
stfs->f_ffree = prstfs->f_ffree;
stfs->f_fsid.__val[0] = prstfs->f_fsid[0] & 0xFFFFFFFFU;
stfs->f_fsid.__val[1] = prstfs->f_fsid[1] >> 32 & 0xFFFFFFFFU;
stfs->f_namelen = prstfs->f_namelen;
stfs->f_frsize = prstfs->f_frsize;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(struct statfs *VAR_0, ProxyStatFS *VAR_1)
{
memset(VAR_0, 0, sizeof(*VAR_0));
VAR_0->f_type = VAR_1->f_type;
VAR_0->f_bsize = VAR_1->f_bsize;
VAR_0->f_blocks = VAR_1->f_blocks;
VAR_0->f_bfree = VAR_1->f_bfree;
VAR_0->f_bavail = VAR_1->f_bavail;
VAR_0->f_files = VAR_1->f_files;
VAR_0->f_ffree = VAR_1->f_ffree;
VAR_0->f_fsid.__val[0] = VAR_1->f_fsid[0] & 0xFFFFFFFFU;
VAR_0->f_fsid.__val[1] = VAR_1->f_fsid[1] >> 32 & 0xFFFFFFFFU;
VAR_0->f_namelen = VAR_1->f_namelen;
VAR_0->f_frsize = VAR_1->f_frsize;
}
| [
"static void FUNC_0(struct statfs *VAR_0, ProxyStatFS *VAR_1)\n{",
"memset(VAR_0, 0, sizeof(*VAR_0));",
"VAR_0->f_type = VAR_1->f_type;",
"VAR_0->f_bsize = VAR_1->f_bsize;",
"VAR_0->f_blocks = VAR_1->f_blocks;",
"VAR_0->f_bfree = VAR_1->f_bfree;",
"VAR_0->f_bavail = VAR_1->f_bavail;",
"VAR_0->f_files = VAR_1->f_files;",
"VAR_0->f_ffree = VAR_1->f_ffree;",
"VAR_0->f_fsid.__val[0] = VAR_1->f_fsid[0] & 0xFFFFFFFFU;",
"VAR_0->f_fsid.__val[1] = VAR_1->f_fsid[1] >> 32 & 0xFFFFFFFFU;",
"VAR_0->f_namelen = VAR_1->f_namelen;",
"VAR_0->f_frsize = VAR_1->f_frsize;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
]
]
|
12,839 | static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
{
ProresContext *ctx = avctx->priv_data;
int i, hdr_size, slice_count;
unsigned pic_data_size;
int log2_slice_mb_width, log2_slice_mb_height;
int slice_mb_count, mb_x, mb_y;
const uint8_t *data_ptr, *index_ptr;
hdr_size = buf[0] >> 3;
if (hdr_size < 8 || hdr_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
return -1;
}
pic_data_size = AV_RB32(buf + 1);
if (pic_data_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
return -1;
}
log2_slice_mb_width = buf[7] >> 4;
log2_slice_mb_height = buf[7] & 0xF;
if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
return -1;
}
ctx->mb_width = (avctx->width + 15) >> 4;
ctx->mb_height = (avctx->height + 15) >> 4;
slice_count = AV_RB16(buf + 5);
if (ctx->slice_count != slice_count || !ctx->slices) {
av_freep(&ctx->slices);
ctx->slices = av_mallocz(slice_count * sizeof(*ctx->slices));
if (!ctx->slices)
return AVERROR(ENOMEM);
ctx->slice_count = slice_count;
}
if (!slice_count)
return AVERROR(EINVAL);
if (hdr_size + slice_count*2 > buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
return -1;
}
// parse slice information
index_ptr = buf + hdr_size;
data_ptr = index_ptr + slice_count*2;
slice_mb_count = 1 << log2_slice_mb_width;
mb_x = 0;
mb_y = 0;
for (i = 0; i < slice_count; i++) {
SliceContext *slice = &ctx->slices[i];
slice->data = data_ptr;
data_ptr += AV_RB16(index_ptr + i*2);
while (ctx->mb_width - mb_x < slice_mb_count)
slice_mb_count >>= 1;
slice->mb_x = mb_x;
slice->mb_y = mb_y;
slice->mb_count = slice_mb_count;
slice->data_size = data_ptr - slice->data;
if (slice->data_size < 6) {
av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
return -1;
}
mb_x += slice_mb_count;
if (mb_x == ctx->mb_width) {
slice_mb_count = 1 << log2_slice_mb_width;
mb_x = 0;
mb_y++;
}
if (data_ptr > buf + buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
return -1;
}
}
return pic_data_size;
}
| false | FFmpeg | 397d194e50e15bf20dc5950e2afe9f868c4ff2c9 | static int decode_picture_header(AVCodecContext *avctx, const uint8_t *buf, const int buf_size)
{
ProresContext *ctx = avctx->priv_data;
int i, hdr_size, slice_count;
unsigned pic_data_size;
int log2_slice_mb_width, log2_slice_mb_height;
int slice_mb_count, mb_x, mb_y;
const uint8_t *data_ptr, *index_ptr;
hdr_size = buf[0] >> 3;
if (hdr_size < 8 || hdr_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, wrong picture header size\n");
return -1;
}
pic_data_size = AV_RB32(buf + 1);
if (pic_data_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, wrong picture data size\n");
return -1;
}
log2_slice_mb_width = buf[7] >> 4;
log2_slice_mb_height = buf[7] & 0xF;
if (log2_slice_mb_width > 3 || log2_slice_mb_height) {
av_log(avctx, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
1 << log2_slice_mb_width, 1 << log2_slice_mb_height);
return -1;
}
ctx->mb_width = (avctx->width + 15) >> 4;
ctx->mb_height = (avctx->height + 15) >> 4;
slice_count = AV_RB16(buf + 5);
if (ctx->slice_count != slice_count || !ctx->slices) {
av_freep(&ctx->slices);
ctx->slices = av_mallocz(slice_count * sizeof(*ctx->slices));
if (!ctx->slices)
return AVERROR(ENOMEM);
ctx->slice_count = slice_count;
}
if (!slice_count)
return AVERROR(EINVAL);
if (hdr_size + slice_count*2 > buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, wrong slice count\n");
return -1;
}
index_ptr = buf + hdr_size;
data_ptr = index_ptr + slice_count*2;
slice_mb_count = 1 << log2_slice_mb_width;
mb_x = 0;
mb_y = 0;
for (i = 0; i < slice_count; i++) {
SliceContext *slice = &ctx->slices[i];
slice->data = data_ptr;
data_ptr += AV_RB16(index_ptr + i*2);
while (ctx->mb_width - mb_x < slice_mb_count)
slice_mb_count >>= 1;
slice->mb_x = mb_x;
slice->mb_y = mb_y;
slice->mb_count = slice_mb_count;
slice->data_size = data_ptr - slice->data;
if (slice->data_size < 6) {
av_log(avctx, AV_LOG_ERROR, "error, wrong slice data size\n");
return -1;
}
mb_x += slice_mb_count;
if (mb_x == ctx->mb_width) {
slice_mb_count = 1 << log2_slice_mb_width;
mb_x = 0;
mb_y++;
}
if (data_ptr > buf + buf_size) {
av_log(avctx, AV_LOG_ERROR, "error, slice out of bounds\n");
return -1;
}
}
return pic_data_size;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, const uint8_t *VAR_1, const int VAR_2)
{
ProresContext *ctx = VAR_0->priv_data;
int VAR_3, VAR_4, VAR_5;
unsigned VAR_6;
int VAR_7, VAR_8;
int VAR_9, VAR_10, VAR_11;
const uint8_t *VAR_12, *index_ptr;
VAR_4 = VAR_1[0] >> 3;
if (VAR_4 < 8 || VAR_4 > VAR_2) {
av_log(VAR_0, AV_LOG_ERROR, "error, wrong picture header size\n");
return -1;
}
VAR_6 = AV_RB32(VAR_1 + 1);
if (VAR_6 > VAR_2) {
av_log(VAR_0, AV_LOG_ERROR, "error, wrong picture data size\n");
return -1;
}
VAR_7 = VAR_1[7] >> 4;
VAR_8 = VAR_1[7] & 0xF;
if (VAR_7 > 3 || VAR_8) {
av_log(VAR_0, AV_LOG_ERROR, "unsupported slice resolution: %dx%d\n",
1 << VAR_7, 1 << VAR_8);
return -1;
}
ctx->mb_width = (VAR_0->width + 15) >> 4;
ctx->mb_height = (VAR_0->height + 15) >> 4;
VAR_5 = AV_RB16(VAR_1 + 5);
if (ctx->VAR_5 != VAR_5 || !ctx->slices) {
av_freep(&ctx->slices);
ctx->slices = av_mallocz(VAR_5 * sizeof(*ctx->slices));
if (!ctx->slices)
return AVERROR(ENOMEM);
ctx->VAR_5 = VAR_5;
}
if (!VAR_5)
return AVERROR(EINVAL);
if (VAR_4 + VAR_5*2 > VAR_2) {
av_log(VAR_0, AV_LOG_ERROR, "error, wrong slice count\n");
return -1;
}
index_ptr = VAR_1 + VAR_4;
VAR_12 = index_ptr + VAR_5*2;
VAR_9 = 1 << VAR_7;
VAR_10 = 0;
VAR_11 = 0;
for (VAR_3 = 0; VAR_3 < VAR_5; VAR_3++) {
SliceContext *slice = &ctx->slices[VAR_3];
slice->data = VAR_12;
VAR_12 += AV_RB16(index_ptr + VAR_3*2);
while (ctx->mb_width - VAR_10 < VAR_9)
VAR_9 >>= 1;
slice->VAR_10 = VAR_10;
slice->VAR_11 = VAR_11;
slice->mb_count = VAR_9;
slice->data_size = VAR_12 - slice->data;
if (slice->data_size < 6) {
av_log(VAR_0, AV_LOG_ERROR, "error, wrong slice data size\n");
return -1;
}
VAR_10 += VAR_9;
if (VAR_10 == ctx->mb_width) {
VAR_9 = 1 << VAR_7;
VAR_10 = 0;
VAR_11++;
}
if (VAR_12 > VAR_1 + VAR_2) {
av_log(VAR_0, AV_LOG_ERROR, "error, slice out of bounds\n");
return -1;
}
}
return VAR_6;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, const uint8_t *VAR_1, const int VAR_2)\n{",
"ProresContext *ctx = VAR_0->priv_data;",
"int VAR_3, VAR_4, VAR_5;",
"unsigned VAR_6;",
"int VAR_7, VAR_8;",
"int VAR_9, VAR_10, VAR_11;",
"const uint8_t *VAR_12, *index_ptr;",
"VAR_4 = VAR_1[0] >> 3;",
"if (VAR_4 < 8 || VAR_4 > VAR_2) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error, wrong picture header size\\n\");",
"return -1;",
"}",
"VAR_6 = AV_RB32(VAR_1 + 1);",
"if (VAR_6 > VAR_2) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error, wrong picture data size\\n\");",
"return -1;",
"}",
"VAR_7 = VAR_1[7] >> 4;",
"VAR_8 = VAR_1[7] & 0xF;",
"if (VAR_7 > 3 || VAR_8) {",
"av_log(VAR_0, AV_LOG_ERROR, \"unsupported slice resolution: %dx%d\\n\",\n1 << VAR_7, 1 << VAR_8);",
"return -1;",
"}",
"ctx->mb_width = (VAR_0->width + 15) >> 4;",
"ctx->mb_height = (VAR_0->height + 15) >> 4;",
"VAR_5 = AV_RB16(VAR_1 + 5);",
"if (ctx->VAR_5 != VAR_5 || !ctx->slices) {",
"av_freep(&ctx->slices);",
"ctx->slices = av_mallocz(VAR_5 * sizeof(*ctx->slices));",
"if (!ctx->slices)\nreturn AVERROR(ENOMEM);",
"ctx->VAR_5 = VAR_5;",
"}",
"if (!VAR_5)\nreturn AVERROR(EINVAL);",
"if (VAR_4 + VAR_5*2 > VAR_2) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error, wrong slice count\\n\");",
"return -1;",
"}",
"index_ptr = VAR_1 + VAR_4;",
"VAR_12 = index_ptr + VAR_5*2;",
"VAR_9 = 1 << VAR_7;",
"VAR_10 = 0;",
"VAR_11 = 0;",
"for (VAR_3 = 0; VAR_3 < VAR_5; VAR_3++) {",
"SliceContext *slice = &ctx->slices[VAR_3];",
"slice->data = VAR_12;",
"VAR_12 += AV_RB16(index_ptr + VAR_3*2);",
"while (ctx->mb_width - VAR_10 < VAR_9)\nVAR_9 >>= 1;",
"slice->VAR_10 = VAR_10;",
"slice->VAR_11 = VAR_11;",
"slice->mb_count = VAR_9;",
"slice->data_size = VAR_12 - slice->data;",
"if (slice->data_size < 6) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error, wrong slice data size\\n\");",
"return -1;",
"}",
"VAR_10 += VAR_9;",
"if (VAR_10 == ctx->mb_width) {",
"VAR_9 = 1 << VAR_7;",
"VAR_10 = 0;",
"VAR_11++;",
"}",
"if (VAR_12 > VAR_1 + VAR_2) {",
"av_log(VAR_0, AV_LOG_ERROR, \"error, slice out of bounds\\n\");",
"return -1;",
"}",
"}",
"return VAR_6;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49,
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
65
],
[
69
],
[
71
],
[
73
],
[
75,
77
],
[
79
],
[
81
],
[
85,
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
117
],
[
119
],
[
123
],
[
125
],
[
129,
131
],
[
135
],
[
137
],
[
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
179
],
[
181
]
]
|
12,840 | static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun,
uint8_t *buf, void *hba_private)
{
SCSIRequest *req;
req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, lun, hba_private);
return req;
}
| false | qemu | 9be385980d37e8f4fd33f605f5fb1c3d144170a8 | static SCSIRequest *scsi_new_request(SCSIDevice *d, uint32_t tag, uint32_t lun,
uint8_t *buf, void *hba_private)
{
SCSIRequest *req;
req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, lun, hba_private);
return req;
}
| {
"code": [],
"line_no": []
} | static SCSIRequest *FUNC_0(SCSIDevice *d, uint32_t tag, uint32_t lun,
uint8_t *buf, void *hba_private)
{
SCSIRequest *req;
req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, lun, hba_private);
return req;
}
| [
"static SCSIRequest *FUNC_0(SCSIDevice *d, uint32_t tag, uint32_t lun,\nuint8_t *buf, void *hba_private)\n{",
"SCSIRequest *req;",
"req = scsi_req_alloc(&scsi_generic_req_ops, d, tag, lun, hba_private);",
"return req;",
"}"
]
| [
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
]
]
|
12,841 | static int kvm_get_xcrs(CPUState *env)
{
#ifdef KVM_CAP_XCRS
int i, ret;
struct kvm_xcrs xcrs;
if (!kvm_has_xcrs())
return 0;
ret = kvm_vcpu_ioctl(env, KVM_GET_XCRS, &xcrs);
if (ret < 0)
return ret;
for (i = 0; i < xcrs.nr_xcrs; i++)
/* Only support xcr0 now */
if (xcrs.xcrs[0].xcr == 0) {
env->xcr0 = xcrs.xcrs[0].value;
break;
}
return 0;
#else
return 0;
#endif
}
| false | qemu | b9bec74bcb16519a876ec21cd5277c526a9b512d | static int kvm_get_xcrs(CPUState *env)
{
#ifdef KVM_CAP_XCRS
int i, ret;
struct kvm_xcrs xcrs;
if (!kvm_has_xcrs())
return 0;
ret = kvm_vcpu_ioctl(env, KVM_GET_XCRS, &xcrs);
if (ret < 0)
return ret;
for (i = 0; i < xcrs.nr_xcrs; i++)
if (xcrs.xcrs[0].xcr == 0) {
env->xcr0 = xcrs.xcrs[0].value;
break;
}
return 0;
#else
return 0;
#endif
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(CPUState *VAR_0)
{
#ifdef KVM_CAP_XCRS
int i, ret;
struct kvm_xcrs xcrs;
if (!kvm_has_xcrs())
return 0;
ret = kvm_vcpu_ioctl(VAR_0, KVM_GET_XCRS, &xcrs);
if (ret < 0)
return ret;
for (i = 0; i < xcrs.nr_xcrs; i++)
if (xcrs.xcrs[0].xcr == 0) {
VAR_0->xcr0 = xcrs.xcrs[0].value;
break;
}
return 0;
#else
return 0;
#endif
}
| [
"static int FUNC_0(CPUState *VAR_0)\n{",
"#ifdef KVM_CAP_XCRS\nint i, ret;",
"struct kvm_xcrs xcrs;",
"if (!kvm_has_xcrs())\nreturn 0;",
"ret = kvm_vcpu_ioctl(VAR_0, KVM_GET_XCRS, &xcrs);",
"if (ret < 0)\nreturn ret;",
"for (i = 0; i < xcrs.nr_xcrs; i++)",
"if (xcrs.xcrs[0].xcr == 0) {",
"VAR_0->xcr0 = xcrs.xcrs[0].value;",
"break;",
"}",
"return 0;",
"#else\nreturn 0;",
"#endif\n}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5,
7
],
[
9
],
[
13,
15
],
[
19
],
[
21,
23
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45,
47
]
]
|
12,842 | static int is_dup_page(uint8_t *page)
{
VECTYPE *p = (VECTYPE *)page;
VECTYPE val = SPLAT(page);
int i;
for (i = 0; i < TARGET_PAGE_SIZE / sizeof(VECTYPE); i++) {
if (!ALL_EQ(val, p[i])) {
return 0;
}
}
return 1;
}
| false | qemu | 3edcd7e6ebae3ef0ac178eed5f4225803159562d | static int is_dup_page(uint8_t *page)
{
VECTYPE *p = (VECTYPE *)page;
VECTYPE val = SPLAT(page);
int i;
for (i = 0; i < TARGET_PAGE_SIZE / sizeof(VECTYPE); i++) {
if (!ALL_EQ(val, p[i])) {
return 0;
}
}
return 1;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(uint8_t *VAR_0)
{
VECTYPE *p = (VECTYPE *)VAR_0;
VECTYPE val = SPLAT(VAR_0);
int VAR_1;
for (VAR_1 = 0; VAR_1 < TARGET_PAGE_SIZE / sizeof(VECTYPE); VAR_1++) {
if (!ALL_EQ(val, p[VAR_1])) {
return 0;
}
}
return 1;
}
| [
"static int FUNC_0(uint8_t *VAR_0)\n{",
"VECTYPE *p = (VECTYPE *)VAR_0;",
"VECTYPE val = SPLAT(VAR_0);",
"int VAR_1;",
"for (VAR_1 = 0; VAR_1 < TARGET_PAGE_SIZE / sizeof(VECTYPE); VAR_1++) {",
"if (!ALL_EQ(val, p[VAR_1])) {",
"return 0;",
"}",
"}",
"return 1;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
]
]
|
12,843 | static void spapr_phb_realize(DeviceState *dev, Error **errp)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
SysBusDevice *s = SYS_BUS_DEVICE(dev);
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s);
PCIHostState *phb = PCI_HOST_BRIDGE(s);
char *namebuf;
int i;
PCIBus *bus;
uint64_t msi_window_size = 4096;
sPAPRTCETable *tcet;
const unsigned windows_supported =
sphb->ddw_enabled ? SPAPR_PCI_DMA_MAX_WINDOWS : 1;
if (sphb->index != (uint32_t)-1) {
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
Error *local_err = NULL;
if ((sphb->buid != (uint64_t)-1) || (sphb->dma_liobn[0] != (uint32_t)-1)
|| (sphb->dma_liobn[1] != (uint32_t)-1 && windows_supported == 2)
|| (sphb->mem_win_addr != (hwaddr)-1)
|| (sphb->mem64_win_addr != (hwaddr)-1)
|| (sphb->io_win_addr != (hwaddr)-1)) {
error_setg(errp, "Either \"index\" or other parameters must"
" be specified for PAPR PHB, not both");
return;
}
smc->phb_placement(spapr, sphb->index,
&sphb->buid, &sphb->io_win_addr,
&sphb->mem_win_addr, &sphb->mem64_win_addr,
windows_supported, sphb->dma_liobn, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
}
if (sphb->buid == (uint64_t)-1) {
error_setg(errp, "BUID not specified for PHB");
return;
}
if ((sphb->dma_liobn[0] == (uint32_t)-1) ||
((sphb->dma_liobn[1] == (uint32_t)-1) && (windows_supported > 1))) {
error_setg(errp, "LIOBN(s) not specified for PHB");
return;
}
if (sphb->mem_win_addr == (hwaddr)-1) {
error_setg(errp, "Memory window address not specified for PHB");
return;
}
if (sphb->io_win_addr == (hwaddr)-1) {
error_setg(errp, "IO window address not specified for PHB");
return;
}
if (sphb->mem64_win_size != 0) {
if (sphb->mem64_win_addr == (hwaddr)-1) {
error_setg(errp,
"64-bit memory window address not specified for PHB");
return;
}
if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
error_setg(errp, "32-bit memory window of size 0x%"HWADDR_PRIx
" (max 2 GiB)", sphb->mem_win_size);
return;
}
if (sphb->mem64_win_pciaddr == (hwaddr)-1) {
/* 64-bit window defaults to identity mapping */
sphb->mem64_win_pciaddr = sphb->mem64_win_addr;
}
} else if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
/*
* For compatibility with old configuration, if no 64-bit MMIO
* window is specified, but the ordinary (32-bit) memory
* window is specified as > 2GiB, we treat it as a 2GiB 32-bit
* window, with a 64-bit MMIO window following on immediately
* afterwards
*/
sphb->mem64_win_size = sphb->mem_win_size - SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem64_win_addr = sphb->mem_win_addr + SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem64_win_pciaddr =
SPAPR_PCI_MEM_WIN_BUS_OFFSET + SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem_win_size = SPAPR_PCI_MEM32_WIN_SIZE;
}
if (spapr_pci_find_phb(spapr, sphb->buid)) {
error_setg(errp, "PCI host bridges must have unique BUIDs");
return;
}
if (sphb->numa_node != -1 &&
(sphb->numa_node >= MAX_NODES || !numa_info[sphb->numa_node].present)) {
error_setg(errp, "Invalid NUMA node ID for PCI host bridge");
return;
}
sphb->dtbusname = g_strdup_printf("pci@%" PRIx64, sphb->buid);
/* Initialize memory regions */
namebuf = g_strdup_printf("%s.mmio", sphb->dtbusname);
memory_region_init(&sphb->memspace, OBJECT(sphb), namebuf, UINT64_MAX);
g_free(namebuf);
namebuf = g_strdup_printf("%s.mmio32-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->mem32window, OBJECT(sphb),
namebuf, &sphb->memspace,
SPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);
g_free(namebuf);
memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,
&sphb->mem32window);
if (sphb->mem64_win_pciaddr != (hwaddr)-1) {
namebuf = g_strdup_printf("%s.mmio64-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->mem64window, OBJECT(sphb),
namebuf, &sphb->memspace,
sphb->mem64_win_pciaddr, sphb->mem64_win_size);
g_free(namebuf);
if (sphb->mem64_win_addr != (hwaddr)-1) {
memory_region_add_subregion(get_system_memory(),
sphb->mem64_win_addr,
&sphb->mem64window);
}
}
/* Initialize IO regions */
namebuf = g_strdup_printf("%s.io", sphb->dtbusname);
memory_region_init(&sphb->iospace, OBJECT(sphb),
namebuf, SPAPR_PCI_IO_WIN_SIZE);
g_free(namebuf);
namebuf = g_strdup_printf("%s.io-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), namebuf,
&sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);
g_free(namebuf);
memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,
&sphb->iowindow);
bus = pci_register_bus(dev, NULL,
pci_spapr_set_irq, pci_spapr_map_irq, sphb,
&sphb->memspace, &sphb->iospace,
PCI_DEVFN(0, 0), PCI_NUM_PINS, TYPE_PCI_BUS);
phb->bus = bus;
qbus_set_hotplug_handler(BUS(phb->bus), DEVICE(sphb), NULL);
/*
* Initialize PHB address space.
* By default there will be at least one subregion for default
* 32bit DMA window.
* Later the guest might want to create another DMA window
* which will become another memory subregion.
*/
namebuf = g_strdup_printf("%s.iommu-root", sphb->dtbusname);
memory_region_init(&sphb->iommu_root, OBJECT(sphb),
namebuf, UINT64_MAX);
g_free(namebuf);
address_space_init(&sphb->iommu_as, &sphb->iommu_root,
sphb->dtbusname);
/*
* As MSI/MSIX interrupts trigger by writing at MSI/MSIX vectors,
* we need to allocate some memory to catch those writes coming
* from msi_notify()/msix_notify().
* As MSIMessage:addr is going to be the same and MSIMessage:data
* is going to be a VIRQ number, 4 bytes of the MSI MR will only
* be used.
*
* For KVM we want to ensure that this memory is a full page so that
* our memory slot is of page size granularity.
*/
#ifdef CONFIG_KVM
if (kvm_enabled()) {
msi_window_size = getpagesize();
}
#endif
memory_region_init_io(&sphb->msiwindow, OBJECT(sphb), &spapr_msi_ops, spapr,
"msi", msi_window_size);
memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,
&sphb->msiwindow);
pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);
pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);
QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);
/* Initialize the LSI table */
for (i = 0; i < PCI_NUM_PINS; i++) {
uint32_t irq;
Error *local_err = NULL;
irq = spapr_ics_alloc_block(spapr->ics, 1, true, false, &local_err);
if (local_err) {
error_propagate(errp, local_err);
error_prepend(errp, "can't allocate LSIs: ");
return;
}
sphb->lsi_table[i].irq = irq;
}
/* allocate connectors for child PCI devices */
if (sphb->dr_enabled) {
for (i = 0; i < PCI_SLOT_MAX * 8; i++) {
spapr_dr_connector_new(OBJECT(phb), TYPE_SPAPR_DRC_PCI,
(sphb->index << 16) | i);
}
}
/* DMA setup */
if (((sphb->page_size_mask & qemu_getrampagesize()) == 0)
&& kvm_enabled()) {
error_report("System page size 0x%lx is not enabled in page_size_mask "
"(0x%"PRIx64"). Performance may be slow",
qemu_getrampagesize(), sphb->page_size_mask);
}
for (i = 0; i < windows_supported; ++i) {
tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[i]);
if (!tcet) {
error_setg(errp, "Creating window#%d failed for %s",
i, sphb->dtbusname);
return;
}
memory_region_add_subregion(&sphb->iommu_root, 0,
spapr_tce_get_iommu(tcet));
}
sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
}
| false | qemu | 30b3bc5aa9f4df68909b63c873a40469caf013dc | static void spapr_phb_realize(DeviceState *dev, Error **errp)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
SysBusDevice *s = SYS_BUS_DEVICE(dev);
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s);
PCIHostState *phb = PCI_HOST_BRIDGE(s);
char *namebuf;
int i;
PCIBus *bus;
uint64_t msi_window_size = 4096;
sPAPRTCETable *tcet;
const unsigned windows_supported =
sphb->ddw_enabled ? SPAPR_PCI_DMA_MAX_WINDOWS : 1;
if (sphb->index != (uint32_t)-1) {
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
Error *local_err = NULL;
if ((sphb->buid != (uint64_t)-1) || (sphb->dma_liobn[0] != (uint32_t)-1)
|| (sphb->dma_liobn[1] != (uint32_t)-1 && windows_supported == 2)
|| (sphb->mem_win_addr != (hwaddr)-1)
|| (sphb->mem64_win_addr != (hwaddr)-1)
|| (sphb->io_win_addr != (hwaddr)-1)) {
error_setg(errp, "Either \"index\" or other parameters must"
" be specified for PAPR PHB, not both");
return;
}
smc->phb_placement(spapr, sphb->index,
&sphb->buid, &sphb->io_win_addr,
&sphb->mem_win_addr, &sphb->mem64_win_addr,
windows_supported, sphb->dma_liobn, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
}
if (sphb->buid == (uint64_t)-1) {
error_setg(errp, "BUID not specified for PHB");
return;
}
if ((sphb->dma_liobn[0] == (uint32_t)-1) ||
((sphb->dma_liobn[1] == (uint32_t)-1) && (windows_supported > 1))) {
error_setg(errp, "LIOBN(s) not specified for PHB");
return;
}
if (sphb->mem_win_addr == (hwaddr)-1) {
error_setg(errp, "Memory window address not specified for PHB");
return;
}
if (sphb->io_win_addr == (hwaddr)-1) {
error_setg(errp, "IO window address not specified for PHB");
return;
}
if (sphb->mem64_win_size != 0) {
if (sphb->mem64_win_addr == (hwaddr)-1) {
error_setg(errp,
"64-bit memory window address not specified for PHB");
return;
}
if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
error_setg(errp, "32-bit memory window of size 0x%"HWADDR_PRIx
" (max 2 GiB)", sphb->mem_win_size);
return;
}
if (sphb->mem64_win_pciaddr == (hwaddr)-1) {
sphb->mem64_win_pciaddr = sphb->mem64_win_addr;
}
} else if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
sphb->mem64_win_size = sphb->mem_win_size - SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem64_win_addr = sphb->mem_win_addr + SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem64_win_pciaddr =
SPAPR_PCI_MEM_WIN_BUS_OFFSET + SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem_win_size = SPAPR_PCI_MEM32_WIN_SIZE;
}
if (spapr_pci_find_phb(spapr, sphb->buid)) {
error_setg(errp, "PCI host bridges must have unique BUIDs");
return;
}
if (sphb->numa_node != -1 &&
(sphb->numa_node >= MAX_NODES || !numa_info[sphb->numa_node].present)) {
error_setg(errp, "Invalid NUMA node ID for PCI host bridge");
return;
}
sphb->dtbusname = g_strdup_printf("pci@%" PRIx64, sphb->buid);
namebuf = g_strdup_printf("%s.mmio", sphb->dtbusname);
memory_region_init(&sphb->memspace, OBJECT(sphb), namebuf, UINT64_MAX);
g_free(namebuf);
namebuf = g_strdup_printf("%s.mmio32-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->mem32window, OBJECT(sphb),
namebuf, &sphb->memspace,
SPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);
g_free(namebuf);
memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,
&sphb->mem32window);
if (sphb->mem64_win_pciaddr != (hwaddr)-1) {
namebuf = g_strdup_printf("%s.mmio64-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->mem64window, OBJECT(sphb),
namebuf, &sphb->memspace,
sphb->mem64_win_pciaddr, sphb->mem64_win_size);
g_free(namebuf);
if (sphb->mem64_win_addr != (hwaddr)-1) {
memory_region_add_subregion(get_system_memory(),
sphb->mem64_win_addr,
&sphb->mem64window);
}
}
namebuf = g_strdup_printf("%s.io", sphb->dtbusname);
memory_region_init(&sphb->iospace, OBJECT(sphb),
namebuf, SPAPR_PCI_IO_WIN_SIZE);
g_free(namebuf);
namebuf = g_strdup_printf("%s.io-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), namebuf,
&sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);
g_free(namebuf);
memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,
&sphb->iowindow);
bus = pci_register_bus(dev, NULL,
pci_spapr_set_irq, pci_spapr_map_irq, sphb,
&sphb->memspace, &sphb->iospace,
PCI_DEVFN(0, 0), PCI_NUM_PINS, TYPE_PCI_BUS);
phb->bus = bus;
qbus_set_hotplug_handler(BUS(phb->bus), DEVICE(sphb), NULL);
namebuf = g_strdup_printf("%s.iommu-root", sphb->dtbusname);
memory_region_init(&sphb->iommu_root, OBJECT(sphb),
namebuf, UINT64_MAX);
g_free(namebuf);
address_space_init(&sphb->iommu_as, &sphb->iommu_root,
sphb->dtbusname);
#ifdef CONFIG_KVM
if (kvm_enabled()) {
msi_window_size = getpagesize();
}
#endif
memory_region_init_io(&sphb->msiwindow, OBJECT(sphb), &spapr_msi_ops, spapr,
"msi", msi_window_size);
memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,
&sphb->msiwindow);
pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);
pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);
QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);
for (i = 0; i < PCI_NUM_PINS; i++) {
uint32_t irq;
Error *local_err = NULL;
irq = spapr_ics_alloc_block(spapr->ics, 1, true, false, &local_err);
if (local_err) {
error_propagate(errp, local_err);
error_prepend(errp, "can't allocate LSIs: ");
return;
}
sphb->lsi_table[i].irq = irq;
}
if (sphb->dr_enabled) {
for (i = 0; i < PCI_SLOT_MAX * 8; i++) {
spapr_dr_connector_new(OBJECT(phb), TYPE_SPAPR_DRC_PCI,
(sphb->index << 16) | i);
}
}
if (((sphb->page_size_mask & qemu_getrampagesize()) == 0)
&& kvm_enabled()) {
error_report("System page size 0x%lx is not enabled in page_size_mask "
"(0x%"PRIx64"). Performance may be slow",
qemu_getrampagesize(), sphb->page_size_mask);
}
for (i = 0; i < windows_supported; ++i) {
tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[i]);
if (!tcet) {
error_setg(errp, "Creating window#%d failed for %s",
i, sphb->dtbusname);
return;
}
memory_region_add_subregion(&sphb->iommu_root, 0,
spapr_tce_get_iommu(tcet));
}
sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
SysBusDevice *s = SYS_BUS_DEVICE(VAR_0);
sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s);
PCIHostState *phb = PCI_HOST_BRIDGE(s);
char *VAR_2;
int VAR_3;
PCIBus *bus;
uint64_t msi_window_size = 4096;
sPAPRTCETable *tcet;
const unsigned VAR_4 =
sphb->ddw_enabled ? SPAPR_PCI_DMA_MAX_WINDOWS : 1;
if (sphb->index != (uint32_t)-1) {
sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
Error *local_err = NULL;
if ((sphb->buid != (uint64_t)-1) || (sphb->dma_liobn[0] != (uint32_t)-1)
|| (sphb->dma_liobn[1] != (uint32_t)-1 && VAR_4 == 2)
|| (sphb->mem_win_addr != (hwaddr)-1)
|| (sphb->mem64_win_addr != (hwaddr)-1)
|| (sphb->io_win_addr != (hwaddr)-1)) {
error_setg(VAR_1, "Either \"index\" or other parameters must"
" be specified for PAPR PHB, not both");
return;
}
smc->phb_placement(spapr, sphb->index,
&sphb->buid, &sphb->io_win_addr,
&sphb->mem_win_addr, &sphb->mem64_win_addr,
VAR_4, sphb->dma_liobn, &local_err);
if (local_err) {
error_propagate(VAR_1, local_err);
return;
}
}
if (sphb->buid == (uint64_t)-1) {
error_setg(VAR_1, "BUID not specified for PHB");
return;
}
if ((sphb->dma_liobn[0] == (uint32_t)-1) ||
((sphb->dma_liobn[1] == (uint32_t)-1) && (VAR_4 > 1))) {
error_setg(VAR_1, "LIOBN(s) not specified for PHB");
return;
}
if (sphb->mem_win_addr == (hwaddr)-1) {
error_setg(VAR_1, "Memory window address not specified for PHB");
return;
}
if (sphb->io_win_addr == (hwaddr)-1) {
error_setg(VAR_1, "IO window address not specified for PHB");
return;
}
if (sphb->mem64_win_size != 0) {
if (sphb->mem64_win_addr == (hwaddr)-1) {
error_setg(VAR_1,
"64-bit memory window address not specified for PHB");
return;
}
if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
error_setg(VAR_1, "32-bit memory window of size 0x%"HWADDR_PRIx
" (max 2 GiB)", sphb->mem_win_size);
return;
}
if (sphb->mem64_win_pciaddr == (hwaddr)-1) {
sphb->mem64_win_pciaddr = sphb->mem64_win_addr;
}
} else if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {
sphb->mem64_win_size = sphb->mem_win_size - SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem64_win_addr = sphb->mem_win_addr + SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem64_win_pciaddr =
SPAPR_PCI_MEM_WIN_BUS_OFFSET + SPAPR_PCI_MEM32_WIN_SIZE;
sphb->mem_win_size = SPAPR_PCI_MEM32_WIN_SIZE;
}
if (spapr_pci_find_phb(spapr, sphb->buid)) {
error_setg(VAR_1, "PCI host bridges must have unique BUIDs");
return;
}
if (sphb->numa_node != -1 &&
(sphb->numa_node >= MAX_NODES || !numa_info[sphb->numa_node].present)) {
error_setg(VAR_1, "Invalid NUMA node ID for PCI host bridge");
return;
}
sphb->dtbusname = g_strdup_printf("pci@%" PRIx64, sphb->buid);
VAR_2 = g_strdup_printf("%s.mmio", sphb->dtbusname);
memory_region_init(&sphb->memspace, OBJECT(sphb), VAR_2, UINT64_MAX);
g_free(VAR_2);
VAR_2 = g_strdup_printf("%s.mmio32-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->mem32window, OBJECT(sphb),
VAR_2, &sphb->memspace,
SPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);
g_free(VAR_2);
memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,
&sphb->mem32window);
if (sphb->mem64_win_pciaddr != (hwaddr)-1) {
VAR_2 = g_strdup_printf("%s.mmio64-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->mem64window, OBJECT(sphb),
VAR_2, &sphb->memspace,
sphb->mem64_win_pciaddr, sphb->mem64_win_size);
g_free(VAR_2);
if (sphb->mem64_win_addr != (hwaddr)-1) {
memory_region_add_subregion(get_system_memory(),
sphb->mem64_win_addr,
&sphb->mem64window);
}
}
VAR_2 = g_strdup_printf("%s.io", sphb->dtbusname);
memory_region_init(&sphb->iospace, OBJECT(sphb),
VAR_2, SPAPR_PCI_IO_WIN_SIZE);
g_free(VAR_2);
VAR_2 = g_strdup_printf("%s.io-alias", sphb->dtbusname);
memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), VAR_2,
&sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);
g_free(VAR_2);
memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,
&sphb->iowindow);
bus = pci_register_bus(VAR_0, NULL,
pci_spapr_set_irq, pci_spapr_map_irq, sphb,
&sphb->memspace, &sphb->iospace,
PCI_DEVFN(0, 0), PCI_NUM_PINS, TYPE_PCI_BUS);
phb->bus = bus;
qbus_set_hotplug_handler(BUS(phb->bus), DEVICE(sphb), NULL);
VAR_2 = g_strdup_printf("%s.iommu-root", sphb->dtbusname);
memory_region_init(&sphb->iommu_root, OBJECT(sphb),
VAR_2, UINT64_MAX);
g_free(VAR_2);
address_space_init(&sphb->iommu_as, &sphb->iommu_root,
sphb->dtbusname);
#ifdef CONFIG_KVM
if (kvm_enabled()) {
msi_window_size = getpagesize();
}
#endif
memory_region_init_io(&sphb->msiwindow, OBJECT(sphb), &spapr_msi_ops, spapr,
"msi", msi_window_size);
memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,
&sphb->msiwindow);
pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);
pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);
QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);
for (VAR_3 = 0; VAR_3 < PCI_NUM_PINS; VAR_3++) {
uint32_t irq;
Error *local_err = NULL;
irq = spapr_ics_alloc_block(spapr->ics, 1, true, false, &local_err);
if (local_err) {
error_propagate(VAR_1, local_err);
error_prepend(VAR_1, "can't allocate LSIs: ");
return;
}
sphb->lsi_table[VAR_3].irq = irq;
}
if (sphb->dr_enabled) {
for (VAR_3 = 0; VAR_3 < PCI_SLOT_MAX * 8; VAR_3++) {
spapr_dr_connector_new(OBJECT(phb), TYPE_SPAPR_DRC_PCI,
(sphb->index << 16) | VAR_3);
}
}
if (((sphb->page_size_mask & qemu_getrampagesize()) == 0)
&& kvm_enabled()) {
error_report("System page size 0x%lx is not enabled in page_size_mask "
"(0x%"PRIx64"). Performance may be slow",
qemu_getrampagesize(), sphb->page_size_mask);
}
for (VAR_3 = 0; VAR_3 < VAR_4; ++VAR_3) {
tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[VAR_3]);
if (!tcet) {
error_setg(VAR_1, "Creating window#%d failed for %s",
VAR_3, sphb->dtbusname);
return;
}
memory_region_add_subregion(&sphb->iommu_root, 0,
spapr_tce_get_iommu(tcet));
}
sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
}
| [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());",
"SysBusDevice *s = SYS_BUS_DEVICE(VAR_0);",
"sPAPRPHBState *sphb = SPAPR_PCI_HOST_BRIDGE(s);",
"PCIHostState *phb = PCI_HOST_BRIDGE(s);",
"char *VAR_2;",
"int VAR_3;",
"PCIBus *bus;",
"uint64_t msi_window_size = 4096;",
"sPAPRTCETable *tcet;",
"const unsigned VAR_4 =\nsphb->ddw_enabled ? SPAPR_PCI_DMA_MAX_WINDOWS : 1;",
"if (sphb->index != (uint32_t)-1) {",
"sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);",
"Error *local_err = NULL;",
"if ((sphb->buid != (uint64_t)-1) || (sphb->dma_liobn[0] != (uint32_t)-1)\n|| (sphb->dma_liobn[1] != (uint32_t)-1 && VAR_4 == 2)\n|| (sphb->mem_win_addr != (hwaddr)-1)\n|| (sphb->mem64_win_addr != (hwaddr)-1)\n|| (sphb->io_win_addr != (hwaddr)-1)) {",
"error_setg(VAR_1, \"Either \\\"index\\\" or other parameters must\"\n\" be specified for PAPR PHB, not both\");",
"return;",
"}",
"smc->phb_placement(spapr, sphb->index,\n&sphb->buid, &sphb->io_win_addr,\n&sphb->mem_win_addr, &sphb->mem64_win_addr,\nVAR_4, sphb->dma_liobn, &local_err);",
"if (local_err) {",
"error_propagate(VAR_1, local_err);",
"return;",
"}",
"}",
"if (sphb->buid == (uint64_t)-1) {",
"error_setg(VAR_1, \"BUID not specified for PHB\");",
"return;",
"}",
"if ((sphb->dma_liobn[0] == (uint32_t)-1) ||\n((sphb->dma_liobn[1] == (uint32_t)-1) && (VAR_4 > 1))) {",
"error_setg(VAR_1, \"LIOBN(s) not specified for PHB\");",
"return;",
"}",
"if (sphb->mem_win_addr == (hwaddr)-1) {",
"error_setg(VAR_1, \"Memory window address not specified for PHB\");",
"return;",
"}",
"if (sphb->io_win_addr == (hwaddr)-1) {",
"error_setg(VAR_1, \"IO window address not specified for PHB\");",
"return;",
"}",
"if (sphb->mem64_win_size != 0) {",
"if (sphb->mem64_win_addr == (hwaddr)-1) {",
"error_setg(VAR_1,\n\"64-bit memory window address not specified for PHB\");",
"return;",
"}",
"if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {",
"error_setg(VAR_1, \"32-bit memory window of size 0x%\"HWADDR_PRIx\n\" (max 2 GiB)\", sphb->mem_win_size);",
"return;",
"}",
"if (sphb->mem64_win_pciaddr == (hwaddr)-1) {",
"sphb->mem64_win_pciaddr = sphb->mem64_win_addr;",
"}",
"} else if (sphb->mem_win_size > SPAPR_PCI_MEM32_WIN_SIZE) {",
"sphb->mem64_win_size = sphb->mem_win_size - SPAPR_PCI_MEM32_WIN_SIZE;",
"sphb->mem64_win_addr = sphb->mem_win_addr + SPAPR_PCI_MEM32_WIN_SIZE;",
"sphb->mem64_win_pciaddr =\nSPAPR_PCI_MEM_WIN_BUS_OFFSET + SPAPR_PCI_MEM32_WIN_SIZE;",
"sphb->mem_win_size = SPAPR_PCI_MEM32_WIN_SIZE;",
"}",
"if (spapr_pci_find_phb(spapr, sphb->buid)) {",
"error_setg(VAR_1, \"PCI host bridges must have unique BUIDs\");",
"return;",
"}",
"if (sphb->numa_node != -1 &&\n(sphb->numa_node >= MAX_NODES || !numa_info[sphb->numa_node].present)) {",
"error_setg(VAR_1, \"Invalid NUMA node ID for PCI host bridge\");",
"return;",
"}",
"sphb->dtbusname = g_strdup_printf(\"pci@%\" PRIx64, sphb->buid);",
"VAR_2 = g_strdup_printf(\"%s.mmio\", sphb->dtbusname);",
"memory_region_init(&sphb->memspace, OBJECT(sphb), VAR_2, UINT64_MAX);",
"g_free(VAR_2);",
"VAR_2 = g_strdup_printf(\"%s.mmio32-alias\", sphb->dtbusname);",
"memory_region_init_alias(&sphb->mem32window, OBJECT(sphb),\nVAR_2, &sphb->memspace,\nSPAPR_PCI_MEM_WIN_BUS_OFFSET, sphb->mem_win_size);",
"g_free(VAR_2);",
"memory_region_add_subregion(get_system_memory(), sphb->mem_win_addr,\n&sphb->mem32window);",
"if (sphb->mem64_win_pciaddr != (hwaddr)-1) {",
"VAR_2 = g_strdup_printf(\"%s.mmio64-alias\", sphb->dtbusname);",
"memory_region_init_alias(&sphb->mem64window, OBJECT(sphb),\nVAR_2, &sphb->memspace,\nsphb->mem64_win_pciaddr, sphb->mem64_win_size);",
"g_free(VAR_2);",
"if (sphb->mem64_win_addr != (hwaddr)-1) {",
"memory_region_add_subregion(get_system_memory(),\nsphb->mem64_win_addr,\n&sphb->mem64window);",
"}",
"}",
"VAR_2 = g_strdup_printf(\"%s.io\", sphb->dtbusname);",
"memory_region_init(&sphb->iospace, OBJECT(sphb),\nVAR_2, SPAPR_PCI_IO_WIN_SIZE);",
"g_free(VAR_2);",
"VAR_2 = g_strdup_printf(\"%s.io-alias\", sphb->dtbusname);",
"memory_region_init_alias(&sphb->iowindow, OBJECT(sphb), VAR_2,\n&sphb->iospace, 0, SPAPR_PCI_IO_WIN_SIZE);",
"g_free(VAR_2);",
"memory_region_add_subregion(get_system_memory(), sphb->io_win_addr,\n&sphb->iowindow);",
"bus = pci_register_bus(VAR_0, NULL,\npci_spapr_set_irq, pci_spapr_map_irq, sphb,\n&sphb->memspace, &sphb->iospace,\nPCI_DEVFN(0, 0), PCI_NUM_PINS, TYPE_PCI_BUS);",
"phb->bus = bus;",
"qbus_set_hotplug_handler(BUS(phb->bus), DEVICE(sphb), NULL);",
"VAR_2 = g_strdup_printf(\"%s.iommu-root\", sphb->dtbusname);",
"memory_region_init(&sphb->iommu_root, OBJECT(sphb),\nVAR_2, UINT64_MAX);",
"g_free(VAR_2);",
"address_space_init(&sphb->iommu_as, &sphb->iommu_root,\nsphb->dtbusname);",
"#ifdef CONFIG_KVM\nif (kvm_enabled()) {",
"msi_window_size = getpagesize();",
"}",
"#endif\nmemory_region_init_io(&sphb->msiwindow, OBJECT(sphb), &spapr_msi_ops, spapr,\n\"msi\", msi_window_size);",
"memory_region_add_subregion(&sphb->iommu_root, SPAPR_PCI_MSI_WINDOW,\n&sphb->msiwindow);",
"pci_setup_iommu(bus, spapr_pci_dma_iommu, sphb);",
"pci_bus_set_route_irq_fn(bus, spapr_route_intx_pin_to_irq);",
"QLIST_INSERT_HEAD(&spapr->phbs, sphb, list);",
"for (VAR_3 = 0; VAR_3 < PCI_NUM_PINS; VAR_3++) {",
"uint32_t irq;",
"Error *local_err = NULL;",
"irq = spapr_ics_alloc_block(spapr->ics, 1, true, false, &local_err);",
"if (local_err) {",
"error_propagate(VAR_1, local_err);",
"error_prepend(VAR_1, \"can't allocate LSIs: \");",
"return;",
"}",
"sphb->lsi_table[VAR_3].irq = irq;",
"}",
"if (sphb->dr_enabled) {",
"for (VAR_3 = 0; VAR_3 < PCI_SLOT_MAX * 8; VAR_3++) {",
"spapr_dr_connector_new(OBJECT(phb), TYPE_SPAPR_DRC_PCI,\n(sphb->index << 16) | VAR_3);",
"}",
"}",
"if (((sphb->page_size_mask & qemu_getrampagesize()) == 0)\n&& kvm_enabled()) {",
"error_report(\"System page size 0x%lx is not enabled in page_size_mask \"\n\"(0x%\"PRIx64\"). Performance may be slow\",\nqemu_getrampagesize(), sphb->page_size_mask);",
"}",
"for (VAR_3 = 0; VAR_3 < VAR_4; ++VAR_3) {",
"tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[VAR_3]);",
"if (!tcet) {",
"error_setg(VAR_1, \"Creating window#%d failed for %s\",\nVAR_3, sphb->dtbusname);",
"return;",
"}",
"memory_region_add_subregion(&sphb->iommu_root, 0,\nspapr_tce_get_iommu(tcet));",
"}",
"sphb->msi = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
29
],
[
31
],
[
33
],
[
37,
39,
41,
43,
45
],
[
47,
49
],
[
51
],
[
53
],
[
57,
59,
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87,
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119
],
[
121
],
[
123,
125
],
[
127
],
[
129
],
[
133
],
[
135,
137
],
[
139
],
[
141
],
[
145
],
[
149
],
[
151
],
[
153
],
[
169
],
[
171
],
[
173,
175
],
[
177
],
[
179
],
[
183
],
[
185
],
[
187
],
[
189
],
[
193,
195
],
[
197
],
[
199
],
[
201
],
[
205
],
[
211
],
[
213
],
[
215
],
[
219
],
[
221,
223,
225
],
[
227
],
[
229,
231
],
[
235
],
[
237
],
[
239,
241,
243
],
[
245
],
[
249
],
[
251,
253,
255
],
[
257
],
[
259
],
[
265
],
[
267,
269
],
[
271
],
[
275
],
[
277,
279
],
[
281
],
[
283,
285
],
[
289,
291,
293,
295
],
[
297
],
[
299
],
[
317
],
[
319,
321
],
[
323
],
[
325,
327
],
[
353,
355
],
[
357
],
[
359
],
[
361,
365,
367
],
[
369,
371
],
[
375
],
[
379
],
[
383
],
[
389
],
[
391
],
[
393
],
[
397
],
[
399
],
[
401
],
[
403
],
[
405
],
[
407
],
[
411
],
[
413
],
[
419
],
[
421
],
[
423,
425
],
[
427
],
[
429
],
[
435,
437
],
[
439,
441,
443
],
[
445
],
[
449
],
[
451
],
[
453
],
[
455,
457
],
[
459
],
[
461
],
[
463,
465
],
[
467
],
[
471
],
[
473
]
]
|
12,844 | static inline int is_sector_in_chunk(BDRVDMGState* s,
uint32_t chunk_num,int sector_num)
{
if(chunk_num>=s->n_chunks || s->sectors[chunk_num]>sector_num ||
s->sectors[chunk_num]+s->sectorcounts[chunk_num]<=sector_num)
return 0;
else
return -1;
}
| false | qemu | 2c1885adcf0312da80c7317b09f9adad97fa0fc6 | static inline int is_sector_in_chunk(BDRVDMGState* s,
uint32_t chunk_num,int sector_num)
{
if(chunk_num>=s->n_chunks || s->sectors[chunk_num]>sector_num ||
s->sectors[chunk_num]+s->sectorcounts[chunk_num]<=sector_num)
return 0;
else
return -1;
}
| {
"code": [],
"line_no": []
} | static inline int FUNC_0(BDRVDMGState* VAR_0,
uint32_t VAR_1,int VAR_2)
{
if(VAR_1>=VAR_0->n_chunks || VAR_0->sectors[VAR_1]>VAR_2 ||
VAR_0->sectors[VAR_1]+VAR_0->sectorcounts[VAR_1]<=VAR_2)
return 0;
else
return -1;
}
| [
"static inline int FUNC_0(BDRVDMGState* VAR_0,\nuint32_t VAR_1,int VAR_2)\n{",
"if(VAR_1>=VAR_0->n_chunks || VAR_0->sectors[VAR_1]>VAR_2 ||\nVAR_0->sectors[VAR_1]+VAR_0->sectorcounts[VAR_1]<=VAR_2)\nreturn 0;",
"else\nreturn -1;",
"}"
]
| [
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7,
9,
11
],
[
13,
15
],
[
17
]
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.