hexsha
stringlengths 40
40
| repo
stringlengths 5
105
| path
stringlengths 3
173
| license
sequence | language
stringclasses 1
value | identifier
stringlengths 1
438
| return_type
stringlengths 1
106
⌀ | original_string
stringlengths 21
40.7k
| original_docstring
stringlengths 18
13.4k
| docstring
stringlengths 11
3.24k
| docstring_tokens
sequence | code
stringlengths 14
20.4k
| code_tokens
sequence | short_docstring
stringlengths 0
4.36k
| short_docstring_tokens
sequence | comment
sequence | parameters
list | docstring_params
dict |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
87b717d1066f2c36eaf7076a7058446d9bc34798 | atrens/DragonFlyBSD-src | sys/dev/sound/pci/emu10kx.c | [
"BSD-3-Clause"
] | C | emu_getcard | null | static unsigned int
emu_getcard(device_t dev)
{
uint16_t device;
uint16_t subdevice;
int n_cards;
unsigned int thiscard;
int i;
device = pci_read_config(dev, PCIR_DEVICE, /* bytes */ 2);
subdevice = pci_read_config(dev, PCIR_SUBDEV_0, /* bytes */ 2);
n_cards = NELEM(emu_cards);
thiscard = 0;
for (i = 1; i < n_cards; i++) {
if (device == emu_cards[i].device) {
if (subdevice == emu_cards[i].subdevice) {
thiscard = i;
break;
}
if (0x0000 == emu_cards[i].subdevice) {
thiscard = i;
/*
* don't break, we can get more specific card
* later in the list.
*/
}
}
}
n_cards = NELEM(emu_bad_cards);
for (i = 0; i < n_cards; i++) {
if (device == emu_bad_cards[i].device) {
if (subdevice == emu_bad_cards[i].subdevice) {
thiscard = 0;
break;
}
if (0x0000 == emu_bad_cards[i].subdevice) {
thiscard = 0;
break; /* we avoid all this cards */
}
}
}
return (thiscard);
} | /*
* Get best known information about device.
*/ | Get best known information about device. | [
"Get",
"best",
"known",
"information",
"about",
"device",
"."
] | static unsigned int
emu_getcard(device_t dev)
{
uint16_t device;
uint16_t subdevice;
int n_cards;
unsigned int thiscard;
int i;
device = pci_read_config(dev, PCIR_DEVICE, 2);
subdevice = pci_read_config(dev, PCIR_SUBDEV_0, 2);
n_cards = NELEM(emu_cards);
thiscard = 0;
for (i = 1; i < n_cards; i++) {
if (device == emu_cards[i].device) {
if (subdevice == emu_cards[i].subdevice) {
thiscard = i;
break;
}
if (0x0000 == emu_cards[i].subdevice) {
thiscard = i;
}
}
}
n_cards = NELEM(emu_bad_cards);
for (i = 0; i < n_cards; i++) {
if (device == emu_bad_cards[i].device) {
if (subdevice == emu_bad_cards[i].subdevice) {
thiscard = 0;
break;
}
if (0x0000 == emu_bad_cards[i].subdevice) {
thiscard = 0;
break;
}
}
}
return (thiscard);
} | [
"static",
"unsigned",
"int",
"emu_getcard",
"(",
"device_t",
"dev",
")",
"{",
"uint16_t",
"device",
";",
"uint16_t",
"subdevice",
";",
"int",
"n_cards",
";",
"unsigned",
"int",
"thiscard",
";",
"int",
"i",
";",
"device",
"=",
"pci_read_config",
"(",
"dev",
",",
"PCIR_DEVICE",
",",
"2",
")",
";",
"subdevice",
"=",
"pci_read_config",
"(",
"dev",
",",
"PCIR_SUBDEV_0",
",",
"2",
")",
";",
"n_cards",
"=",
"NELEM",
"(",
"emu_cards",
")",
";",
"thiscard",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"1",
";",
"i",
"<",
"n_cards",
";",
"i",
"++",
")",
"{",
"if",
"(",
"device",
"==",
"emu_cards",
"[",
"i",
"]",
".",
"device",
")",
"{",
"if",
"(",
"subdevice",
"==",
"emu_cards",
"[",
"i",
"]",
".",
"subdevice",
")",
"{",
"thiscard",
"=",
"i",
";",
"break",
";",
"}",
"if",
"(",
"0x0000",
"==",
"emu_cards",
"[",
"i",
"]",
".",
"subdevice",
")",
"{",
"thiscard",
"=",
"i",
";",
"}",
"}",
"}",
"n_cards",
"=",
"NELEM",
"(",
"emu_bad_cards",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"n_cards",
";",
"i",
"++",
")",
"{",
"if",
"(",
"device",
"==",
"emu_bad_cards",
"[",
"i",
"]",
".",
"device",
")",
"{",
"if",
"(",
"subdevice",
"==",
"emu_bad_cards",
"[",
"i",
"]",
".",
"subdevice",
")",
"{",
"thiscard",
"=",
"0",
";",
"break",
";",
"}",
"if",
"(",
"0x0000",
"==",
"emu_bad_cards",
"[",
"i",
"]",
".",
"subdevice",
")",
"{",
"thiscard",
"=",
"0",
";",
"break",
";",
"}",
"}",
"}",
"return",
"(",
"thiscard",
")",
";",
"}"
] | Get best known information about device. | [
"Get",
"best",
"known",
"information",
"about",
"device",
"."
] | [
"/* bytes */",
"/* bytes */",
"/*\n\t\t\t\t * don't break, we can get more specific card\n\t\t\t\t * later in the list.\n\t\t\t\t */",
"/* we avoid all this cards */"
] | [
{
"param": "dev",
"type": "device_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dev",
"type": "device_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
87b717d1066f2c36eaf7076a7058446d9bc34798 | atrens/DragonFlyBSD-src | sys/dev/sound/pci/emu10kx.c | [
"BSD-3-Clause"
] | C | emu_wr | void | void
emu_wr(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size)
{
KASSERT(regno != EMU_PTR, ("emu_wr: attempt to write to EMU_PTR"));
KASSERT(regno != EMU_A2_PTR, ("emu_wr: attempt to write to EMU_A2_PTR"));
emu_wr_nolock(sc, regno, data, size);
} | /*
* Direct hardware register access
* Assume that it is never used to access EMU_PTR-based registers and can run unlocked.
*/ | Direct hardware register access
Assume that it is never used to access EMU_PTR-based registers and can run unlocked. | [
"Direct",
"hardware",
"register",
"access",
"Assume",
"that",
"it",
"is",
"never",
"used",
"to",
"access",
"EMU_PTR",
"-",
"based",
"registers",
"and",
"can",
"run",
"unlocked",
"."
] | void
emu_wr(struct emu_sc_info *sc, unsigned int regno, uint32_t data, unsigned int size)
{
KASSERT(regno != EMU_PTR, ("emu_wr: attempt to write to EMU_PTR"));
KASSERT(regno != EMU_A2_PTR, ("emu_wr: attempt to write to EMU_A2_PTR"));
emu_wr_nolock(sc, regno, data, size);
} | [
"void",
"emu_wr",
"(",
"struct",
"emu_sc_info",
"*",
"sc",
",",
"unsigned",
"int",
"regno",
",",
"uint32_t",
"data",
",",
"unsigned",
"int",
"size",
")",
"{",
"KASSERT",
"(",
"regno",
"!=",
"EMU_PTR",
",",
"(",
"\"",
"\"",
")",
")",
";",
"KASSERT",
"(",
"regno",
"!=",
"EMU_A2_PTR",
",",
"(",
"\"",
"\"",
")",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"regno",
",",
"data",
",",
"size",
")",
";",
"}"
] | Direct hardware register access
Assume that it is never used to access EMU_PTR-based registers and can run unlocked. | [
"Direct",
"hardware",
"register",
"access",
"Assume",
"that",
"it",
"is",
"never",
"used",
"to",
"access",
"EMU_PTR",
"-",
"based",
"registers",
"and",
"can",
"run",
"unlocked",
"."
] | [] | [
{
"param": "sc",
"type": "struct emu_sc_info"
},
{
"param": "regno",
"type": "unsigned int"
},
{
"param": "data",
"type": "uint32_t"
},
{
"param": "size",
"type": "unsigned int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "sc",
"type": "struct emu_sc_info",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "regno",
"type": "unsigned int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "data",
"type": "uint32_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "size",
"type": "unsigned int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
87b717d1066f2c36eaf7076a7058446d9bc34798 | atrens/DragonFlyBSD-src | sys/dev/sound/pci/emu10kx.c | [
"BSD-3-Clause"
] | C | emu_enable_ir | void | void
emu_enable_ir(struct emu_sc_info *sc)
{
uint32_t iocfg;
if (sc->is_emu10k2 || sc->is_ca0102) {
iocfg = emu_rd_nolock(sc, EMU_A_IOCFG, 2);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg | EMU_A_IOCFG_GPOUT2, 2);
DELAY(500);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg | EMU_A_IOCFG_GPOUT1 | EMU_A_IOCFG_GPOUT2, 2);
DELAY(500);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg | EMU_A_IOCFG_GPOUT1, 2);
DELAY(100);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg, 2);
device_printf(sc->dev, "Audigy IR MIDI events enabled.\n");
sc->enable_ir = 1;
}
if (sc->is_emu10k1) {
iocfg = emu_rd_nolock(sc, EMU_HCFG, 4);
emu_wr_nolock(sc, EMU_HCFG, iocfg | EMU_HCFG_GPOUT2, 4);
DELAY(500);
emu_wr_nolock(sc, EMU_HCFG, iocfg | EMU_HCFG_GPOUT1 | EMU_HCFG_GPOUT2, 4);
DELAY(100);
emu_wr_nolock(sc, EMU_HCFG, iocfg, 4);
device_printf(sc->dev, "SB Live! IR MIDI events enabled.\n");
sc->enable_ir = 1;
}
} | /*
* Enabling IR MIDI messages is another kind of black magic. It just
* has to be made this way. It really do it.
*/ | Enabling IR MIDI messages is another kind of black magic. It just
has to be made this way. It really do it. | [
"Enabling",
"IR",
"MIDI",
"messages",
"is",
"another",
"kind",
"of",
"black",
"magic",
".",
"It",
"just",
"has",
"to",
"be",
"made",
"this",
"way",
".",
"It",
"really",
"do",
"it",
"."
] | void
emu_enable_ir(struct emu_sc_info *sc)
{
uint32_t iocfg;
if (sc->is_emu10k2 || sc->is_ca0102) {
iocfg = emu_rd_nolock(sc, EMU_A_IOCFG, 2);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg | EMU_A_IOCFG_GPOUT2, 2);
DELAY(500);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg | EMU_A_IOCFG_GPOUT1 | EMU_A_IOCFG_GPOUT2, 2);
DELAY(500);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg | EMU_A_IOCFG_GPOUT1, 2);
DELAY(100);
emu_wr_nolock(sc, EMU_A_IOCFG, iocfg, 2);
device_printf(sc->dev, "Audigy IR MIDI events enabled.\n");
sc->enable_ir = 1;
}
if (sc->is_emu10k1) {
iocfg = emu_rd_nolock(sc, EMU_HCFG, 4);
emu_wr_nolock(sc, EMU_HCFG, iocfg | EMU_HCFG_GPOUT2, 4);
DELAY(500);
emu_wr_nolock(sc, EMU_HCFG, iocfg | EMU_HCFG_GPOUT1 | EMU_HCFG_GPOUT2, 4);
DELAY(100);
emu_wr_nolock(sc, EMU_HCFG, iocfg, 4);
device_printf(sc->dev, "SB Live! IR MIDI events enabled.\n");
sc->enable_ir = 1;
}
} | [
"void",
"emu_enable_ir",
"(",
"struct",
"emu_sc_info",
"*",
"sc",
")",
"{",
"uint32_t",
"iocfg",
";",
"if",
"(",
"sc",
"->",
"is_emu10k2",
"||",
"sc",
"->",
"is_ca0102",
")",
"{",
"iocfg",
"=",
"emu_rd_nolock",
"(",
"sc",
",",
"EMU_A_IOCFG",
",",
"2",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_A_IOCFG",
",",
"iocfg",
"|",
"EMU_A_IOCFG_GPOUT2",
",",
"2",
")",
";",
"DELAY",
"(",
"500",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_A_IOCFG",
",",
"iocfg",
"|",
"EMU_A_IOCFG_GPOUT1",
"|",
"EMU_A_IOCFG_GPOUT2",
",",
"2",
")",
";",
"DELAY",
"(",
"500",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_A_IOCFG",
",",
"iocfg",
"|",
"EMU_A_IOCFG_GPOUT1",
",",
"2",
")",
";",
"DELAY",
"(",
"100",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_A_IOCFG",
",",
"iocfg",
",",
"2",
")",
";",
"device_printf",
"(",
"sc",
"->",
"dev",
",",
"\"",
"\\n",
"\"",
")",
";",
"sc",
"->",
"enable_ir",
"=",
"1",
";",
"}",
"if",
"(",
"sc",
"->",
"is_emu10k1",
")",
"{",
"iocfg",
"=",
"emu_rd_nolock",
"(",
"sc",
",",
"EMU_HCFG",
",",
"4",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_HCFG",
",",
"iocfg",
"|",
"EMU_HCFG_GPOUT2",
",",
"4",
")",
";",
"DELAY",
"(",
"500",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_HCFG",
",",
"iocfg",
"|",
"EMU_HCFG_GPOUT1",
"|",
"EMU_HCFG_GPOUT2",
",",
"4",
")",
";",
"DELAY",
"(",
"100",
")",
";",
"emu_wr_nolock",
"(",
"sc",
",",
"EMU_HCFG",
",",
"iocfg",
",",
"4",
")",
";",
"device_printf",
"(",
"sc",
"->",
"dev",
",",
"\"",
"\\n",
"\"",
")",
";",
"sc",
"->",
"enable_ir",
"=",
"1",
";",
"}",
"}"
] | Enabling IR MIDI messages is another kind of black magic. | [
"Enabling",
"IR",
"MIDI",
"messages",
"is",
"another",
"kind",
"of",
"black",
"magic",
"."
] | [] | [
{
"param": "sc",
"type": "struct emu_sc_info"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "sc",
"type": "struct emu_sc_info",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
87b717d1066f2c36eaf7076a7058446d9bc34798 | atrens/DragonFlyBSD-src | sys/dev/sound/pci/emu10kx.c | [
"BSD-3-Clause"
] | C | emu_gettag | bus_dma_tag_t | bus_dma_tag_t
emu_gettag(struct emu_sc_info *sc)
{
return (sc->mem.dmat);
} | /*
* Get data from private emu10kx structure for PCM buffer allocation.
* Used by PCM code only.
*/ | Get data from private emu10kx structure for PCM buffer allocation.
Used by PCM code only. | [
"Get",
"data",
"from",
"private",
"emu10kx",
"structure",
"for",
"PCM",
"buffer",
"allocation",
".",
"Used",
"by",
"PCM",
"code",
"only",
"."
] | bus_dma_tag_t
emu_gettag(struct emu_sc_info *sc)
{
return (sc->mem.dmat);
} | [
"bus_dma_tag_t",
"emu_gettag",
"(",
"struct",
"emu_sc_info",
"*",
"sc",
")",
"{",
"return",
"(",
"sc",
"->",
"mem",
".",
"dmat",
")",
";",
"}"
] | Get data from private emu10kx structure for PCM buffer allocation. | [
"Get",
"data",
"from",
"private",
"emu10kx",
"structure",
"for",
"PCM",
"buffer",
"allocation",
"."
] | [] | [
{
"param": "sc",
"type": "struct emu_sc_info"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "sc",
"type": "struct emu_sc_info",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
4b43aec6b72b8f05ff4c6d8803fc403b72df50ef | atrens/DragonFlyBSD-src | contrib/binutils-2.34/binutils/addr2line.c | [
"BSD-3-Clause"
] | C | usage | void | static void
usage (FILE *stream, int status)
{
fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
fprintf (stream, _(" The options are:\n\
@<file> Read options from <file>\n\
-a --addresses Show addresses\n\
-b --target=<bfdname> Set the binary file format\n\
-e --exe=<executable> Set the input file name (default is a.out)\n\
-i --inlines Unwind inlined functions\n\
-j --section=<name> Read section-relative offsets instead of addresses\n\
-p --pretty-print Make the output easier to read for humans\n\
-s --basenames Strip directory names\n\
-f --functions Show function names\n\
-C --demangle[=style] Demangle function names\n\
-R --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
-r --no-recurse-limit Disable a limit on recursion whilst demangling\n\
-h --help Display this information\n\
-v --version Display the program's version\n\
\n"));
list_supported_targets (program_name, stream);
if (REPORT_BUGS_TO[0] && status == 0)
fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
exit (status);
} | /* Print a usage message to STREAM and exit with STATUS. */ | Print a usage message to STREAM and exit with STATUS. | [
"Print",
"a",
"usage",
"message",
"to",
"STREAM",
"and",
"exit",
"with",
"STATUS",
"."
] | static void
usage (FILE *stream, int status)
{
fprintf (stream, _("Usage: %s [option(s)] [addr(s)]\n"), program_name);
fprintf (stream, _(" Convert addresses into line number/file name pairs.\n"));
fprintf (stream, _(" If no addresses are specified on the command line, they will be read from stdin\n"));
fprintf (stream, _(" The options are:\n\
@<file> Read options from <file>\n\
-a --addresses Show addresses\n\
-b --target=<bfdname> Set the binary file format\n\
-e --exe=<executable> Set the input file name (default is a.out)\n\
-i --inlines Unwind inlined functions\n\
-j --section=<name> Read section-relative offsets instead of addresses\n\
-p --pretty-print Make the output easier to read for humans\n\
-s --basenames Strip directory names\n\
-f --functions Show function names\n\
-C --demangle[=style] Demangle function names\n\
-R --recurse-limit Enable a limit on recursion whilst demangling. [Default]\n\
-r --no-recurse-limit Disable a limit on recursion whilst demangling\n\
-h --help Display this information\n\
-v --version Display the program's version\n\
\n"));
list_supported_targets (program_name, stream);
if (REPORT_BUGS_TO[0] && status == 0)
fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
exit (status);
} | [
"static",
"void",
"usage",
"(",
"FILE",
"*",
"stream",
",",
"int",
"status",
")",
"{",
"fprintf",
"(",
"stream",
",",
"_",
"(",
"\"",
"\\n",
"\"",
")",
",",
"program_name",
")",
";",
"fprintf",
"(",
"stream",
",",
"_",
"(",
"\"",
"\\n",
"\"",
")",
")",
";",
"fprintf",
"(",
"stream",
",",
"_",
"(",
"\"",
"\\n",
"\"",
")",
")",
";",
"fprintf",
"(",
"stream",
",",
"_",
"(",
"\"",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n",
"\\n",
"\\\n\\n",
"\"",
")",
")",
";",
"list_supported_targets",
"(",
"program_name",
",",
"stream",
")",
";",
"if",
"(",
"REPORT_BUGS_TO",
"[",
"0",
"]",
"&&",
"status",
"==",
"0",
")",
"fprintf",
"(",
"stream",
",",
"_",
"(",
"\"",
"\\n",
"\"",
")",
",",
"REPORT_BUGS_TO",
")",
";",
"exit",
"(",
"status",
")",
";",
"}"
] | Print a usage message to STREAM and exit with STATUS. | [
"Print",
"a",
"usage",
"message",
"to",
"STREAM",
"and",
"exit",
"with",
"STATUS",
"."
] | [] | [
{
"param": "stream",
"type": "FILE"
},
{
"param": "status",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "stream",
"type": "FILE",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "status",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
4b43aec6b72b8f05ff4c6d8803fc403b72df50ef | atrens/DragonFlyBSD-src | contrib/binutils-2.34/binutils/addr2line.c | [
"BSD-3-Clause"
] | C | slurp_symtab | void | static void
slurp_symtab (bfd *abfd)
{
long storage;
long symcount;
bfd_boolean dynamic = FALSE;
if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
return;
storage = bfd_get_symtab_upper_bound (abfd);
if (storage == 0)
{
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
dynamic = TRUE;
}
if (storage < 0)
bfd_fatal (bfd_get_filename (abfd));
syms = (asymbol **) xmalloc (storage);
if (dynamic)
symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
else
symcount = bfd_canonicalize_symtab (abfd, syms);
if (symcount < 0)
bfd_fatal (bfd_get_filename (abfd));
/* If there are no symbols left after canonicalization and
we have not tried the dynamic symbols then give them a go. */
if (symcount == 0
&& ! dynamic
&& (storage = bfd_get_dynamic_symtab_upper_bound (abfd)) > 0)
{
free (syms);
syms = xmalloc (storage);
symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
}
/* PR 17512: file: 2a1d3b5b.
Do not pretend that we have some symbols when we don't. */
if (symcount <= 0)
{
free (syms);
syms = NULL;
}
} | /* Read in the symbol table. */ | Read in the symbol table. | [
"Read",
"in",
"the",
"symbol",
"table",
"."
] | static void
slurp_symtab (bfd *abfd)
{
long storage;
long symcount;
bfd_boolean dynamic = FALSE;
if ((bfd_get_file_flags (abfd) & HAS_SYMS) == 0)
return;
storage = bfd_get_symtab_upper_bound (abfd);
if (storage == 0)
{
storage = bfd_get_dynamic_symtab_upper_bound (abfd);
dynamic = TRUE;
}
if (storage < 0)
bfd_fatal (bfd_get_filename (abfd));
syms = (asymbol **) xmalloc (storage);
if (dynamic)
symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
else
symcount = bfd_canonicalize_symtab (abfd, syms);
if (symcount < 0)
bfd_fatal (bfd_get_filename (abfd));
if (symcount == 0
&& ! dynamic
&& (storage = bfd_get_dynamic_symtab_upper_bound (abfd)) > 0)
{
free (syms);
syms = xmalloc (storage);
symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
}
if (symcount <= 0)
{
free (syms);
syms = NULL;
}
} | [
"static",
"void",
"slurp_symtab",
"(",
"bfd",
"*",
"abfd",
")",
"{",
"long",
"storage",
";",
"long",
"symcount",
";",
"bfd_boolean",
"dynamic",
"=",
"FALSE",
";",
"if",
"(",
"(",
"bfd_get_file_flags",
"(",
"abfd",
")",
"&",
"HAS_SYMS",
")",
"==",
"0",
")",
"return",
";",
"storage",
"=",
"bfd_get_symtab_upper_bound",
"(",
"abfd",
")",
";",
"if",
"(",
"storage",
"==",
"0",
")",
"{",
"storage",
"=",
"bfd_get_dynamic_symtab_upper_bound",
"(",
"abfd",
")",
";",
"dynamic",
"=",
"TRUE",
";",
"}",
"if",
"(",
"storage",
"<",
"0",
")",
"bfd_fatal",
"(",
"bfd_get_filename",
"(",
"abfd",
")",
")",
";",
"syms",
"=",
"(",
"asymbol",
"*",
"*",
")",
"xmalloc",
"(",
"storage",
")",
";",
"if",
"(",
"dynamic",
")",
"symcount",
"=",
"bfd_canonicalize_dynamic_symtab",
"(",
"abfd",
",",
"syms",
")",
";",
"else",
"symcount",
"=",
"bfd_canonicalize_symtab",
"(",
"abfd",
",",
"syms",
")",
";",
"if",
"(",
"symcount",
"<",
"0",
")",
"bfd_fatal",
"(",
"bfd_get_filename",
"(",
"abfd",
")",
")",
";",
"if",
"(",
"symcount",
"==",
"0",
"&&",
"!",
"dynamic",
"&&",
"(",
"storage",
"=",
"bfd_get_dynamic_symtab_upper_bound",
"(",
"abfd",
")",
")",
">",
"0",
")",
"{",
"free",
"(",
"syms",
")",
";",
"syms",
"=",
"xmalloc",
"(",
"storage",
")",
";",
"symcount",
"=",
"bfd_canonicalize_dynamic_symtab",
"(",
"abfd",
",",
"syms",
")",
";",
"}",
"if",
"(",
"symcount",
"<=",
"0",
")",
"{",
"free",
"(",
"syms",
")",
";",
"syms",
"=",
"NULL",
";",
"}",
"}"
] | Read in the symbol table. | [
"Read",
"in",
"the",
"symbol",
"table",
"."
] | [
"/* If there are no symbols left after canonicalization and\n we have not tried the dynamic symbols then give them a go. */",
"/* PR 17512: file: 2a1d3b5b.\n Do not pretend that we have some symbols when we don't. */"
] | [
{
"param": "abfd",
"type": "bfd"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "abfd",
"type": "bfd",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
4b43aec6b72b8f05ff4c6d8803fc403b72df50ef | atrens/DragonFlyBSD-src | contrib/binutils-2.34/binutils/addr2line.c | [
"BSD-3-Clause"
] | C | find_offset_in_section | void | static void
find_offset_in_section (bfd *abfd, asection *section)
{
bfd_size_type size;
if (found)
return;
if ((bfd_section_flags (section) & SEC_ALLOC) == 0)
return;
size = bfd_section_size (section);
if (pc >= size)
return;
found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc,
&filename, &functionname,
&line, &discriminator);
} | /* Look for an offset in a section. This is directly called. */ | Look for an offset in a section. This is directly called. | [
"Look",
"for",
"an",
"offset",
"in",
"a",
"section",
".",
"This",
"is",
"directly",
"called",
"."
] | static void
find_offset_in_section (bfd *abfd, asection *section)
{
bfd_size_type size;
if (found)
return;
if ((bfd_section_flags (section) & SEC_ALLOC) == 0)
return;
size = bfd_section_size (section);
if (pc >= size)
return;
found = bfd_find_nearest_line_discriminator (abfd, section, syms, pc,
&filename, &functionname,
&line, &discriminator);
} | [
"static",
"void",
"find_offset_in_section",
"(",
"bfd",
"*",
"abfd",
",",
"asection",
"*",
"section",
")",
"{",
"bfd_size_type",
"size",
";",
"if",
"(",
"found",
")",
"return",
";",
"if",
"(",
"(",
"bfd_section_flags",
"(",
"section",
")",
"&",
"SEC_ALLOC",
")",
"==",
"0",
")",
"return",
";",
"size",
"=",
"bfd_section_size",
"(",
"section",
")",
";",
"if",
"(",
"pc",
">=",
"size",
")",
"return",
";",
"found",
"=",
"bfd_find_nearest_line_discriminator",
"(",
"abfd",
",",
"section",
",",
"syms",
",",
"pc",
",",
"&",
"filename",
",",
"&",
"functionname",
",",
"&",
"line",
",",
"&",
"discriminator",
")",
";",
"}"
] | Look for an offset in a section. | [
"Look",
"for",
"an",
"offset",
"in",
"a",
"section",
"."
] | [] | [
{
"param": "abfd",
"type": "bfd"
},
{
"param": "section",
"type": "asection"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "abfd",
"type": "bfd",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "section",
"type": "asection",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
4b43aec6b72b8f05ff4c6d8803fc403b72df50ef | atrens/DragonFlyBSD-src | contrib/binutils-2.34/binutils/addr2line.c | [
"BSD-3-Clause"
] | C | translate_addresses | void | static void
translate_addresses (bfd *abfd, asection *section)
{
int read_stdin = (naddr == 0);
for (;;)
{
if (read_stdin)
{
char addr_hex[100];
if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
break;
pc = bfd_scan_vma (addr_hex, NULL, 16);
}
else
{
if (naddr <= 0)
break;
--naddr;
pc = bfd_scan_vma (*addr++, NULL, 16);
}
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);
pc &= (sign << 1) - 1;
if (bed->sign_extend_vma)
pc = (pc ^ sign) - sign;
}
if (with_addresses)
{
printf ("0x");
bfd_printf_vma (abfd, pc);
if (pretty_print)
printf (": ");
else
printf ("\n");
}
found = FALSE;
if (section)
find_offset_in_section (abfd, section);
else
bfd_map_over_sections (abfd, find_address_in_section, NULL);
if (! found)
{
if (with_functions)
{
if (pretty_print)
printf ("?? ");
else
printf ("??\n");
}
printf ("??:0\n");
}
else
{
while (1)
{
if (with_functions)
{
const char *name;
char *alloc = NULL;
name = functionname;
if (name == NULL || *name == '\0')
name = "??";
else if (do_demangle)
{
alloc = bfd_demangle (abfd, name, demangle_flags);
if (alloc != NULL)
name = alloc;
}
printf ("%s", name);
if (pretty_print)
/* Note for translators: This printf is used to join the
function name just printed above to the line number/
file name pair that is about to be printed below. Eg:
foo at 123:bar.c */
printf (_(" at "));
else
printf ("\n");
if (alloc != NULL)
free (alloc);
}
if (base_names && filename != NULL)
{
char *h;
h = strrchr (filename, '/');
if (h != NULL)
filename = h + 1;
}
printf ("%s:", filename ? filename : "??");
if (line != 0)
{
if (discriminator != 0)
printf ("%u (discriminator %u)\n", line, discriminator);
else
printf ("%u\n", line);
}
else
printf ("?\n");
if (!unwind_inlines)
found = FALSE;
else
found = bfd_find_inliner_info (abfd, &filename, &functionname,
&line);
if (! found)
break;
if (pretty_print)
/* Note for translators: This printf is used to join the
line number/file name pair that has just been printed with
the line number/file name pair that is going to be printed
by the next iteration of the while loop. Eg:
123:bar.c (inlined by) 456:main.c */
printf (_(" (inlined by) "));
}
}
/* fflush() is essential for using this command as a server
child process that reads addresses from a pipe and responds
with line number information, processing one address at a
time. */
fflush (stdout);
}
} | /* Read hexadecimal addresses from stdin, translate into
file_name:line_number and optionally function name. */ | Read hexadecimal addresses from stdin, translate into
file_name:line_number and optionally function name. | [
"Read",
"hexadecimal",
"addresses",
"from",
"stdin",
"translate",
"into",
"file_name",
":",
"line_number",
"and",
"optionally",
"function",
"name",
"."
] | static void
translate_addresses (bfd *abfd, asection *section)
{
int read_stdin = (naddr == 0);
for (;;)
{
if (read_stdin)
{
char addr_hex[100];
if (fgets (addr_hex, sizeof addr_hex, stdin) == NULL)
break;
pc = bfd_scan_vma (addr_hex, NULL, 16);
}
else
{
if (naddr <= 0)
break;
--naddr;
pc = bfd_scan_vma (*addr++, NULL, 16);
}
if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
{
const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bfd_vma sign = (bfd_vma) 1 << (bed->s->arch_size - 1);
pc &= (sign << 1) - 1;
if (bed->sign_extend_vma)
pc = (pc ^ sign) - sign;
}
if (with_addresses)
{
printf ("0x");
bfd_printf_vma (abfd, pc);
if (pretty_print)
printf (": ");
else
printf ("\n");
}
found = FALSE;
if (section)
find_offset_in_section (abfd, section);
else
bfd_map_over_sections (abfd, find_address_in_section, NULL);
if (! found)
{
if (with_functions)
{
if (pretty_print)
printf ("?? ");
else
printf ("??\n");
}
printf ("??:0\n");
}
else
{
while (1)
{
if (with_functions)
{
const char *name;
char *alloc = NULL;
name = functionname;
if (name == NULL || *name == '\0')
name = "??";
else if (do_demangle)
{
alloc = bfd_demangle (abfd, name, demangle_flags);
if (alloc != NULL)
name = alloc;
}
printf ("%s", name);
if (pretty_print)
printf (_(" at "));
else
printf ("\n");
if (alloc != NULL)
free (alloc);
}
if (base_names && filename != NULL)
{
char *h;
h = strrchr (filename, '/');
if (h != NULL)
filename = h + 1;
}
printf ("%s:", filename ? filename : "??");
if (line != 0)
{
if (discriminator != 0)
printf ("%u (discriminator %u)\n", line, discriminator);
else
printf ("%u\n", line);
}
else
printf ("?\n");
if (!unwind_inlines)
found = FALSE;
else
found = bfd_find_inliner_info (abfd, &filename, &functionname,
&line);
if (! found)
break;
if (pretty_print)
printf (_(" (inlined by) "));
}
}
fflush (stdout);
}
} | [
"static",
"void",
"translate_addresses",
"(",
"bfd",
"*",
"abfd",
",",
"asection",
"*",
"section",
")",
"{",
"int",
"read_stdin",
"=",
"(",
"naddr",
"==",
"0",
")",
";",
"for",
"(",
";",
";",
")",
"{",
"if",
"(",
"read_stdin",
")",
"{",
"char",
"addr_hex",
"[",
"100",
"]",
";",
"if",
"(",
"fgets",
"(",
"addr_hex",
",",
"sizeof",
"addr_hex",
",",
"stdin",
")",
"==",
"NULL",
")",
"break",
";",
"pc",
"=",
"bfd_scan_vma",
"(",
"addr_hex",
",",
"NULL",
",",
"16",
")",
";",
"}",
"else",
"{",
"if",
"(",
"naddr",
"<=",
"0",
")",
"break",
";",
"--",
"naddr",
";",
"pc",
"=",
"bfd_scan_vma",
"(",
"*",
"addr",
"++",
",",
"NULL",
",",
"16",
")",
";",
"}",
"if",
"(",
"bfd_get_flavour",
"(",
"abfd",
")",
"==",
"bfd_target_elf_flavour",
")",
"{",
"const",
"struct",
"elf_backend_data",
"*",
"bed",
"=",
"get_elf_backend_data",
"(",
"abfd",
")",
";",
"bfd_vma",
"sign",
"=",
"(",
"bfd_vma",
")",
"1",
"<<",
"(",
"bed",
"->",
"s",
"->",
"arch_size",
"-",
"1",
")",
";",
"pc",
"&=",
"(",
"sign",
"<<",
"1",
")",
"-",
"1",
";",
"if",
"(",
"bed",
"->",
"sign_extend_vma",
")",
"pc",
"=",
"(",
"pc",
"^",
"sign",
")",
"-",
"sign",
";",
"}",
"if",
"(",
"with_addresses",
")",
"{",
"printf",
"(",
"\"",
"\"",
")",
";",
"bfd_printf_vma",
"(",
"abfd",
",",
"pc",
")",
";",
"if",
"(",
"pretty_print",
")",
"printf",
"(",
"\"",
"\"",
")",
";",
"else",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"}",
"found",
"=",
"FALSE",
";",
"if",
"(",
"section",
")",
"find_offset_in_section",
"(",
"abfd",
",",
"section",
")",
";",
"else",
"bfd_map_over_sections",
"(",
"abfd",
",",
"find_address_in_section",
",",
"NULL",
")",
";",
"if",
"(",
"!",
"found",
")",
"{",
"if",
"(",
"with_functions",
")",
"{",
"if",
"(",
"pretty_print",
")",
"printf",
"(",
"\"",
"\"",
")",
";",
"else",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"}",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"}",
"else",
"{",
"while",
"(",
"1",
")",
"{",
"if",
"(",
"with_functions",
")",
"{",
"const",
"char",
"*",
"name",
";",
"char",
"*",
"alloc",
"=",
"NULL",
";",
"name",
"=",
"functionname",
";",
"if",
"(",
"name",
"==",
"NULL",
"||",
"*",
"name",
"==",
"'",
"\\0",
"'",
")",
"name",
"=",
"\"",
"\"",
";",
"else",
"if",
"(",
"do_demangle",
")",
"{",
"alloc",
"=",
"bfd_demangle",
"(",
"abfd",
",",
"name",
",",
"demangle_flags",
")",
";",
"if",
"(",
"alloc",
"!=",
"NULL",
")",
"name",
"=",
"alloc",
";",
"}",
"printf",
"(",
"\"",
"\"",
",",
"name",
")",
";",
"if",
"(",
"pretty_print",
")",
"printf",
"(",
"_",
"(",
"\"",
"\"",
")",
")",
";",
"else",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"if",
"(",
"alloc",
"!=",
"NULL",
")",
"free",
"(",
"alloc",
")",
";",
"}",
"if",
"(",
"base_names",
"&&",
"filename",
"!=",
"NULL",
")",
"{",
"char",
"*",
"h",
";",
"h",
"=",
"strrchr",
"(",
"filename",
",",
"'",
"'",
")",
";",
"if",
"(",
"h",
"!=",
"NULL",
")",
"filename",
"=",
"h",
"+",
"1",
";",
"}",
"printf",
"(",
"\"",
"\"",
",",
"filename",
"?",
"filename",
":",
"\"",
"\"",
")",
";",
"if",
"(",
"line",
"!=",
"0",
")",
"{",
"if",
"(",
"discriminator",
"!=",
"0",
")",
"printf",
"(",
"\"",
"\\n",
"\"",
",",
"line",
",",
"discriminator",
")",
";",
"else",
"printf",
"(",
"\"",
"\\n",
"\"",
",",
"line",
")",
";",
"}",
"else",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"if",
"(",
"!",
"unwind_inlines",
")",
"found",
"=",
"FALSE",
";",
"else",
"found",
"=",
"bfd_find_inliner_info",
"(",
"abfd",
",",
"&",
"filename",
",",
"&",
"functionname",
",",
"&",
"line",
")",
";",
"if",
"(",
"!",
"found",
")",
"break",
";",
"if",
"(",
"pretty_print",
")",
"printf",
"(",
"_",
"(",
"\"",
"\"",
")",
")",
";",
"}",
"}",
"fflush",
"(",
"stdout",
")",
";",
"}",
"}"
] | Read hexadecimal addresses from stdin, translate into
file_name:line_number and optionally function name. | [
"Read",
"hexadecimal",
"addresses",
"from",
"stdin",
"translate",
"into",
"file_name",
":",
"line_number",
"and",
"optionally",
"function",
"name",
"."
] | [
"/* Note for translators: This printf is used to join the\n\t\t function name just printed above to the line number/\n\t\t file name pair that is about to be printed below. Eg:\n\n\t\t foo at 123:bar.c */",
"/* Note for translators: This printf is used to join the\n\t\t line number/file name pair that has just been printed with\n\t\t the line number/file name pair that is going to be printed\n\t\t by the next iteration of the while loop. Eg:\n\n\t\t 123:bar.c (inlined by) 456:main.c */",
"/* fflush() is essential for using this command as a server\n child process that reads addresses from a pipe and responds\n with line number information, processing one address at a\n time. */"
] | [
{
"param": "abfd",
"type": "bfd"
},
{
"param": "section",
"type": "asection"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "abfd",
"type": "bfd",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "section",
"type": "asection",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
4b43aec6b72b8f05ff4c6d8803fc403b72df50ef | atrens/DragonFlyBSD-src | contrib/binutils-2.34/binutils/addr2line.c | [
"BSD-3-Clause"
] | C | process_file | int | static int
process_file (const char *file_name, const char *section_name,
const char *target)
{
bfd *abfd;
asection *section;
char **matching;
if (get_file_size (file_name) < 1)
return 1;
abfd = bfd_openr (file_name, target);
if (abfd == NULL)
bfd_fatal (file_name);
/* Decompress sections. */
abfd->flags |= BFD_DECOMPRESS;
if (bfd_check_format (abfd, bfd_archive))
fatal (_("%s: cannot get addresses from archive"), file_name);
if (! bfd_check_format_matches (abfd, bfd_object, &matching))
{
bfd_nonfatal (bfd_get_filename (abfd));
if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
{
list_matching_formats (matching);
free (matching);
}
xexit (1);
}
if (section_name != NULL)
{
section = bfd_get_section_by_name (abfd, section_name);
if (section == NULL)
fatal (_("%s: cannot find section %s"), file_name, section_name);
}
else
section = NULL;
slurp_symtab (abfd);
translate_addresses (abfd, section);
if (syms != NULL)
{
free (syms);
syms = NULL;
}
bfd_close (abfd);
return 0;
} | /* Process a file. Returns an exit value for main(). */ | Process a file. Returns an exit value for main(). | [
"Process",
"a",
"file",
".",
"Returns",
"an",
"exit",
"value",
"for",
"main",
"()",
"."
] | static int
process_file (const char *file_name, const char *section_name,
const char *target)
{
bfd *abfd;
asection *section;
char **matching;
if (get_file_size (file_name) < 1)
return 1;
abfd = bfd_openr (file_name, target);
if (abfd == NULL)
bfd_fatal (file_name);
abfd->flags |= BFD_DECOMPRESS;
if (bfd_check_format (abfd, bfd_archive))
fatal (_("%s: cannot get addresses from archive"), file_name);
if (! bfd_check_format_matches (abfd, bfd_object, &matching))
{
bfd_nonfatal (bfd_get_filename (abfd));
if (bfd_get_error () == bfd_error_file_ambiguously_recognized)
{
list_matching_formats (matching);
free (matching);
}
xexit (1);
}
if (section_name != NULL)
{
section = bfd_get_section_by_name (abfd, section_name);
if (section == NULL)
fatal (_("%s: cannot find section %s"), file_name, section_name);
}
else
section = NULL;
slurp_symtab (abfd);
translate_addresses (abfd, section);
if (syms != NULL)
{
free (syms);
syms = NULL;
}
bfd_close (abfd);
return 0;
} | [
"static",
"int",
"process_file",
"(",
"const",
"char",
"*",
"file_name",
",",
"const",
"char",
"*",
"section_name",
",",
"const",
"char",
"*",
"target",
")",
"{",
"bfd",
"*",
"abfd",
";",
"asection",
"*",
"section",
";",
"char",
"*",
"*",
"matching",
";",
"if",
"(",
"get_file_size",
"(",
"file_name",
")",
"<",
"1",
")",
"return",
"1",
";",
"abfd",
"=",
"bfd_openr",
"(",
"file_name",
",",
"target",
")",
";",
"if",
"(",
"abfd",
"==",
"NULL",
")",
"bfd_fatal",
"(",
"file_name",
")",
";",
"abfd",
"->",
"flags",
"|=",
"BFD_DECOMPRESS",
";",
"if",
"(",
"bfd_check_format",
"(",
"abfd",
",",
"bfd_archive",
")",
")",
"fatal",
"(",
"_",
"(",
"\"",
"\"",
")",
",",
"file_name",
")",
";",
"if",
"(",
"!",
"bfd_check_format_matches",
"(",
"abfd",
",",
"bfd_object",
",",
"&",
"matching",
")",
")",
"{",
"bfd_nonfatal",
"(",
"bfd_get_filename",
"(",
"abfd",
")",
")",
";",
"if",
"(",
"bfd_get_error",
"(",
")",
"==",
"bfd_error_file_ambiguously_recognized",
")",
"{",
"list_matching_formats",
"(",
"matching",
")",
";",
"free",
"(",
"matching",
")",
";",
"}",
"xexit",
"(",
"1",
")",
";",
"}",
"if",
"(",
"section_name",
"!=",
"NULL",
")",
"{",
"section",
"=",
"bfd_get_section_by_name",
"(",
"abfd",
",",
"section_name",
")",
";",
"if",
"(",
"section",
"==",
"NULL",
")",
"fatal",
"(",
"_",
"(",
"\"",
"\"",
")",
",",
"file_name",
",",
"section_name",
")",
";",
"}",
"else",
"section",
"=",
"NULL",
";",
"slurp_symtab",
"(",
"abfd",
")",
";",
"translate_addresses",
"(",
"abfd",
",",
"section",
")",
";",
"if",
"(",
"syms",
"!=",
"NULL",
")",
"{",
"free",
"(",
"syms",
")",
";",
"syms",
"=",
"NULL",
";",
"}",
"bfd_close",
"(",
"abfd",
")",
";",
"return",
"0",
";",
"}"
] | Process a file. | [
"Process",
"a",
"file",
"."
] | [
"/* Decompress sections. */"
] | [
{
"param": "file_name",
"type": "char"
},
{
"param": "section_name",
"type": "char"
},
{
"param": "target",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "file_name",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "section_name",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "target",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | phi_arg_in_outermost_loop | size_t | static size_t
phi_arg_in_outermost_loop (gimple phi)
{
loop_p loop = gimple_bb (phi)->loop_father;
size_t i, res = 0;
for (i = 0; i < gimple_phi_num_args (phi); i++)
if (!flow_bb_inside_loop_p (loop, gimple_phi_arg_edge (phi, i)->src))
{
loop = gimple_phi_arg_edge (phi, i)->src->loop_father;
res = i;
}
return res;
} | /* Returns the index of the PHI argument defined in the outermost
loop. */ | Returns the index of the PHI argument defined in the outermost
loop. | [
"Returns",
"the",
"index",
"of",
"the",
"PHI",
"argument",
"defined",
"in",
"the",
"outermost",
"loop",
"."
] | static size_t
phi_arg_in_outermost_loop (gimple phi)
{
loop_p loop = gimple_bb (phi)->loop_father;
size_t i, res = 0;
for (i = 0; i < gimple_phi_num_args (phi); i++)
if (!flow_bb_inside_loop_p (loop, gimple_phi_arg_edge (phi, i)->src))
{
loop = gimple_phi_arg_edge (phi, i)->src->loop_father;
res = i;
}
return res;
} | [
"static",
"size_t",
"phi_arg_in_outermost_loop",
"(",
"gimple",
"phi",
")",
"{",
"loop_p",
"loop",
"=",
"gimple_bb",
"(",
"phi",
")",
"->",
"loop_father",
";",
"size_t",
"i",
",",
"res",
"=",
"0",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"gimple_phi_num_args",
"(",
"phi",
")",
";",
"i",
"++",
")",
"if",
"(",
"!",
"flow_bb_inside_loop_p",
"(",
"loop",
",",
"gimple_phi_arg_edge",
"(",
"phi",
",",
"i",
")",
"->",
"src",
")",
")",
"{",
"loop",
"=",
"gimple_phi_arg_edge",
"(",
"phi",
",",
"i",
")",
"->",
"src",
"->",
"loop_father",
";",
"res",
"=",
"i",
";",
"}",
"return",
"res",
";",
"}"
] | Returns the index of the PHI argument defined in the outermost
loop. | [
"Returns",
"the",
"index",
"of",
"the",
"PHI",
"argument",
"defined",
"in",
"the",
"outermost",
"loop",
"."
] | [] | [
{
"param": "phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | remove_invariant_phi | void | static void
remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
{
gimple phi = gsi_stmt (*psi);
loop_p loop = loop_containing_stmt (phi);
tree res = gimple_phi_result (phi);
tree scev = scalar_evolution_in_region (region, loop, res);
size_t entry = phi_arg_in_outermost_loop (phi);
edge e = gimple_phi_arg_edge (phi, entry);
tree var;
gimple stmt;
gimple_seq stmts;
gimple_stmt_iterator gsi;
if (tree_contains_chrecs (scev, NULL))
scev = gimple_phi_arg_def (phi, entry);
var = force_gimple_operand (scev, &stmts, true, NULL_TREE);
stmt = gimple_build_assign (res, var);
remove_phi_node (psi, false);
if (!stmts)
stmts = gimple_seq_alloc ();
gsi = gsi_last (stmts);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
gsi_insert_seq_on_edge (e, stmts);
gsi_commit_edge_inserts ();
SSA_NAME_DEF_STMT (res) = stmt;
} | /* Removes an invariant phi node at position PSI by inserting on the
loop ENTRY edge the assignment RES = INIT. */ | Removes an invariant phi node at position PSI by inserting on the
loop ENTRY edge the assignment RES = INIT. | [
"Removes",
"an",
"invariant",
"phi",
"node",
"at",
"position",
"PSI",
"by",
"inserting",
"on",
"the",
"loop",
"ENTRY",
"edge",
"the",
"assignment",
"RES",
"=",
"INIT",
"."
] | static void
remove_invariant_phi (sese region, gimple_stmt_iterator *psi)
{
gimple phi = gsi_stmt (*psi);
loop_p loop = loop_containing_stmt (phi);
tree res = gimple_phi_result (phi);
tree scev = scalar_evolution_in_region (region, loop, res);
size_t entry = phi_arg_in_outermost_loop (phi);
edge e = gimple_phi_arg_edge (phi, entry);
tree var;
gimple stmt;
gimple_seq stmts;
gimple_stmt_iterator gsi;
if (tree_contains_chrecs (scev, NULL))
scev = gimple_phi_arg_def (phi, entry);
var = force_gimple_operand (scev, &stmts, true, NULL_TREE);
stmt = gimple_build_assign (res, var);
remove_phi_node (psi, false);
if (!stmts)
stmts = gimple_seq_alloc ();
gsi = gsi_last (stmts);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
gsi_insert_seq_on_edge (e, stmts);
gsi_commit_edge_inserts ();
SSA_NAME_DEF_STMT (res) = stmt;
} | [
"static",
"void",
"remove_invariant_phi",
"(",
"sese",
"region",
",",
"gimple_stmt_iterator",
"*",
"psi",
")",
"{",
"gimple",
"phi",
"=",
"gsi_stmt",
"(",
"*",
"psi",
")",
";",
"loop_p",
"loop",
"=",
"loop_containing_stmt",
"(",
"phi",
")",
";",
"tree",
"res",
"=",
"gimple_phi_result",
"(",
"phi",
")",
";",
"tree",
"scev",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"res",
")",
";",
"size_t",
"entry",
"=",
"phi_arg_in_outermost_loop",
"(",
"phi",
")",
";",
"edge",
"e",
"=",
"gimple_phi_arg_edge",
"(",
"phi",
",",
"entry",
")",
";",
"tree",
"var",
";",
"gimple",
"stmt",
";",
"gimple_seq",
"stmts",
";",
"gimple_stmt_iterator",
"gsi",
";",
"if",
"(",
"tree_contains_chrecs",
"(",
"scev",
",",
"NULL",
")",
")",
"scev",
"=",
"gimple_phi_arg_def",
"(",
"phi",
",",
"entry",
")",
";",
"var",
"=",
"force_gimple_operand",
"(",
"scev",
",",
"&",
"stmts",
",",
"true",
",",
"NULL_TREE",
")",
";",
"stmt",
"=",
"gimple_build_assign",
"(",
"res",
",",
"var",
")",
";",
"remove_phi_node",
"(",
"psi",
",",
"false",
")",
";",
"if",
"(",
"!",
"stmts",
")",
"stmts",
"=",
"gimple_seq_alloc",
"(",
")",
";",
"gsi",
"=",
"gsi_last",
"(",
"stmts",
")",
";",
"gsi_insert_after",
"(",
"&",
"gsi",
",",
"stmt",
",",
"GSI_NEW_STMT",
")",
";",
"gsi_insert_seq_on_edge",
"(",
"e",
",",
"stmts",
")",
";",
"gsi_commit_edge_inserts",
"(",
")",
";",
"SSA_NAME_DEF_STMT",
"(",
"res",
")",
"=",
"stmt",
";",
"}"
] | Removes an invariant phi node at position PSI by inserting on the
loop ENTRY edge the assignment RES = INIT. | [
"Removes",
"an",
"invariant",
"phi",
"node",
"at",
"position",
"PSI",
"by",
"inserting",
"on",
"the",
"loop",
"ENTRY",
"edge",
"the",
"assignment",
"RES",
"=",
"INIT",
"."
] | [] | [
{
"param": "region",
"type": "sese"
},
{
"param": "psi",
"type": "gimple_stmt_iterator"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "psi",
"type": "gimple_stmt_iterator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | reduction_phi_p | bool | static bool
reduction_phi_p (sese region, gimple_stmt_iterator *psi)
{
loop_p loop;
gimple phi = gsi_stmt (*psi);
tree res = gimple_phi_result (phi);
loop = loop_containing_stmt (phi);
if (simple_copy_phi_p (phi))
{
/* PRE introduces phi nodes like these, for an example,
see id-5.f in the fortran graphite testsuite:
# prephitmp.85_265 = PHI <prephitmp.85_258(33), prephitmp.85_265(18)>
*/
remove_simple_copy_phi (psi);
return false;
}
if (scev_analyzable_p (res, region))
{
tree scev = scalar_evolution_in_region (region, loop, res);
if (evolution_function_is_invariant_p (scev, loop->num))
remove_invariant_phi (region, psi);
else
gsi_next (psi);
return false;
}
/* All the other cases are considered reductions. */
return true;
} | /* Returns true when the phi node at position PSI is a reduction phi
node in REGION. Otherwise moves the pointer PSI to the next phi to
be considered. */ | Returns true when the phi node at position PSI is a reduction phi
node in REGION. Otherwise moves the pointer PSI to the next phi to
be considered. | [
"Returns",
"true",
"when",
"the",
"phi",
"node",
"at",
"position",
"PSI",
"is",
"a",
"reduction",
"phi",
"node",
"in",
"REGION",
".",
"Otherwise",
"moves",
"the",
"pointer",
"PSI",
"to",
"the",
"next",
"phi",
"to",
"be",
"considered",
"."
] | static bool
reduction_phi_p (sese region, gimple_stmt_iterator *psi)
{
loop_p loop;
gimple phi = gsi_stmt (*psi);
tree res = gimple_phi_result (phi);
loop = loop_containing_stmt (phi);
if (simple_copy_phi_p (phi))
{
remove_simple_copy_phi (psi);
return false;
}
if (scev_analyzable_p (res, region))
{
tree scev = scalar_evolution_in_region (region, loop, res);
if (evolution_function_is_invariant_p (scev, loop->num))
remove_invariant_phi (region, psi);
else
gsi_next (psi);
return false;
}
return true;
} | [
"static",
"bool",
"reduction_phi_p",
"(",
"sese",
"region",
",",
"gimple_stmt_iterator",
"*",
"psi",
")",
"{",
"loop_p",
"loop",
";",
"gimple",
"phi",
"=",
"gsi_stmt",
"(",
"*",
"psi",
")",
";",
"tree",
"res",
"=",
"gimple_phi_result",
"(",
"phi",
")",
";",
"loop",
"=",
"loop_containing_stmt",
"(",
"phi",
")",
";",
"if",
"(",
"simple_copy_phi_p",
"(",
"phi",
")",
")",
"{",
"remove_simple_copy_phi",
"(",
"psi",
")",
";",
"return",
"false",
";",
"}",
"if",
"(",
"scev_analyzable_p",
"(",
"res",
",",
"region",
")",
")",
"{",
"tree",
"scev",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"res",
")",
";",
"if",
"(",
"evolution_function_is_invariant_p",
"(",
"scev",
",",
"loop",
"->",
"num",
")",
")",
"remove_invariant_phi",
"(",
"region",
",",
"psi",
")",
";",
"else",
"gsi_next",
"(",
"psi",
")",
";",
"return",
"false",
";",
"}",
"return",
"true",
";",
"}"
] | Returns true when the phi node at position PSI is a reduction phi
node in REGION. | [
"Returns",
"true",
"when",
"the",
"phi",
"node",
"at",
"position",
"PSI",
"is",
"a",
"reduction",
"phi",
"node",
"in",
"REGION",
"."
] | [
"/* PRE introduces phi nodes like these, for an example,\n\t see id-5.f in the fortran graphite testsuite:\n\n\t # prephitmp.85_265 = PHI <prephitmp.85_258(33), prephitmp.85_265(18)>\n */",
"/* All the other cases are considered reductions. */"
] | [
{
"param": "region",
"type": "sese"
},
{
"param": "psi",
"type": "gimple_stmt_iterator"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "psi",
"type": "gimple_stmt_iterator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | remove_gbbs_in_scop | void | static void
remove_gbbs_in_scop (scop_p scop)
{
int i;
poly_bb_p pbb;
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
free_gimple_bb (PBB_BLACK_BOX (pbb));
} | /* Deletes all gimple bbs in SCOP. */ | Deletes all gimple bbs in SCOP. | [
"Deletes",
"all",
"gimple",
"bbs",
"in",
"SCOP",
"."
] | static void
remove_gbbs_in_scop (scop_p scop)
{
int i;
poly_bb_p pbb;
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
free_gimple_bb (PBB_BLACK_BOX (pbb));
} | [
"static",
"void",
"remove_gbbs_in_scop",
"(",
"scop_p",
"scop",
")",
"{",
"int",
"i",
";",
"poly_bb_p",
"pbb",
";",
"FOR_EACH_VEC_ELT",
"(",
"poly_bb_p",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"i",
",",
"pbb",
")",
"",
"free_gimple_bb",
"(",
"PBB_BLACK_BOX",
"(",
"pbb",
")",
")",
";",
"}"
] | Deletes all gimple bbs in SCOP. | [
"Deletes",
"all",
"gimple",
"bbs",
"in",
"SCOP",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | outermost_loop_in_sese_1 | loop_p | static loop_p
outermost_loop_in_sese_1 (sese region, basic_block bb)
{
loop_p nest = outermost_loop_in_sese (region, bb);
if (loop_in_sese_p (nest, region))
return nest;
/* When the basic block BB does not belong to a loop in the region,
return the first loop in the region. */
nest = nest->inner;
while (nest)
if (loop_in_sese_p (nest, region))
break;
else
nest = nest->next;
gcc_assert (nest);
return nest;
} | /* Same as outermost_loop_in_sese, returns the outermost loop
containing BB in REGION, but makes sure that the returned loop
belongs to the REGION, and so this returns the first loop in the
REGION when the loop containing BB does not belong to REGION. */ | Same as outermost_loop_in_sese, returns the outermost loop
containing BB in REGION, but makes sure that the returned loop
belongs to the REGION, and so this returns the first loop in the
REGION when the loop containing BB does not belong to REGION. | [
"Same",
"as",
"outermost_loop_in_sese",
"returns",
"the",
"outermost",
"loop",
"containing",
"BB",
"in",
"REGION",
"but",
"makes",
"sure",
"that",
"the",
"returned",
"loop",
"belongs",
"to",
"the",
"REGION",
"and",
"so",
"this",
"returns",
"the",
"first",
"loop",
"in",
"the",
"REGION",
"when",
"the",
"loop",
"containing",
"BB",
"does",
"not",
"belong",
"to",
"REGION",
"."
] | static loop_p
outermost_loop_in_sese_1 (sese region, basic_block bb)
{
loop_p nest = outermost_loop_in_sese (region, bb);
if (loop_in_sese_p (nest, region))
return nest;
nest = nest->inner;
while (nest)
if (loop_in_sese_p (nest, region))
break;
else
nest = nest->next;
gcc_assert (nest);
return nest;
} | [
"static",
"loop_p",
"outermost_loop_in_sese_1",
"(",
"sese",
"region",
",",
"basic_block",
"bb",
")",
"{",
"loop_p",
"nest",
"=",
"outermost_loop_in_sese",
"(",
"region",
",",
"bb",
")",
";",
"if",
"(",
"loop_in_sese_p",
"(",
"nest",
",",
"region",
")",
")",
"return",
"nest",
";",
"nest",
"=",
"nest",
"->",
"inner",
";",
"while",
"(",
"nest",
")",
"if",
"(",
"loop_in_sese_p",
"(",
"nest",
",",
"region",
")",
")",
"break",
";",
"else",
"nest",
"=",
"nest",
"->",
"next",
";",
"gcc_assert",
"(",
"nest",
")",
";",
"return",
"nest",
";",
"}"
] | Same as outermost_loop_in_sese, returns the outermost loop
containing BB in REGION, but makes sure that the returned loop
belongs to the REGION, and so this returns the first loop in the
REGION when the loop containing BB does not belong to REGION. | [
"Same",
"as",
"outermost_loop_in_sese",
"returns",
"the",
"outermost",
"loop",
"containing",
"BB",
"in",
"REGION",
"but",
"makes",
"sure",
"that",
"the",
"returned",
"loop",
"belongs",
"to",
"the",
"REGION",
"and",
"so",
"this",
"returns",
"the",
"first",
"loop",
"in",
"the",
"REGION",
"when",
"the",
"loop",
"containing",
"BB",
"does",
"not",
"belong",
"to",
"REGION",
"."
] | [
"/* When the basic block BB does not belong to a loop in the region,\n return the first loop in the region. */"
] | [
{
"param": "region",
"type": "sese"
},
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | try_generate_gimple_bb | gimple_bb_p | static gimple_bb_p
try_generate_gimple_bb (scop_p scop, basic_block bb)
{
VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 5);
sese region = SCOP_REGION (scop);
loop_p nest = outermost_loop_in_sese_1 (region, bb);
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
loop_p loop;
if (is_gimple_debug (stmt))
continue;
loop = loop_containing_stmt (stmt);
if (!loop_in_sese_p (loop, region))
loop = nest;
graphite_find_data_references_in_stmt (nest, loop, stmt, &drs);
}
return new_gimple_bb (bb, drs);
} | /* Generates a polyhedral black box only if the bb contains interesting
information. */ | Generates a polyhedral black box only if the bb contains interesting
information. | [
"Generates",
"a",
"polyhedral",
"black",
"box",
"only",
"if",
"the",
"bb",
"contains",
"interesting",
"information",
"."
] | static gimple_bb_p
try_generate_gimple_bb (scop_p scop, basic_block bb)
{
VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 5);
sese region = SCOP_REGION (scop);
loop_p nest = outermost_loop_in_sese_1 (region, bb);
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
gimple stmt = gsi_stmt (gsi);
loop_p loop;
if (is_gimple_debug (stmt))
continue;
loop = loop_containing_stmt (stmt);
if (!loop_in_sese_p (loop, region))
loop = nest;
graphite_find_data_references_in_stmt (nest, loop, stmt, &drs);
}
return new_gimple_bb (bb, drs);
} | [
"static",
"gimple_bb_p",
"try_generate_gimple_bb",
"(",
"scop_p",
"scop",
",",
"basic_block",
"bb",
")",
"{",
"VEC",
"(",
"data_reference_p",
",",
"heap",
")",
"*",
"drs",
"=",
"VEC_alloc",
"(",
"data_reference_p",
",",
"heap",
",",
"5",
")",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"loop_p",
"nest",
"=",
"outermost_loop_in_sese_1",
"(",
"region",
",",
"bb",
")",
";",
"gimple_stmt_iterator",
"gsi",
";",
"for",
"(",
"gsi",
"=",
"gsi_start_bb",
"(",
"bb",
")",
";",
"!",
"gsi_end_p",
"(",
"gsi",
")",
";",
"gsi_next",
"(",
"&",
"gsi",
")",
")",
"{",
"gimple",
"stmt",
"=",
"gsi_stmt",
"(",
"gsi",
")",
";",
"loop_p",
"loop",
";",
"if",
"(",
"is_gimple_debug",
"(",
"stmt",
")",
")",
"continue",
";",
"loop",
"=",
"loop_containing_stmt",
"(",
"stmt",
")",
";",
"if",
"(",
"!",
"loop_in_sese_p",
"(",
"loop",
",",
"region",
")",
")",
"loop",
"=",
"nest",
";",
"graphite_find_data_references_in_stmt",
"(",
"nest",
",",
"loop",
",",
"stmt",
",",
"&",
"drs",
")",
";",
"}",
"return",
"new_gimple_bb",
"(",
"bb",
",",
"drs",
")",
";",
"}"
] | Generates a polyhedral black box only if the bb contains interesting
information. | [
"Generates",
"a",
"polyhedral",
"black",
"box",
"only",
"if",
"the",
"bb",
"contains",
"interesting",
"information",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | all_non_dominated_preds_marked_p | bool | static bool
all_non_dominated_preds_marked_p (basic_block bb, sbitmap map)
{
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
if (!TEST_BIT (map, e->src->index)
&& !dominated_by_p (CDI_DOMINATORS, e->src, bb))
return false;
return true;
} | /* Returns true if all predecessors of BB, that are not dominated by BB, are
marked in MAP. The predecessors dominated by BB are loop latches and will
be handled after BB. */ | Returns true if all predecessors of BB, that are not dominated by BB, are
marked in MAP. The predecessors dominated by BB are loop latches and will
be handled after BB. | [
"Returns",
"true",
"if",
"all",
"predecessors",
"of",
"BB",
"that",
"are",
"not",
"dominated",
"by",
"BB",
"are",
"marked",
"in",
"MAP",
".",
"The",
"predecessors",
"dominated",
"by",
"BB",
"are",
"loop",
"latches",
"and",
"will",
"be",
"handled",
"after",
"BB",
"."
] | static bool
all_non_dominated_preds_marked_p (basic_block bb, sbitmap map)
{
edge e;
edge_iterator ei;
FOR_EACH_EDGE (e, ei, bb->preds)
if (!TEST_BIT (map, e->src->index)
&& !dominated_by_p (CDI_DOMINATORS, e->src, bb))
return false;
return true;
} | [
"static",
"bool",
"all_non_dominated_preds_marked_p",
"(",
"basic_block",
"bb",
",",
"sbitmap",
"map",
")",
"{",
"edge",
"e",
";",
"edge_iterator",
"ei",
";",
"FOR_EACH_EDGE",
"(",
"e",
",",
"ei",
",",
"bb",
"->",
"preds",
")",
"",
"if",
"(",
"!",
"TEST_BIT",
"(",
"map",
",",
"e",
"->",
"src",
"->",
"index",
")",
"&&",
"!",
"dominated_by_p",
"(",
"CDI_DOMINATORS",
",",
"e",
"->",
"src",
",",
"bb",
")",
")",
"return",
"false",
";",
"return",
"true",
";",
"}"
] | Returns true if all predecessors of BB, that are not dominated by BB, are
marked in MAP. | [
"Returns",
"true",
"if",
"all",
"predecessors",
"of",
"BB",
"that",
"are",
"not",
"dominated",
"by",
"BB",
"are",
"marked",
"in",
"MAP",
"."
] | [] | [
{
"param": "bb",
"type": "basic_block"
},
{
"param": "map",
"type": "sbitmap"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "map",
"type": "sbitmap",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | compare_bb_depths | int | static int
compare_bb_depths (const void *p1, const void *p2)
{
const_basic_block const bb1 = *(const_basic_block const*)p1;
const_basic_block const bb2 = *(const_basic_block const*)p2;
int d1 = loop_depth (bb1->loop_father);
int d2 = loop_depth (bb2->loop_father);
if (d1 < d2)
return 1;
if (d1 > d2)
return -1;
return 0;
} | /* Compare the depth of two basic_block's P1 and P2. */ | Compare the depth of two basic_block's P1 and P2. | [
"Compare",
"the",
"depth",
"of",
"two",
"basic_block",
"'",
"s",
"P1",
"and",
"P2",
"."
] | static int
compare_bb_depths (const void *p1, const void *p2)
{
const_basic_block const bb1 = *(const_basic_block const*)p1;
const_basic_block const bb2 = *(const_basic_block const*)p2;
int d1 = loop_depth (bb1->loop_father);
int d2 = loop_depth (bb2->loop_father);
if (d1 < d2)
return 1;
if (d1 > d2)
return -1;
return 0;
} | [
"static",
"int",
"compare_bb_depths",
"(",
"const",
"void",
"*",
"p1",
",",
"const",
"void",
"*",
"p2",
")",
"{",
"const_basic_block",
"const",
"bb1",
"=",
"*",
"(",
"const_basic_block",
"const",
"*",
")",
"p1",
";",
"const_basic_block",
"const",
"bb2",
"=",
"*",
"(",
"const_basic_block",
"const",
"*",
")",
"p2",
";",
"int",
"d1",
"=",
"loop_depth",
"(",
"bb1",
"->",
"loop_father",
")",
";",
"int",
"d2",
"=",
"loop_depth",
"(",
"bb2",
"->",
"loop_father",
")",
";",
"if",
"(",
"d1",
"<",
"d2",
")",
"return",
"1",
";",
"if",
"(",
"d1",
">",
"d2",
")",
"return",
"-1",
";",
"return",
"0",
";",
"}"
] | Compare the depth of two basic_block's P1 and P2. | [
"Compare",
"the",
"depth",
"of",
"two",
"basic_block",
"'",
"s",
"P1",
"and",
"P2",
"."
] | [] | [
{
"param": "p1",
"type": "void"
},
{
"param": "p2",
"type": "void"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "p1",
"type": "void",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "p2",
"type": "void",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_scop_bbs_1 | void | static void
build_scop_bbs_1 (scop_p scop, sbitmap visited, basic_block bb)
{
sese region = SCOP_REGION (scop);
VEC (basic_block, heap) *dom;
poly_bb_p pbb;
if (TEST_BIT (visited, bb->index)
|| !bb_in_sese_p (bb, region))
return;
pbb = new_poly_bb (scop, try_generate_gimple_bb (scop, bb));
VEC_safe_push (poly_bb_p, heap, SCOP_BBS (scop), pbb);
SET_BIT (visited, bb->index);
dom = get_dominated_by (CDI_DOMINATORS, bb);
if (dom == NULL)
return;
graphite_sort_dominated_info (dom);
while (!VEC_empty (basic_block, dom))
{
int i;
basic_block dom_bb;
FOR_EACH_VEC_ELT (basic_block, dom, i, dom_bb)
if (all_non_dominated_preds_marked_p (dom_bb, visited))
{
build_scop_bbs_1 (scop, visited, dom_bb);
VEC_unordered_remove (basic_block, dom, i);
break;
}
}
VEC_free (basic_block, heap, dom);
} | /* Recursive helper function for build_scops_bbs. */ | Recursive helper function for build_scops_bbs. | [
"Recursive",
"helper",
"function",
"for",
"build_scops_bbs",
"."
] | static void
build_scop_bbs_1 (scop_p scop, sbitmap visited, basic_block bb)
{
sese region = SCOP_REGION (scop);
VEC (basic_block, heap) *dom;
poly_bb_p pbb;
if (TEST_BIT (visited, bb->index)
|| !bb_in_sese_p (bb, region))
return;
pbb = new_poly_bb (scop, try_generate_gimple_bb (scop, bb));
VEC_safe_push (poly_bb_p, heap, SCOP_BBS (scop), pbb);
SET_BIT (visited, bb->index);
dom = get_dominated_by (CDI_DOMINATORS, bb);
if (dom == NULL)
return;
graphite_sort_dominated_info (dom);
while (!VEC_empty (basic_block, dom))
{
int i;
basic_block dom_bb;
FOR_EACH_VEC_ELT (basic_block, dom, i, dom_bb)
if (all_non_dominated_preds_marked_p (dom_bb, visited))
{
build_scop_bbs_1 (scop, visited, dom_bb);
VEC_unordered_remove (basic_block, dom, i);
break;
}
}
VEC_free (basic_block, heap, dom);
} | [
"static",
"void",
"build_scop_bbs_1",
"(",
"scop_p",
"scop",
",",
"sbitmap",
"visited",
",",
"basic_block",
"bb",
")",
"{",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"VEC",
"(",
"basic_block",
",",
"heap",
")",
"*",
"dom",
";",
"poly_bb_p",
"pbb",
";",
"if",
"(",
"TEST_BIT",
"(",
"visited",
",",
"bb",
"->",
"index",
")",
"||",
"!",
"bb_in_sese_p",
"(",
"bb",
",",
"region",
")",
")",
"return",
";",
"pbb",
"=",
"new_poly_bb",
"(",
"scop",
",",
"try_generate_gimple_bb",
"(",
"scop",
",",
"bb",
")",
")",
";",
"VEC_safe_push",
"(",
"poly_bb_p",
",",
"heap",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"pbb",
")",
";",
"SET_BIT",
"(",
"visited",
",",
"bb",
"->",
"index",
")",
";",
"dom",
"=",
"get_dominated_by",
"(",
"CDI_DOMINATORS",
",",
"bb",
")",
";",
"if",
"(",
"dom",
"==",
"NULL",
")",
"return",
";",
"graphite_sort_dominated_info",
"(",
"dom",
")",
";",
"while",
"(",
"!",
"VEC_empty",
"(",
"basic_block",
",",
"dom",
")",
")",
"{",
"int",
"i",
";",
"basic_block",
"dom_bb",
";",
"FOR_EACH_VEC_ELT",
"(",
"basic_block",
",",
"dom",
",",
"i",
",",
"dom_bb",
")",
"",
"if",
"(",
"all_non_dominated_preds_marked_p",
"(",
"dom_bb",
",",
"visited",
")",
")",
"{",
"build_scop_bbs_1",
"(",
"scop",
",",
"visited",
",",
"dom_bb",
")",
";",
"VEC_unordered_remove",
"(",
"basic_block",
",",
"dom",
",",
"i",
")",
";",
"break",
";",
"}",
"}",
"VEC_free",
"(",
"basic_block",
",",
"heap",
",",
"dom",
")",
";",
"}"
] | Recursive helper function for build_scops_bbs. | [
"Recursive",
"helper",
"function",
"for",
"build_scops_bbs",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "visited",
"type": "sbitmap"
},
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "visited",
"type": "sbitmap",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_scop_bbs | void | static void
build_scop_bbs (scop_p scop)
{
sbitmap visited = sbitmap_alloc (last_basic_block);
sese region = SCOP_REGION (scop);
sbitmap_zero (visited);
build_scop_bbs_1 (scop, visited, SESE_ENTRY_BB (region));
sbitmap_free (visited);
} | /* Gather the basic blocks belonging to the SCOP. */ | Gather the basic blocks belonging to the SCOP. | [
"Gather",
"the",
"basic",
"blocks",
"belonging",
"to",
"the",
"SCOP",
"."
] | static void
build_scop_bbs (scop_p scop)
{
sbitmap visited = sbitmap_alloc (last_basic_block);
sese region = SCOP_REGION (scop);
sbitmap_zero (visited);
build_scop_bbs_1 (scop, visited, SESE_ENTRY_BB (region));
sbitmap_free (visited);
} | [
"static",
"void",
"build_scop_bbs",
"(",
"scop_p",
"scop",
")",
"{",
"sbitmap",
"visited",
"=",
"sbitmap_alloc",
"(",
"last_basic_block",
")",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"sbitmap_zero",
"(",
"visited",
")",
";",
"build_scop_bbs_1",
"(",
"scop",
",",
"visited",
",",
"SESE_ENTRY_BB",
"(",
"region",
")",
")",
";",
"sbitmap_free",
"(",
"visited",
")",
";",
"}"
] | Gather the basic blocks belonging to the SCOP. | [
"Gather",
"the",
"basic",
"blocks",
"belonging",
"to",
"the",
"SCOP",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_pbb_scattering_polyhedrons | void | static void
build_pbb_scattering_polyhedrons (ppl_Linear_Expression_t static_schedule,
poly_bb_p pbb, int scattering_dimensions)
{
int i;
scop_p scop = PBB_SCOP (pbb);
int nb_iterators = pbb_dim_iter_domain (pbb);
int used_scattering_dimensions = nb_iterators * 2 + 1;
int nb_params = scop_nb_params (scop);
ppl_Coefficient_t c;
ppl_dimension_type dim = scattering_dimensions + nb_iterators + nb_params;
mpz_t v;
gcc_assert (scattering_dimensions >= used_scattering_dimensions);
mpz_init (v);
ppl_new_Coefficient (&c);
PBB_TRANSFORMED (pbb) = poly_scattering_new ();
ppl_new_C_Polyhedron_from_space_dimension
(&PBB_TRANSFORMED_SCATTERING (pbb), dim, 0);
PBB_NB_SCATTERING_TRANSFORM (pbb) = scattering_dimensions;
for (i = 0; i < scattering_dimensions; i++)
{
ppl_Constraint_t cstr;
ppl_Linear_Expression_t expr;
ppl_new_Linear_Expression_with_dimension (&expr, dim);
mpz_set_si (v, 1);
ppl_assign_Coefficient_from_mpz_t (c, v);
ppl_Linear_Expression_add_to_coefficient (expr, i, c);
/* Textual order inside this loop. */
if ((i % 2) == 0)
{
ppl_Linear_Expression_coefficient (static_schedule, i / 2, c);
ppl_Coefficient_to_mpz_t (c, v);
mpz_neg (v, v);
ppl_assign_Coefficient_from_mpz_t (c, v);
ppl_Linear_Expression_add_to_inhomogeneous (expr, c);
}
/* Iterations of this loop. */
else /* if ((i % 2) == 1) */
{
int loop = (i - 1) / 2;
mpz_set_si (v, -1);
ppl_assign_Coefficient_from_mpz_t (c, v);
ppl_Linear_Expression_add_to_coefficient
(expr, scattering_dimensions + loop, c);
}
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (PBB_TRANSFORMED_SCATTERING (pbb), cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
}
mpz_clear (v);
ppl_delete_Coefficient (c);
PBB_ORIGINAL (pbb) = poly_scattering_copy (PBB_TRANSFORMED (pbb));
} | /* Converts the STATIC_SCHEDULE of PBB into a scattering polyhedron.
We generate SCATTERING_DIMENSIONS scattering dimensions.
CLooG 0.15.0 and previous versions require, that all
scattering functions of one CloogProgram have the same number of
scattering dimensions, therefore we allow to specify it. This
should be removed in future versions of CLooG.
The scattering polyhedron consists of these dimensions: scattering,
loop_iterators, parameters.
Example:
| scattering_dimensions = 5
| used_scattering_dimensions = 3
| nb_iterators = 1
| scop_nb_params = 2
|
| Schedule:
| i
| 4 5
|
| Scattering polyhedron:
|
| scattering: {s1, s2, s3, s4, s5}
| loop_iterators: {i}
| parameters: {p1, p2}
|
| s1 s2 s3 s4 s5 i p1 p2 1
| 1 0 0 0 0 0 0 0 -4 = 0
| 0 1 0 0 0 -1 0 0 0 = 0
| 0 0 1 0 0 0 0 0 -5 = 0 */ | Converts the STATIC_SCHEDULE of PBB into a scattering polyhedron.
We generate SCATTERING_DIMENSIONS scattering dimensions.
CLooG 0.15.0 and previous versions require, that all
scattering functions of one CloogProgram have the same number of
scattering dimensions, therefore we allow to specify it. This
should be removed in future versions of CLooG.
The scattering polyhedron consists of these dimensions: scattering,
loop_iterators, parameters.
| [
"Converts",
"the",
"STATIC_SCHEDULE",
"of",
"PBB",
"into",
"a",
"scattering",
"polyhedron",
".",
"We",
"generate",
"SCATTERING_DIMENSIONS",
"scattering",
"dimensions",
".",
"CLooG",
"0",
".",
"15",
".",
"0",
"and",
"previous",
"versions",
"require",
"that",
"all",
"scattering",
"functions",
"of",
"one",
"CloogProgram",
"have",
"the",
"same",
"number",
"of",
"scattering",
"dimensions",
"therefore",
"we",
"allow",
"to",
"specify",
"it",
".",
"This",
"should",
"be",
"removed",
"in",
"future",
"versions",
"of",
"CLooG",
".",
"The",
"scattering",
"polyhedron",
"consists",
"of",
"these",
"dimensions",
":",
"scattering",
"loop_iterators",
"parameters",
"."
] | static void
build_pbb_scattering_polyhedrons (ppl_Linear_Expression_t static_schedule,
poly_bb_p pbb, int scattering_dimensions)
{
int i;
scop_p scop = PBB_SCOP (pbb);
int nb_iterators = pbb_dim_iter_domain (pbb);
int used_scattering_dimensions = nb_iterators * 2 + 1;
int nb_params = scop_nb_params (scop);
ppl_Coefficient_t c;
ppl_dimension_type dim = scattering_dimensions + nb_iterators + nb_params;
mpz_t v;
gcc_assert (scattering_dimensions >= used_scattering_dimensions);
mpz_init (v);
ppl_new_Coefficient (&c);
PBB_TRANSFORMED (pbb) = poly_scattering_new ();
ppl_new_C_Polyhedron_from_space_dimension
(&PBB_TRANSFORMED_SCATTERING (pbb), dim, 0);
PBB_NB_SCATTERING_TRANSFORM (pbb) = scattering_dimensions;
for (i = 0; i < scattering_dimensions; i++)
{
ppl_Constraint_t cstr;
ppl_Linear_Expression_t expr;
ppl_new_Linear_Expression_with_dimension (&expr, dim);
mpz_set_si (v, 1);
ppl_assign_Coefficient_from_mpz_t (c, v);
ppl_Linear_Expression_add_to_coefficient (expr, i, c);
if ((i % 2) == 0)
{
ppl_Linear_Expression_coefficient (static_schedule, i / 2, c);
ppl_Coefficient_to_mpz_t (c, v);
mpz_neg (v, v);
ppl_assign_Coefficient_from_mpz_t (c, v);
ppl_Linear_Expression_add_to_inhomogeneous (expr, c);
}
else
{
int loop = (i - 1) / 2;
mpz_set_si (v, -1);
ppl_assign_Coefficient_from_mpz_t (c, v);
ppl_Linear_Expression_add_to_coefficient
(expr, scattering_dimensions + loop, c);
}
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (PBB_TRANSFORMED_SCATTERING (pbb), cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
}
mpz_clear (v);
ppl_delete_Coefficient (c);
PBB_ORIGINAL (pbb) = poly_scattering_copy (PBB_TRANSFORMED (pbb));
} | [
"static",
"void",
"build_pbb_scattering_polyhedrons",
"(",
"ppl_Linear_Expression_t",
"static_schedule",
",",
"poly_bb_p",
"pbb",
",",
"int",
"scattering_dimensions",
")",
"{",
"int",
"i",
";",
"scop_p",
"scop",
"=",
"PBB_SCOP",
"(",
"pbb",
")",
";",
"int",
"nb_iterators",
"=",
"pbb_dim_iter_domain",
"(",
"pbb",
")",
";",
"int",
"used_scattering_dimensions",
"=",
"nb_iterators",
"*",
"2",
"+",
"1",
";",
"int",
"nb_params",
"=",
"scop_nb_params",
"(",
"scop",
")",
";",
"ppl_Coefficient_t",
"c",
";",
"ppl_dimension_type",
"dim",
"=",
"scattering_dimensions",
"+",
"nb_iterators",
"+",
"nb_params",
";",
"mpz_t",
"v",
";",
"gcc_assert",
"(",
"scattering_dimensions",
">=",
"used_scattering_dimensions",
")",
";",
"mpz_init",
"(",
"v",
")",
";",
"ppl_new_Coefficient",
"(",
"&",
"c",
")",
";",
"PBB_TRANSFORMED",
"(",
"pbb",
")",
"=",
"poly_scattering_new",
"(",
")",
";",
"ppl_new_C_Polyhedron_from_space_dimension",
"(",
"&",
"PBB_TRANSFORMED_SCATTERING",
"(",
"pbb",
")",
",",
"dim",
",",
"0",
")",
";",
"PBB_NB_SCATTERING_TRANSFORM",
"(",
"pbb",
")",
"=",
"scattering_dimensions",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"scattering_dimensions",
";",
"i",
"++",
")",
"{",
"ppl_Constraint_t",
"cstr",
";",
"ppl_Linear_Expression_t",
"expr",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"expr",
",",
"dim",
")",
";",
"mpz_set_si",
"(",
"v",
",",
"1",
")",
";",
"ppl_assign_Coefficient_from_mpz_t",
"(",
"c",
",",
"v",
")",
";",
"ppl_Linear_Expression_add_to_coefficient",
"(",
"expr",
",",
"i",
",",
"c",
")",
";",
"if",
"(",
"(",
"i",
"%",
"2",
")",
"==",
"0",
")",
"{",
"ppl_Linear_Expression_coefficient",
"(",
"static_schedule",
",",
"i",
"/",
"2",
",",
"c",
")",
";",
"ppl_Coefficient_to_mpz_t",
"(",
"c",
",",
"v",
")",
";",
"mpz_neg",
"(",
"v",
",",
"v",
")",
";",
"ppl_assign_Coefficient_from_mpz_t",
"(",
"c",
",",
"v",
")",
";",
"ppl_Linear_Expression_add_to_inhomogeneous",
"(",
"expr",
",",
"c",
")",
";",
"}",
"else",
"{",
"int",
"loop",
"=",
"(",
"i",
"-",
"1",
")",
"/",
"2",
";",
"mpz_set_si",
"(",
"v",
",",
"-1",
")",
";",
"ppl_assign_Coefficient_from_mpz_t",
"(",
"c",
",",
"v",
")",
";",
"ppl_Linear_Expression_add_to_coefficient",
"(",
"expr",
",",
"scattering_dimensions",
"+",
"loop",
",",
"c",
")",
";",
"}",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"expr",
",",
"PPL_CONSTRAINT_TYPE_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"PBB_TRANSFORMED_SCATTERING",
"(",
"pbb",
")",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"expr",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}",
"mpz_clear",
"(",
"v",
")",
";",
"ppl_delete_Coefficient",
"(",
"c",
")",
";",
"PBB_ORIGINAL",
"(",
"pbb",
")",
"=",
"poly_scattering_copy",
"(",
"PBB_TRANSFORMED",
"(",
"pbb",
")",
")",
";",
"}"
] | Converts the STATIC_SCHEDULE of PBB into a scattering polyhedron. | [
"Converts",
"the",
"STATIC_SCHEDULE",
"of",
"PBB",
"into",
"a",
"scattering",
"polyhedron",
"."
] | [
"/* Textual order inside this loop. */",
"/* Iterations of this loop. */",
"/* if ((i % 2) == 1) */"
] | [
{
"param": "static_schedule",
"type": "ppl_Linear_Expression_t"
},
{
"param": "pbb",
"type": "poly_bb_p"
},
{
"param": "scattering_dimensions",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "static_schedule",
"type": "ppl_Linear_Expression_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "scattering_dimensions",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | add_value_to_dim | void | static void
add_value_to_dim (ppl_dimension_type d, ppl_Linear_Expression_t expr,
mpz_t k)
{
mpz_t val;
ppl_Coefficient_t coef;
ppl_new_Coefficient (&coef);
ppl_Linear_Expression_coefficient (expr, d, coef);
mpz_init (val);
ppl_Coefficient_to_mpz_t (coef, val);
mpz_add (val, val, k);
ppl_assign_Coefficient_from_mpz_t (coef, val);
ppl_Linear_Expression_add_to_coefficient (expr, d, coef);
mpz_clear (val);
ppl_delete_Coefficient (coef);
} | /* Add the value K to the dimension D of the linear expression EXPR. */ | Add the value K to the dimension D of the linear expression EXPR. | [
"Add",
"the",
"value",
"K",
"to",
"the",
"dimension",
"D",
"of",
"the",
"linear",
"expression",
"EXPR",
"."
] | static void
add_value_to_dim (ppl_dimension_type d, ppl_Linear_Expression_t expr,
mpz_t k)
{
mpz_t val;
ppl_Coefficient_t coef;
ppl_new_Coefficient (&coef);
ppl_Linear_Expression_coefficient (expr, d, coef);
mpz_init (val);
ppl_Coefficient_to_mpz_t (coef, val);
mpz_add (val, val, k);
ppl_assign_Coefficient_from_mpz_t (coef, val);
ppl_Linear_Expression_add_to_coefficient (expr, d, coef);
mpz_clear (val);
ppl_delete_Coefficient (coef);
} | [
"static",
"void",
"add_value_to_dim",
"(",
"ppl_dimension_type",
"d",
",",
"ppl_Linear_Expression_t",
"expr",
",",
"mpz_t",
"k",
")",
"{",
"mpz_t",
"val",
";",
"ppl_Coefficient_t",
"coef",
";",
"ppl_new_Coefficient",
"(",
"&",
"coef",
")",
";",
"ppl_Linear_Expression_coefficient",
"(",
"expr",
",",
"d",
",",
"coef",
")",
";",
"mpz_init",
"(",
"val",
")",
";",
"ppl_Coefficient_to_mpz_t",
"(",
"coef",
",",
"val",
")",
";",
"mpz_add",
"(",
"val",
",",
"val",
",",
"k",
")",
";",
"ppl_assign_Coefficient_from_mpz_t",
"(",
"coef",
",",
"val",
")",
";",
"ppl_Linear_Expression_add_to_coefficient",
"(",
"expr",
",",
"d",
",",
"coef",
")",
";",
"mpz_clear",
"(",
"val",
")",
";",
"ppl_delete_Coefficient",
"(",
"coef",
")",
";",
"}"
] | Add the value K to the dimension D of the linear expression EXPR. | [
"Add",
"the",
"value",
"K",
"to",
"the",
"dimension",
"D",
"of",
"the",
"linear",
"expression",
"EXPR",
"."
] | [] | [
{
"param": "d",
"type": "ppl_dimension_type"
},
{
"param": "expr",
"type": "ppl_Linear_Expression_t"
},
{
"param": "k",
"type": "mpz_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "d",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "expr",
"type": "ppl_Linear_Expression_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "k",
"type": "mpz_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | scan_tree_for_params_right_scev | void | static void
scan_tree_for_params_right_scev (sese s, tree e, int var,
ppl_Linear_Expression_t expr)
{
if (expr)
{
loop_p loop = get_loop (var);
ppl_dimension_type l = sese_loop_depth (s, loop) - 1;
mpz_t val;
/* Scalar evolutions should happen in the sese region. */
gcc_assert (sese_loop_depth (s, loop) > 0);
/* We can not deal with parametric strides like:
| p = parameter;
|
| for i:
| a [i * p] = ... */
gcc_assert (TREE_CODE (e) == INTEGER_CST);
mpz_init (val);
tree_int_to_gmp (e, val);
add_value_to_dim (l, expr, val);
mpz_clear (val);
}
} | /* In the context of scop S, scan E, the right hand side of a scalar
evolution function in loop VAR, and translate it to a linear
expression EXPR. */ | In the context of scop S, scan E, the right hand side of a scalar
evolution function in loop VAR, and translate it to a linear
expression EXPR. | [
"In",
"the",
"context",
"of",
"scop",
"S",
"scan",
"E",
"the",
"right",
"hand",
"side",
"of",
"a",
"scalar",
"evolution",
"function",
"in",
"loop",
"VAR",
"and",
"translate",
"it",
"to",
"a",
"linear",
"expression",
"EXPR",
"."
] | static void
scan_tree_for_params_right_scev (sese s, tree e, int var,
ppl_Linear_Expression_t expr)
{
if (expr)
{
loop_p loop = get_loop (var);
ppl_dimension_type l = sese_loop_depth (s, loop) - 1;
mpz_t val;
gcc_assert (sese_loop_depth (s, loop) > 0);
gcc_assert (TREE_CODE (e) == INTEGER_CST);
mpz_init (val);
tree_int_to_gmp (e, val);
add_value_to_dim (l, expr, val);
mpz_clear (val);
}
} | [
"static",
"void",
"scan_tree_for_params_right_scev",
"(",
"sese",
"s",
",",
"tree",
"e",
",",
"int",
"var",
",",
"ppl_Linear_Expression_t",
"expr",
")",
"{",
"if",
"(",
"expr",
")",
"{",
"loop_p",
"loop",
"=",
"get_loop",
"(",
"var",
")",
";",
"ppl_dimension_type",
"l",
"=",
"sese_loop_depth",
"(",
"s",
",",
"loop",
")",
"-",
"1",
";",
"mpz_t",
"val",
";",
"gcc_assert",
"(",
"sese_loop_depth",
"(",
"s",
",",
"loop",
")",
">",
"0",
")",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"e",
")",
"==",
"INTEGER_CST",
")",
";",
"mpz_init",
"(",
"val",
")",
";",
"tree_int_to_gmp",
"(",
"e",
",",
"val",
")",
";",
"add_value_to_dim",
"(",
"l",
",",
"expr",
",",
"val",
")",
";",
"mpz_clear",
"(",
"val",
")",
";",
"}",
"}"
] | In the context of scop S, scan E, the right hand side of a scalar
evolution function in loop VAR, and translate it to a linear
expression EXPR. | [
"In",
"the",
"context",
"of",
"scop",
"S",
"scan",
"E",
"the",
"right",
"hand",
"side",
"of",
"a",
"scalar",
"evolution",
"function",
"in",
"loop",
"VAR",
"and",
"translate",
"it",
"to",
"a",
"linear",
"expression",
"EXPR",
"."
] | [
"/* Scalar evolutions should happen in the sese region. */",
"/* We can not deal with parametric strides like:\n\n | p = parameter;\n |\n | for i:\n | a [i * p] = ... */"
] | [
{
"param": "s",
"type": "sese"
},
{
"param": "e",
"type": "tree"
},
{
"param": "var",
"type": "int"
},
{
"param": "expr",
"type": "ppl_Linear_Expression_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "s",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "e",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "var",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "expr",
"type": "ppl_Linear_Expression_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | scan_tree_for_params_int | void | static void
scan_tree_for_params_int (tree cst, ppl_Linear_Expression_t expr, mpz_t k)
{
mpz_t val;
ppl_Coefficient_t coef;
tree type = TREE_TYPE (cst);
mpz_init (val);
/* Necessary to not get "-1 = 2^n - 1". */
mpz_set_double_int (val, double_int_sext (tree_to_double_int (cst),
TYPE_PRECISION (type)), false);
mpz_mul (val, val, k);
ppl_new_Coefficient (&coef);
ppl_assign_Coefficient_from_mpz_t (coef, val);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
mpz_clear (val);
ppl_delete_Coefficient (coef);
} | /* Scan the integer constant CST, and add it to the inhomogeneous part of the
linear expression EXPR. K is the multiplier of the constant. */ | Scan the integer constant CST, and add it to the inhomogeneous part of the
linear expression EXPR. K is the multiplier of the constant. | [
"Scan",
"the",
"integer",
"constant",
"CST",
"and",
"add",
"it",
"to",
"the",
"inhomogeneous",
"part",
"of",
"the",
"linear",
"expression",
"EXPR",
".",
"K",
"is",
"the",
"multiplier",
"of",
"the",
"constant",
"."
] | static void
scan_tree_for_params_int (tree cst, ppl_Linear_Expression_t expr, mpz_t k)
{
mpz_t val;
ppl_Coefficient_t coef;
tree type = TREE_TYPE (cst);
mpz_init (val);
mpz_set_double_int (val, double_int_sext (tree_to_double_int (cst),
TYPE_PRECISION (type)), false);
mpz_mul (val, val, k);
ppl_new_Coefficient (&coef);
ppl_assign_Coefficient_from_mpz_t (coef, val);
ppl_Linear_Expression_add_to_inhomogeneous (expr, coef);
mpz_clear (val);
ppl_delete_Coefficient (coef);
} | [
"static",
"void",
"scan_tree_for_params_int",
"(",
"tree",
"cst",
",",
"ppl_Linear_Expression_t",
"expr",
",",
"mpz_t",
"k",
")",
"{",
"mpz_t",
"val",
";",
"ppl_Coefficient_t",
"coef",
";",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"cst",
")",
";",
"mpz_init",
"(",
"val",
")",
";",
"mpz_set_double_int",
"(",
"val",
",",
"double_int_sext",
"(",
"tree_to_double_int",
"(",
"cst",
")",
",",
"TYPE_PRECISION",
"(",
"type",
")",
")",
",",
"false",
")",
";",
"mpz_mul",
"(",
"val",
",",
"val",
",",
"k",
")",
";",
"ppl_new_Coefficient",
"(",
"&",
"coef",
")",
";",
"ppl_assign_Coefficient_from_mpz_t",
"(",
"coef",
",",
"val",
")",
";",
"ppl_Linear_Expression_add_to_inhomogeneous",
"(",
"expr",
",",
"coef",
")",
";",
"mpz_clear",
"(",
"val",
")",
";",
"ppl_delete_Coefficient",
"(",
"coef",
")",
";",
"}"
] | Scan the integer constant CST, and add it to the inhomogeneous part of the
linear expression EXPR. | [
"Scan",
"the",
"integer",
"constant",
"CST",
"and",
"add",
"it",
"to",
"the",
"inhomogeneous",
"part",
"of",
"the",
"linear",
"expression",
"EXPR",
"."
] | [
"/* Necessary to not get \"-1 = 2^n - 1\". */"
] | [
{
"param": "cst",
"type": "tree"
},
{
"param": "expr",
"type": "ppl_Linear_Expression_t"
},
{
"param": "k",
"type": "mpz_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "cst",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "expr",
"type": "ppl_Linear_Expression_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "k",
"type": "mpz_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | parameter_index_in_region_1 | int | static inline int
parameter_index_in_region_1 (tree name, sese region)
{
int i;
tree p;
gcc_assert (TREE_CODE (name) == SSA_NAME);
FOR_EACH_VEC_ELT (tree, SESE_PARAMS (region), i, p)
if (p == name)
return i;
return -1;
} | /* When parameter NAME is in REGION, returns its index in SESE_PARAMS.
Otherwise returns -1. */ | When parameter NAME is in REGION, returns its index in SESE_PARAMS.
Otherwise returns -1. | [
"When",
"parameter",
"NAME",
"is",
"in",
"REGION",
"returns",
"its",
"index",
"in",
"SESE_PARAMS",
".",
"Otherwise",
"returns",
"-",
"1",
"."
] | static inline int
parameter_index_in_region_1 (tree name, sese region)
{
int i;
tree p;
gcc_assert (TREE_CODE (name) == SSA_NAME);
FOR_EACH_VEC_ELT (tree, SESE_PARAMS (region), i, p)
if (p == name)
return i;
return -1;
} | [
"static",
"inline",
"int",
"parameter_index_in_region_1",
"(",
"tree",
"name",
",",
"sese",
"region",
")",
"{",
"int",
"i",
";",
"tree",
"p",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"name",
")",
"==",
"SSA_NAME",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"tree",
",",
"SESE_PARAMS",
"(",
"region",
")",
",",
"i",
",",
"p",
")",
"",
"if",
"(",
"p",
"==",
"name",
")",
"return",
"i",
";",
"return",
"-1",
";",
"}"
] | When parameter NAME is in REGION, returns its index in SESE_PARAMS. | [
"When",
"parameter",
"NAME",
"is",
"in",
"REGION",
"returns",
"its",
"index",
"in",
"SESE_PARAMS",
"."
] | [] | [
{
"param": "name",
"type": "tree"
},
{
"param": "region",
"type": "sese"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "name",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | parameter_index_in_region | int | static int
parameter_index_in_region (tree name, sese region)
{
int i;
gcc_assert (TREE_CODE (name) == SSA_NAME);
i = parameter_index_in_region_1 (name, region);
if (i != -1)
return i;
gcc_assert (SESE_ADD_PARAMS (region));
i = VEC_length (tree, SESE_PARAMS (region));
VEC_safe_push (tree, heap, SESE_PARAMS (region), name);
return i;
} | /* When the parameter NAME is in REGION, returns its index in
SESE_PARAMS. Otherwise this function inserts NAME in SESE_PARAMS
and returns the index of NAME. */ | When the parameter NAME is in REGION, returns its index in
SESE_PARAMS. Otherwise this function inserts NAME in SESE_PARAMS
and returns the index of NAME. | [
"When",
"the",
"parameter",
"NAME",
"is",
"in",
"REGION",
"returns",
"its",
"index",
"in",
"SESE_PARAMS",
".",
"Otherwise",
"this",
"function",
"inserts",
"NAME",
"in",
"SESE_PARAMS",
"and",
"returns",
"the",
"index",
"of",
"NAME",
"."
] | static int
parameter_index_in_region (tree name, sese region)
{
int i;
gcc_assert (TREE_CODE (name) == SSA_NAME);
i = parameter_index_in_region_1 (name, region);
if (i != -1)
return i;
gcc_assert (SESE_ADD_PARAMS (region));
i = VEC_length (tree, SESE_PARAMS (region));
VEC_safe_push (tree, heap, SESE_PARAMS (region), name);
return i;
} | [
"static",
"int",
"parameter_index_in_region",
"(",
"tree",
"name",
",",
"sese",
"region",
")",
"{",
"int",
"i",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"name",
")",
"==",
"SSA_NAME",
")",
";",
"i",
"=",
"parameter_index_in_region_1",
"(",
"name",
",",
"region",
")",
";",
"if",
"(",
"i",
"!=",
"-1",
")",
"return",
"i",
";",
"gcc_assert",
"(",
"SESE_ADD_PARAMS",
"(",
"region",
")",
")",
";",
"i",
"=",
"VEC_length",
"(",
"tree",
",",
"SESE_PARAMS",
"(",
"region",
")",
")",
";",
"VEC_safe_push",
"(",
"tree",
",",
"heap",
",",
"SESE_PARAMS",
"(",
"region",
")",
",",
"name",
")",
";",
"return",
"i",
";",
"}"
] | When the parameter NAME is in REGION, returns its index in
SESE_PARAMS. | [
"When",
"the",
"parameter",
"NAME",
"is",
"in",
"REGION",
"returns",
"its",
"index",
"in",
"SESE_PARAMS",
"."
] | [] | [
{
"param": "name",
"type": "tree"
},
{
"param": "region",
"type": "sese"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "name",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | scan_tree_for_params | void | static void
scan_tree_for_params (sese s, tree e, ppl_Linear_Expression_t c,
mpz_t k)
{
if (e == chrec_dont_know)
return;
switch (TREE_CODE (e))
{
case POLYNOMIAL_CHREC:
scan_tree_for_params_right_scev (s, CHREC_RIGHT (e),
CHREC_VARIABLE (e), c);
scan_tree_for_params (s, CHREC_LEFT (e), c, k);
break;
case MULT_EXPR:
if (chrec_contains_symbols (TREE_OPERAND (e, 0)))
{
if (c)
{
mpz_t val;
gcc_assert (host_integerp (TREE_OPERAND (e, 1), 0));
mpz_init (val);
tree_int_to_gmp (TREE_OPERAND (e, 1), val);
mpz_mul (val, val, k);
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, val);
mpz_clear (val);
}
else
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
}
else
{
if (c)
{
mpz_t val;
gcc_assert (host_integerp (TREE_OPERAND (e, 0), 0));
mpz_init (val);
tree_int_to_gmp (TREE_OPERAND (e, 0), val);
mpz_mul (val, val, k);
scan_tree_for_params (s, TREE_OPERAND (e, 1), c, val);
mpz_clear (val);
}
else
scan_tree_for_params (s, TREE_OPERAND (e, 1), c, k);
}
break;
case PLUS_EXPR:
case POINTER_PLUS_EXPR:
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
scan_tree_for_params (s, TREE_OPERAND (e, 1), c, k);
break;
case MINUS_EXPR:
{
ppl_Linear_Expression_t tmp_expr = NULL;
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
ppl_new_Linear_Expression_with_dimension (&tmp_expr, dim);
}
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
scan_tree_for_params (s, TREE_OPERAND (e, 1), tmp_expr, k);
if (c)
{
ppl_subtract_Linear_Expression_from_Linear_Expression (c,
tmp_expr);
ppl_delete_Linear_Expression (tmp_expr);
}
break;
}
case NEGATE_EXPR:
{
ppl_Linear_Expression_t tmp_expr = NULL;
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
ppl_new_Linear_Expression_with_dimension (&tmp_expr, dim);
}
scan_tree_for_params (s, TREE_OPERAND (e, 0), tmp_expr, k);
if (c)
{
ppl_subtract_Linear_Expression_from_Linear_Expression (c,
tmp_expr);
ppl_delete_Linear_Expression (tmp_expr);
}
break;
}
case BIT_NOT_EXPR:
{
ppl_Linear_Expression_t tmp_expr = NULL;
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
ppl_new_Linear_Expression_with_dimension (&tmp_expr, dim);
}
scan_tree_for_params (s, TREE_OPERAND (e, 0), tmp_expr, k);
if (c)
{
ppl_Coefficient_t coef;
mpz_t minus_one;
ppl_subtract_Linear_Expression_from_Linear_Expression (c,
tmp_expr);
ppl_delete_Linear_Expression (tmp_expr);
mpz_init (minus_one);
mpz_set_si (minus_one, -1);
ppl_new_Coefficient_from_mpz_t (&coef, minus_one);
ppl_Linear_Expression_add_to_inhomogeneous (c, coef);
mpz_clear (minus_one);
ppl_delete_Coefficient (coef);
}
break;
}
case SSA_NAME:
{
ppl_dimension_type p = parameter_index_in_region (e, s);
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
p += dim - sese_nb_params (s);
add_value_to_dim (p, c, k);
}
break;
}
case INTEGER_CST:
if (c)
scan_tree_for_params_int (e, c, k);
break;
CASE_CONVERT:
case NON_LVALUE_EXPR:
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
break;
case ADDR_EXPR:
break;
default:
gcc_unreachable ();
break;
}
} | /* In the context of sese S, scan the expression E and translate it to
a linear expression C. When parsing a symbolic multiplication, K
represents the constant multiplier of an expression containing
parameters. */ | In the context of sese S, scan the expression E and translate it to
a linear expression C. When parsing a symbolic multiplication, K
represents the constant multiplier of an expression containing
parameters. | [
"In",
"the",
"context",
"of",
"sese",
"S",
"scan",
"the",
"expression",
"E",
"and",
"translate",
"it",
"to",
"a",
"linear",
"expression",
"C",
".",
"When",
"parsing",
"a",
"symbolic",
"multiplication",
"K",
"represents",
"the",
"constant",
"multiplier",
"of",
"an",
"expression",
"containing",
"parameters",
"."
] | static void
scan_tree_for_params (sese s, tree e, ppl_Linear_Expression_t c,
mpz_t k)
{
if (e == chrec_dont_know)
return;
switch (TREE_CODE (e))
{
case POLYNOMIAL_CHREC:
scan_tree_for_params_right_scev (s, CHREC_RIGHT (e),
CHREC_VARIABLE (e), c);
scan_tree_for_params (s, CHREC_LEFT (e), c, k);
break;
case MULT_EXPR:
if (chrec_contains_symbols (TREE_OPERAND (e, 0)))
{
if (c)
{
mpz_t val;
gcc_assert (host_integerp (TREE_OPERAND (e, 1), 0));
mpz_init (val);
tree_int_to_gmp (TREE_OPERAND (e, 1), val);
mpz_mul (val, val, k);
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, val);
mpz_clear (val);
}
else
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
}
else
{
if (c)
{
mpz_t val;
gcc_assert (host_integerp (TREE_OPERAND (e, 0), 0));
mpz_init (val);
tree_int_to_gmp (TREE_OPERAND (e, 0), val);
mpz_mul (val, val, k);
scan_tree_for_params (s, TREE_OPERAND (e, 1), c, val);
mpz_clear (val);
}
else
scan_tree_for_params (s, TREE_OPERAND (e, 1), c, k);
}
break;
case PLUS_EXPR:
case POINTER_PLUS_EXPR:
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
scan_tree_for_params (s, TREE_OPERAND (e, 1), c, k);
break;
case MINUS_EXPR:
{
ppl_Linear_Expression_t tmp_expr = NULL;
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
ppl_new_Linear_Expression_with_dimension (&tmp_expr, dim);
}
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
scan_tree_for_params (s, TREE_OPERAND (e, 1), tmp_expr, k);
if (c)
{
ppl_subtract_Linear_Expression_from_Linear_Expression (c,
tmp_expr);
ppl_delete_Linear_Expression (tmp_expr);
}
break;
}
case NEGATE_EXPR:
{
ppl_Linear_Expression_t tmp_expr = NULL;
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
ppl_new_Linear_Expression_with_dimension (&tmp_expr, dim);
}
scan_tree_for_params (s, TREE_OPERAND (e, 0), tmp_expr, k);
if (c)
{
ppl_subtract_Linear_Expression_from_Linear_Expression (c,
tmp_expr);
ppl_delete_Linear_Expression (tmp_expr);
}
break;
}
case BIT_NOT_EXPR:
{
ppl_Linear_Expression_t tmp_expr = NULL;
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
ppl_new_Linear_Expression_with_dimension (&tmp_expr, dim);
}
scan_tree_for_params (s, TREE_OPERAND (e, 0), tmp_expr, k);
if (c)
{
ppl_Coefficient_t coef;
mpz_t minus_one;
ppl_subtract_Linear_Expression_from_Linear_Expression (c,
tmp_expr);
ppl_delete_Linear_Expression (tmp_expr);
mpz_init (minus_one);
mpz_set_si (minus_one, -1);
ppl_new_Coefficient_from_mpz_t (&coef, minus_one);
ppl_Linear_Expression_add_to_inhomogeneous (c, coef);
mpz_clear (minus_one);
ppl_delete_Coefficient (coef);
}
break;
}
case SSA_NAME:
{
ppl_dimension_type p = parameter_index_in_region (e, s);
if (c)
{
ppl_dimension_type dim;
ppl_Linear_Expression_space_dimension (c, &dim);
p += dim - sese_nb_params (s);
add_value_to_dim (p, c, k);
}
break;
}
case INTEGER_CST:
if (c)
scan_tree_for_params_int (e, c, k);
break;
CASE_CONVERT:
case NON_LVALUE_EXPR:
scan_tree_for_params (s, TREE_OPERAND (e, 0), c, k);
break;
case ADDR_EXPR:
break;
default:
gcc_unreachable ();
break;
}
} | [
"static",
"void",
"scan_tree_for_params",
"(",
"sese",
"s",
",",
"tree",
"e",
",",
"ppl_Linear_Expression_t",
"c",
",",
"mpz_t",
"k",
")",
"{",
"if",
"(",
"e",
"==",
"chrec_dont_know",
")",
"return",
";",
"switch",
"(",
"TREE_CODE",
"(",
"e",
")",
")",
"{",
"case",
"POLYNOMIAL_CHREC",
":",
"scan_tree_for_params_right_scev",
"(",
"s",
",",
"CHREC_RIGHT",
"(",
"e",
")",
",",
"CHREC_VARIABLE",
"(",
"e",
")",
",",
"c",
")",
";",
"scan_tree_for_params",
"(",
"s",
",",
"CHREC_LEFT",
"(",
"e",
")",
",",
"c",
",",
"k",
")",
";",
"break",
";",
"case",
"MULT_EXPR",
":",
"if",
"(",
"chrec_contains_symbols",
"(",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
")",
")",
"{",
"if",
"(",
"c",
")",
"{",
"mpz_t",
"val",
";",
"gcc_assert",
"(",
"host_integerp",
"(",
"TREE_OPERAND",
"(",
"e",
",",
"1",
")",
",",
"0",
")",
")",
";",
"mpz_init",
"(",
"val",
")",
";",
"tree_int_to_gmp",
"(",
"TREE_OPERAND",
"(",
"e",
",",
"1",
")",
",",
"val",
")",
";",
"mpz_mul",
"(",
"val",
",",
"val",
",",
"k",
")",
";",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"c",
",",
"val",
")",
";",
"mpz_clear",
"(",
"val",
")",
";",
"}",
"else",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"c",
",",
"k",
")",
";",
"}",
"else",
"{",
"if",
"(",
"c",
")",
"{",
"mpz_t",
"val",
";",
"gcc_assert",
"(",
"host_integerp",
"(",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"0",
")",
")",
";",
"mpz_init",
"(",
"val",
")",
";",
"tree_int_to_gmp",
"(",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"val",
")",
";",
"mpz_mul",
"(",
"val",
",",
"val",
",",
"k",
")",
";",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"1",
")",
",",
"c",
",",
"val",
")",
";",
"mpz_clear",
"(",
"val",
")",
";",
"}",
"else",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"1",
")",
",",
"c",
",",
"k",
")",
";",
"}",
"break",
";",
"case",
"PLUS_EXPR",
":",
"case",
"POINTER_PLUS_EXPR",
":",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"c",
",",
"k",
")",
";",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"1",
")",
",",
"c",
",",
"k",
")",
";",
"break",
";",
"case",
"MINUS_EXPR",
":",
"{",
"ppl_Linear_Expression_t",
"tmp_expr",
"=",
"NULL",
";",
"if",
"(",
"c",
")",
"{",
"ppl_dimension_type",
"dim",
";",
"ppl_Linear_Expression_space_dimension",
"(",
"c",
",",
"&",
"dim",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"tmp_expr",
",",
"dim",
")",
";",
"}",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"c",
",",
"k",
")",
";",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"1",
")",
",",
"tmp_expr",
",",
"k",
")",
";",
"if",
"(",
"c",
")",
"{",
"ppl_subtract_Linear_Expression_from_Linear_Expression",
"(",
"c",
",",
"tmp_expr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"tmp_expr",
")",
";",
"}",
"break",
";",
"}",
"case",
"NEGATE_EXPR",
":",
"{",
"ppl_Linear_Expression_t",
"tmp_expr",
"=",
"NULL",
";",
"if",
"(",
"c",
")",
"{",
"ppl_dimension_type",
"dim",
";",
"ppl_Linear_Expression_space_dimension",
"(",
"c",
",",
"&",
"dim",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"tmp_expr",
",",
"dim",
")",
";",
"}",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"tmp_expr",
",",
"k",
")",
";",
"if",
"(",
"c",
")",
"{",
"ppl_subtract_Linear_Expression_from_Linear_Expression",
"(",
"c",
",",
"tmp_expr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"tmp_expr",
")",
";",
"}",
"break",
";",
"}",
"case",
"BIT_NOT_EXPR",
":",
"{",
"ppl_Linear_Expression_t",
"tmp_expr",
"=",
"NULL",
";",
"if",
"(",
"c",
")",
"{",
"ppl_dimension_type",
"dim",
";",
"ppl_Linear_Expression_space_dimension",
"(",
"c",
",",
"&",
"dim",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"tmp_expr",
",",
"dim",
")",
";",
"}",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"tmp_expr",
",",
"k",
")",
";",
"if",
"(",
"c",
")",
"{",
"ppl_Coefficient_t",
"coef",
";",
"mpz_t",
"minus_one",
";",
"ppl_subtract_Linear_Expression_from_Linear_Expression",
"(",
"c",
",",
"tmp_expr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"tmp_expr",
")",
";",
"mpz_init",
"(",
"minus_one",
")",
";",
"mpz_set_si",
"(",
"minus_one",
",",
"-1",
")",
";",
"ppl_new_Coefficient_from_mpz_t",
"(",
"&",
"coef",
",",
"minus_one",
")",
";",
"ppl_Linear_Expression_add_to_inhomogeneous",
"(",
"c",
",",
"coef",
")",
";",
"mpz_clear",
"(",
"minus_one",
")",
";",
"ppl_delete_Coefficient",
"(",
"coef",
")",
";",
"}",
"break",
";",
"}",
"case",
"SSA_NAME",
":",
"{",
"ppl_dimension_type",
"p",
"=",
"parameter_index_in_region",
"(",
"e",
",",
"s",
")",
";",
"if",
"(",
"c",
")",
"{",
"ppl_dimension_type",
"dim",
";",
"ppl_Linear_Expression_space_dimension",
"(",
"c",
",",
"&",
"dim",
")",
";",
"p",
"+=",
"dim",
"-",
"sese_nb_params",
"(",
"s",
")",
";",
"add_value_to_dim",
"(",
"p",
",",
"c",
",",
"k",
")",
";",
"}",
"break",
";",
"}",
"case",
"INTEGER_CST",
":",
"if",
"(",
"c",
")",
"scan_tree_for_params_int",
"(",
"e",
",",
"c",
",",
"k",
")",
";",
"break",
";",
"CASE_CONVERT",
":",
"case",
"NON_LVALUE_EXPR",
":",
"scan_tree_for_params",
"(",
"s",
",",
"TREE_OPERAND",
"(",
"e",
",",
"0",
")",
",",
"c",
",",
"k",
")",
";",
"break",
";",
"case",
"ADDR_EXPR",
":",
"break",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"break",
";",
"}",
"}"
] | In the context of sese S, scan the expression E and translate it to
a linear expression C. When parsing a symbolic multiplication, K
represents the constant multiplier of an expression containing
parameters. | [
"In",
"the",
"context",
"of",
"sese",
"S",
"scan",
"the",
"expression",
"E",
"and",
"translate",
"it",
"to",
"a",
"linear",
"expression",
"C",
".",
"When",
"parsing",
"a",
"symbolic",
"multiplication",
"K",
"represents",
"the",
"constant",
"multiplier",
"of",
"an",
"expression",
"containing",
"parameters",
"."
] | [] | [
{
"param": "s",
"type": "sese"
},
{
"param": "e",
"type": "tree"
},
{
"param": "c",
"type": "ppl_Linear_Expression_t"
},
{
"param": "k",
"type": "mpz_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "s",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "e",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "c",
"type": "ppl_Linear_Expression_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "k",
"type": "mpz_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | find_params_in_bb | void | static void
find_params_in_bb (sese region, gimple_bb_p gbb)
{
int i;
unsigned j;
data_reference_p dr;
gimple stmt;
loop_p loop = GBB_BB (gbb)->loop_father;
mpz_t one;
mpz_init (one);
mpz_set_si (one, 1);
/* Find parameters in the access functions of data references. */
FOR_EACH_VEC_ELT (data_reference_p, GBB_DATA_REFS (gbb), i, dr)
for (j = 0; j < DR_NUM_DIMENSIONS (dr); j++)
scan_tree_for_params (region, DR_ACCESS_FN (dr, j), NULL, one);
/* Find parameters in conditional statements. */
FOR_EACH_VEC_ELT (gimple, GBB_CONDITIONS (gbb), i, stmt)
{
tree lhs = scalar_evolution_in_region (region, loop,
gimple_cond_lhs (stmt));
tree rhs = scalar_evolution_in_region (region, loop,
gimple_cond_rhs (stmt));
scan_tree_for_params (region, lhs, NULL, one);
scan_tree_for_params (region, rhs, NULL, one);
}
mpz_clear (one);
} | /* Find parameters with respect to REGION in BB. We are looking in memory
access functions, conditions and loop bounds. */ | Find parameters with respect to REGION in BB. We are looking in memory
access functions, conditions and loop bounds. | [
"Find",
"parameters",
"with",
"respect",
"to",
"REGION",
"in",
"BB",
".",
"We",
"are",
"looking",
"in",
"memory",
"access",
"functions",
"conditions",
"and",
"loop",
"bounds",
"."
] | static void
find_params_in_bb (sese region, gimple_bb_p gbb)
{
int i;
unsigned j;
data_reference_p dr;
gimple stmt;
loop_p loop = GBB_BB (gbb)->loop_father;
mpz_t one;
mpz_init (one);
mpz_set_si (one, 1);
FOR_EACH_VEC_ELT (data_reference_p, GBB_DATA_REFS (gbb), i, dr)
for (j = 0; j < DR_NUM_DIMENSIONS (dr); j++)
scan_tree_for_params (region, DR_ACCESS_FN (dr, j), NULL, one);
FOR_EACH_VEC_ELT (gimple, GBB_CONDITIONS (gbb), i, stmt)
{
tree lhs = scalar_evolution_in_region (region, loop,
gimple_cond_lhs (stmt));
tree rhs = scalar_evolution_in_region (region, loop,
gimple_cond_rhs (stmt));
scan_tree_for_params (region, lhs, NULL, one);
scan_tree_for_params (region, rhs, NULL, one);
}
mpz_clear (one);
} | [
"static",
"void",
"find_params_in_bb",
"(",
"sese",
"region",
",",
"gimple_bb_p",
"gbb",
")",
"{",
"int",
"i",
";",
"unsigned",
"j",
";",
"data_reference_p",
"dr",
";",
"gimple",
"stmt",
";",
"loop_p",
"loop",
"=",
"GBB_BB",
"(",
"gbb",
")",
"->",
"loop_father",
";",
"mpz_t",
"one",
";",
"mpz_init",
"(",
"one",
")",
";",
"mpz_set_si",
"(",
"one",
",",
"1",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"data_reference_p",
",",
"GBB_DATA_REFS",
"(",
"gbb",
")",
",",
"i",
",",
"dr",
")",
"",
"for",
"(",
"j",
"=",
"0",
";",
"j",
"<",
"DR_NUM_DIMENSIONS",
"(",
"dr",
")",
";",
"j",
"++",
")",
"scan_tree_for_params",
"(",
"region",
",",
"DR_ACCESS_FN",
"(",
"dr",
",",
"j",
")",
",",
"NULL",
",",
"one",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"gimple",
",",
"GBB_CONDITIONS",
"(",
"gbb",
")",
",",
"i",
",",
"stmt",
")",
"",
"{",
"tree",
"lhs",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"gimple_cond_lhs",
"(",
"stmt",
")",
")",
";",
"tree",
"rhs",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"gimple_cond_rhs",
"(",
"stmt",
")",
")",
";",
"scan_tree_for_params",
"(",
"region",
",",
"lhs",
",",
"NULL",
",",
"one",
")",
";",
"scan_tree_for_params",
"(",
"region",
",",
"rhs",
",",
"NULL",
",",
"one",
")",
";",
"}",
"mpz_clear",
"(",
"one",
")",
";",
"}"
] | Find parameters with respect to REGION in BB. | [
"Find",
"parameters",
"with",
"respect",
"to",
"REGION",
"in",
"BB",
"."
] | [
"/* Find parameters in the access functions of data references. */",
"/* Find parameters in conditional statements. */"
] | [
{
"param": "region",
"type": "sese"
},
{
"param": "gbb",
"type": "gimple_bb_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "gbb",
"type": "gimple_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | find_scop_parameters | void | static void
find_scop_parameters (scop_p scop)
{
poly_bb_p pbb;
unsigned i;
sese region = SCOP_REGION (scop);
struct loop *loop;
mpz_t one;
mpz_init (one);
mpz_set_si (one, 1);
/* Find the parameters used in the loop bounds. */
FOR_EACH_VEC_ELT (loop_p, SESE_LOOP_NEST (region), i, loop)
{
tree nb_iters = number_of_latch_executions (loop);
if (!chrec_contains_symbols (nb_iters))
continue;
nb_iters = scalar_evolution_in_region (region, loop, nb_iters);
scan_tree_for_params (region, nb_iters, NULL, one);
}
mpz_clear (one);
/* Find the parameters used in data accesses. */
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
find_params_in_bb (region, PBB_BLACK_BOX (pbb));
scop_set_nb_params (scop, sese_nb_params (region));
SESE_ADD_PARAMS (region) = false;
ppl_new_Pointset_Powerset_C_Polyhedron_from_space_dimension
(&SCOP_CONTEXT (scop), scop_nb_params (scop), 0);
} | /* Record the parameters used in the SCOP. A variable is a parameter
in a scop if it does not vary during the execution of that scop. */ | Record the parameters used in the SCOP. A variable is a parameter
in a scop if it does not vary during the execution of that scop. | [
"Record",
"the",
"parameters",
"used",
"in",
"the",
"SCOP",
".",
"A",
"variable",
"is",
"a",
"parameter",
"in",
"a",
"scop",
"if",
"it",
"does",
"not",
"vary",
"during",
"the",
"execution",
"of",
"that",
"scop",
"."
] | static void
find_scop_parameters (scop_p scop)
{
poly_bb_p pbb;
unsigned i;
sese region = SCOP_REGION (scop);
struct loop *loop;
mpz_t one;
mpz_init (one);
mpz_set_si (one, 1);
FOR_EACH_VEC_ELT (loop_p, SESE_LOOP_NEST (region), i, loop)
{
tree nb_iters = number_of_latch_executions (loop);
if (!chrec_contains_symbols (nb_iters))
continue;
nb_iters = scalar_evolution_in_region (region, loop, nb_iters);
scan_tree_for_params (region, nb_iters, NULL, one);
}
mpz_clear (one);
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
find_params_in_bb (region, PBB_BLACK_BOX (pbb));
scop_set_nb_params (scop, sese_nb_params (region));
SESE_ADD_PARAMS (region) = false;
ppl_new_Pointset_Powerset_C_Polyhedron_from_space_dimension
(&SCOP_CONTEXT (scop), scop_nb_params (scop), 0);
} | [
"static",
"void",
"find_scop_parameters",
"(",
"scop_p",
"scop",
")",
"{",
"poly_bb_p",
"pbb",
";",
"unsigned",
"i",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"struct",
"loop",
"*",
"loop",
";",
"mpz_t",
"one",
";",
"mpz_init",
"(",
"one",
")",
";",
"mpz_set_si",
"(",
"one",
",",
"1",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"loop_p",
",",
"SESE_LOOP_NEST",
"(",
"region",
")",
",",
"i",
",",
"loop",
")",
"",
"{",
"tree",
"nb_iters",
"=",
"number_of_latch_executions",
"(",
"loop",
")",
";",
"if",
"(",
"!",
"chrec_contains_symbols",
"(",
"nb_iters",
")",
")",
"continue",
";",
"nb_iters",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"nb_iters",
")",
";",
"scan_tree_for_params",
"(",
"region",
",",
"nb_iters",
",",
"NULL",
",",
"one",
")",
";",
"}",
"mpz_clear",
"(",
"one",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"poly_bb_p",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"i",
",",
"pbb",
")",
"",
"find_params_in_bb",
"(",
"region",
",",
"PBB_BLACK_BOX",
"(",
"pbb",
")",
")",
";",
"scop_set_nb_params",
"(",
"scop",
",",
"sese_nb_params",
"(",
"region",
")",
")",
";",
"SESE_ADD_PARAMS",
"(",
"region",
")",
"=",
"false",
";",
"ppl_new_Pointset_Powerset_C_Polyhedron_from_space_dimension",
"(",
"&",
"SCOP_CONTEXT",
"(",
"scop",
")",
",",
"scop_nb_params",
"(",
"scop",
")",
",",
"0",
")",
";",
"}"
] | Record the parameters used in the SCOP. | [
"Record",
"the",
"parameters",
"used",
"in",
"the",
"SCOP",
"."
] | [
"/* Find the parameters used in the loop bounds. */",
"/* Find the parameters used in data accesses. */"
] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | add_upper_bounds_from_estimated_nit | void | static void
add_upper_bounds_from_estimated_nit (scop_p scop, double_int nit,
ppl_dimension_type dim,
ppl_Linear_Expression_t ub_expr)
{
mpz_t val;
ppl_Linear_Expression_t nb_iters_le;
ppl_Polyhedron_t pol;
ppl_Coefficient_t coef;
ppl_Constraint_t ub;
ppl_new_C_Polyhedron_from_space_dimension (&pol, dim, 0);
ppl_new_Linear_Expression_from_Linear_Expression (&nb_iters_le,
ub_expr);
/* Construct the negated number of last iteration in VAL. */
mpz_init (val);
mpz_set_double_int (val, nit, false);
mpz_sub_ui (val, val, 1);
mpz_neg (val, val);
/* NB_ITERS_LE holds the number of last iteration in
parametrical form. Subtract estimated number of last
iteration and assert that result is not positive. */
ppl_new_Coefficient_from_mpz_t (&coef, val);
ppl_Linear_Expression_add_to_inhomogeneous (nb_iters_le, coef);
ppl_delete_Coefficient (coef);
ppl_new_Constraint (&ub, nb_iters_le,
PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
ppl_Polyhedron_add_constraint (pol, ub);
/* Remove all but last GDIM dimensions from POL to obtain
only the constraints on the parameters. */
{
graphite_dim_t gdim = scop_nb_params (scop);
ppl_dimension_type *dims = XNEWVEC (ppl_dimension_type, dim - gdim);
graphite_dim_t i;
for (i = 0; i < dim - gdim; i++)
dims[i] = i;
ppl_Polyhedron_remove_space_dimensions (pol, dims, dim - gdim);
XDELETEVEC (dims);
}
/* Add the constraints on the parameters to the SCoP context. */
{
ppl_Pointset_Powerset_C_Polyhedron_t constraints_ps;
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
(&constraints_ps, pol);
ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
(SCOP_CONTEXT (scop), constraints_ps);
ppl_delete_Pointset_Powerset_C_Polyhedron (constraints_ps);
}
ppl_delete_Polyhedron (pol);
ppl_delete_Linear_Expression (nb_iters_le);
ppl_delete_Constraint (ub);
mpz_clear (val);
} | /* Insert in the SCOP context constraints from the estimation of the
number of iterations. UB_EXPR is a linear expression describing
the number of iterations in a loop. This expression is bounded by
the estimation NIT. */ | Insert in the SCOP context constraints from the estimation of the
number of iterations. UB_EXPR is a linear expression describing
the number of iterations in a loop. This expression is bounded by
the estimation NIT. | [
"Insert",
"in",
"the",
"SCOP",
"context",
"constraints",
"from",
"the",
"estimation",
"of",
"the",
"number",
"of",
"iterations",
".",
"UB_EXPR",
"is",
"a",
"linear",
"expression",
"describing",
"the",
"number",
"of",
"iterations",
"in",
"a",
"loop",
".",
"This",
"expression",
"is",
"bounded",
"by",
"the",
"estimation",
"NIT",
"."
] | static void
add_upper_bounds_from_estimated_nit (scop_p scop, double_int nit,
ppl_dimension_type dim,
ppl_Linear_Expression_t ub_expr)
{
mpz_t val;
ppl_Linear_Expression_t nb_iters_le;
ppl_Polyhedron_t pol;
ppl_Coefficient_t coef;
ppl_Constraint_t ub;
ppl_new_C_Polyhedron_from_space_dimension (&pol, dim, 0);
ppl_new_Linear_Expression_from_Linear_Expression (&nb_iters_le,
ub_expr);
mpz_init (val);
mpz_set_double_int (val, nit, false);
mpz_sub_ui (val, val, 1);
mpz_neg (val, val);
ppl_new_Coefficient_from_mpz_t (&coef, val);
ppl_Linear_Expression_add_to_inhomogeneous (nb_iters_le, coef);
ppl_delete_Coefficient (coef);
ppl_new_Constraint (&ub, nb_iters_le,
PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
ppl_Polyhedron_add_constraint (pol, ub);
{
graphite_dim_t gdim = scop_nb_params (scop);
ppl_dimension_type *dims = XNEWVEC (ppl_dimension_type, dim - gdim);
graphite_dim_t i;
for (i = 0; i < dim - gdim; i++)
dims[i] = i;
ppl_Polyhedron_remove_space_dimensions (pol, dims, dim - gdim);
XDELETEVEC (dims);
}
{
ppl_Pointset_Powerset_C_Polyhedron_t constraints_ps;
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
(&constraints_ps, pol);
ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
(SCOP_CONTEXT (scop), constraints_ps);
ppl_delete_Pointset_Powerset_C_Polyhedron (constraints_ps);
}
ppl_delete_Polyhedron (pol);
ppl_delete_Linear_Expression (nb_iters_le);
ppl_delete_Constraint (ub);
mpz_clear (val);
} | [
"static",
"void",
"add_upper_bounds_from_estimated_nit",
"(",
"scop_p",
"scop",
",",
"double_int",
"nit",
",",
"ppl_dimension_type",
"dim",
",",
"ppl_Linear_Expression_t",
"ub_expr",
")",
"{",
"mpz_t",
"val",
";",
"ppl_Linear_Expression_t",
"nb_iters_le",
";",
"ppl_Polyhedron_t",
"pol",
";",
"ppl_Coefficient_t",
"coef",
";",
"ppl_Constraint_t",
"ub",
";",
"ppl_new_C_Polyhedron_from_space_dimension",
"(",
"&",
"pol",
",",
"dim",
",",
"0",
")",
";",
"ppl_new_Linear_Expression_from_Linear_Expression",
"(",
"&",
"nb_iters_le",
",",
"ub_expr",
")",
";",
"mpz_init",
"(",
"val",
")",
";",
"mpz_set_double_int",
"(",
"val",
",",
"nit",
",",
"false",
")",
";",
"mpz_sub_ui",
"(",
"val",
",",
"val",
",",
"1",
")",
";",
"mpz_neg",
"(",
"val",
",",
"val",
")",
";",
"ppl_new_Coefficient_from_mpz_t",
"(",
"&",
"coef",
",",
"val",
")",
";",
"ppl_Linear_Expression_add_to_inhomogeneous",
"(",
"nb_iters_le",
",",
"coef",
")",
";",
"ppl_delete_Coefficient",
"(",
"coef",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"ub",
",",
"nb_iters_le",
",",
"PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"pol",
",",
"ub",
")",
";",
"{",
"graphite_dim_t",
"gdim",
"=",
"scop_nb_params",
"(",
"scop",
")",
";",
"ppl_dimension_type",
"*",
"dims",
"=",
"XNEWVEC",
"(",
"ppl_dimension_type",
",",
"dim",
"-",
"gdim",
")",
";",
"graphite_dim_t",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"dim",
"-",
"gdim",
";",
"i",
"++",
")",
"dims",
"[",
"i",
"]",
"=",
"i",
";",
"ppl_Polyhedron_remove_space_dimensions",
"(",
"pol",
",",
"dims",
",",
"dim",
"-",
"gdim",
")",
";",
"XDELETEVEC",
"(",
"dims",
")",
";",
"}",
"{",
"ppl_Pointset_Powerset_C_Polyhedron_t",
"constraints_ps",
";",
"ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron",
"(",
"&",
"constraints_ps",
",",
"pol",
")",
";",
"ppl_Pointset_Powerset_C_Polyhedron_intersection_assign",
"(",
"SCOP_CONTEXT",
"(",
"scop",
")",
",",
"constraints_ps",
")",
";",
"ppl_delete_Pointset_Powerset_C_Polyhedron",
"(",
"constraints_ps",
")",
";",
"}",
"ppl_delete_Polyhedron",
"(",
"pol",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"nb_iters_le",
")",
";",
"ppl_delete_Constraint",
"(",
"ub",
")",
";",
"mpz_clear",
"(",
"val",
")",
";",
"}"
] | Insert in the SCOP context constraints from the estimation of the
number of iterations. | [
"Insert",
"in",
"the",
"SCOP",
"context",
"constraints",
"from",
"the",
"estimation",
"of",
"the",
"number",
"of",
"iterations",
"."
] | [
"/* Construct the negated number of last iteration in VAL. */",
"/* NB_ITERS_LE holds the number of last iteration in\n parametrical form. Subtract estimated number of last\n iteration and assert that result is not positive. */",
"/* Remove all but last GDIM dimensions from POL to obtain\n only the constraints on the parameters. */",
"/* Add the constraints on the parameters to the SCoP context. */"
] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "nit",
"type": "double_int"
},
{
"param": "dim",
"type": "ppl_dimension_type"
},
{
"param": "ub_expr",
"type": "ppl_Linear_Expression_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "nit",
"type": "double_int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dim",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "ub_expr",
"type": "ppl_Linear_Expression_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | create_linear_expr_from_tree | ppl_Linear_Expression_t | static ppl_Linear_Expression_t
create_linear_expr_from_tree (poly_bb_p pbb, tree t)
{
mpz_t one;
ppl_Linear_Expression_t res;
ppl_dimension_type dim;
sese region = SCOP_REGION (PBB_SCOP (pbb));
loop_p loop = pbb_loop (pbb);
dim = pbb_dim_iter_domain (pbb) + pbb_nb_params (pbb);
ppl_new_Linear_Expression_with_dimension (&res, dim);
t = scalar_evolution_in_region (region, loop, t);
gcc_assert (!automatically_generated_chrec_p (t));
mpz_init (one);
mpz_set_si (one, 1);
scan_tree_for_params (region, t, res, one);
mpz_clear (one);
return res;
} | /* Returns a linear expression for tree T evaluated in PBB. */ | Returns a linear expression for tree T evaluated in PBB. | [
"Returns",
"a",
"linear",
"expression",
"for",
"tree",
"T",
"evaluated",
"in",
"PBB",
"."
] | static ppl_Linear_Expression_t
create_linear_expr_from_tree (poly_bb_p pbb, tree t)
{
mpz_t one;
ppl_Linear_Expression_t res;
ppl_dimension_type dim;
sese region = SCOP_REGION (PBB_SCOP (pbb));
loop_p loop = pbb_loop (pbb);
dim = pbb_dim_iter_domain (pbb) + pbb_nb_params (pbb);
ppl_new_Linear_Expression_with_dimension (&res, dim);
t = scalar_evolution_in_region (region, loop, t);
gcc_assert (!automatically_generated_chrec_p (t));
mpz_init (one);
mpz_set_si (one, 1);
scan_tree_for_params (region, t, res, one);
mpz_clear (one);
return res;
} | [
"static",
"ppl_Linear_Expression_t",
"create_linear_expr_from_tree",
"(",
"poly_bb_p",
"pbb",
",",
"tree",
"t",
")",
"{",
"mpz_t",
"one",
";",
"ppl_Linear_Expression_t",
"res",
";",
"ppl_dimension_type",
"dim",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"PBB_SCOP",
"(",
"pbb",
")",
")",
";",
"loop_p",
"loop",
"=",
"pbb_loop",
"(",
"pbb",
")",
";",
"dim",
"=",
"pbb_dim_iter_domain",
"(",
"pbb",
")",
"+",
"pbb_nb_params",
"(",
"pbb",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"res",
",",
"dim",
")",
";",
"t",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"t",
")",
";",
"gcc_assert",
"(",
"!",
"automatically_generated_chrec_p",
"(",
"t",
")",
")",
";",
"mpz_init",
"(",
"one",
")",
";",
"mpz_set_si",
"(",
"one",
",",
"1",
")",
";",
"scan_tree_for_params",
"(",
"region",
",",
"t",
",",
"res",
",",
"one",
")",
";",
"mpz_clear",
"(",
"one",
")",
";",
"return",
"res",
";",
"}"
] | Returns a linear expression for tree T evaluated in PBB. | [
"Returns",
"a",
"linear",
"expression",
"for",
"tree",
"T",
"evaluated",
"in",
"PBB",
"."
] | [] | [
{
"param": "pbb",
"type": "poly_bb_p"
},
{
"param": "t",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "t",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | ppl_constraint_type_from_tree_code | null | static enum ppl_enum_Constraint_Type
ppl_constraint_type_from_tree_code (enum tree_code code)
{
switch (code)
{
/* We do not support LT and GT to be able to work with C_Polyhedron.
As we work on integer polyhedron "a < b" can be expressed by
"a + 1 <= b". */
case LT_EXPR:
case GT_EXPR:
gcc_unreachable ();
case LE_EXPR:
return PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL;
case GE_EXPR:
return PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL;
case EQ_EXPR:
return PPL_CONSTRAINT_TYPE_EQUAL;
default:
gcc_unreachable ();
}
} | /* Returns the ppl constraint type from the gimple tree code CODE. */ | Returns the ppl constraint type from the gimple tree code CODE. | [
"Returns",
"the",
"ppl",
"constraint",
"type",
"from",
"the",
"gimple",
"tree",
"code",
"CODE",
"."
] | static enum ppl_enum_Constraint_Type
ppl_constraint_type_from_tree_code (enum tree_code code)
{
switch (code)
{
case LT_EXPR:
case GT_EXPR:
gcc_unreachable ();
case LE_EXPR:
return PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL;
case GE_EXPR:
return PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL;
case EQ_EXPR:
return PPL_CONSTRAINT_TYPE_EQUAL;
default:
gcc_unreachable ();
}
} | [
"static",
"enum",
"ppl_enum_Constraint_Type",
"ppl_constraint_type_from_tree_code",
"(",
"enum",
"tree_code",
"code",
")",
"{",
"switch",
"(",
"code",
")",
"{",
"case",
"LT_EXPR",
":",
"case",
"GT_EXPR",
":",
"gcc_unreachable",
"(",
")",
";",
"case",
"LE_EXPR",
":",
"return",
"PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL",
";",
"case",
"GE_EXPR",
":",
"return",
"PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL",
";",
"case",
"EQ_EXPR",
":",
"return",
"PPL_CONSTRAINT_TYPE_EQUAL",
";",
"default",
":",
"gcc_unreachable",
"(",
")",
";",
"}",
"}"
] | Returns the ppl constraint type from the gimple tree code CODE. | [
"Returns",
"the",
"ppl",
"constraint",
"type",
"from",
"the",
"gimple",
"tree",
"code",
"CODE",
"."
] | [
"/* We do not support LT and GT to be able to work with C_Polyhedron.\n As we work on integer polyhedron \"a < b\" can be expressed by\n \"a + 1 <= b\". */"
] | [
{
"param": "code",
"type": "enum tree_code"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "code",
"type": "enum tree_code",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | add_condition_to_pbb | void | static void
add_condition_to_pbb (poly_bb_p pbb, gimple stmt, enum tree_code code)
{
if (code == NE_EXPR)
{
ppl_Pointset_Powerset_C_Polyhedron_t left = PBB_DOMAIN (pbb);
ppl_Pointset_Powerset_C_Polyhedron_t right;
ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
(&right, left);
add_condition_to_domain (left, stmt, pbb, LT_EXPR);
add_condition_to_domain (right, stmt, pbb, GT_EXPR);
ppl_Pointset_Powerset_C_Polyhedron_upper_bound_assign (left, right);
ppl_delete_Pointset_Powerset_C_Polyhedron (right);
}
else
add_condition_to_domain (PBB_DOMAIN (pbb), stmt, pbb, code);
} | /* Add conditional statement STMT to pbb. CODE is used as the comparision
operator. This allows us to invert the condition or to handle
inequalities. */ | Add conditional statement STMT to pbb. CODE is used as the comparision
operator. This allows us to invert the condition or to handle
inequalities. | [
"Add",
"conditional",
"statement",
"STMT",
"to",
"pbb",
".",
"CODE",
"is",
"used",
"as",
"the",
"comparision",
"operator",
".",
"This",
"allows",
"us",
"to",
"invert",
"the",
"condition",
"or",
"to",
"handle",
"inequalities",
"."
] | static void
add_condition_to_pbb (poly_bb_p pbb, gimple stmt, enum tree_code code)
{
if (code == NE_EXPR)
{
ppl_Pointset_Powerset_C_Polyhedron_t left = PBB_DOMAIN (pbb);
ppl_Pointset_Powerset_C_Polyhedron_t right;
ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
(&right, left);
add_condition_to_domain (left, stmt, pbb, LT_EXPR);
add_condition_to_domain (right, stmt, pbb, GT_EXPR);
ppl_Pointset_Powerset_C_Polyhedron_upper_bound_assign (left, right);
ppl_delete_Pointset_Powerset_C_Polyhedron (right);
}
else
add_condition_to_domain (PBB_DOMAIN (pbb), stmt, pbb, code);
} | [
"static",
"void",
"add_condition_to_pbb",
"(",
"poly_bb_p",
"pbb",
",",
"gimple",
"stmt",
",",
"enum",
"tree_code",
"code",
")",
"{",
"if",
"(",
"code",
"==",
"NE_EXPR",
")",
"{",
"ppl_Pointset_Powerset_C_Polyhedron_t",
"left",
"=",
"PBB_DOMAIN",
"(",
"pbb",
")",
";",
"ppl_Pointset_Powerset_C_Polyhedron_t",
"right",
";",
"ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron",
"(",
"&",
"right",
",",
"left",
")",
";",
"add_condition_to_domain",
"(",
"left",
",",
"stmt",
",",
"pbb",
",",
"LT_EXPR",
")",
";",
"add_condition_to_domain",
"(",
"right",
",",
"stmt",
",",
"pbb",
",",
"GT_EXPR",
")",
";",
"ppl_Pointset_Powerset_C_Polyhedron_upper_bound_assign",
"(",
"left",
",",
"right",
")",
";",
"ppl_delete_Pointset_Powerset_C_Polyhedron",
"(",
"right",
")",
";",
"}",
"else",
"add_condition_to_domain",
"(",
"PBB_DOMAIN",
"(",
"pbb",
")",
",",
"stmt",
",",
"pbb",
",",
"code",
")",
";",
"}"
] | Add conditional statement STMT to pbb. | [
"Add",
"conditional",
"statement",
"STMT",
"to",
"pbb",
"."
] | [] | [
{
"param": "pbb",
"type": "poly_bb_p"
},
{
"param": "stmt",
"type": "gimple"
},
{
"param": "code",
"type": "enum tree_code"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "code",
"type": "enum tree_code",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | add_conditions_to_constraints | void | static void
add_conditions_to_constraints (scop_p scop)
{
int i;
poly_bb_p pbb;
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
add_conditions_to_domain (pbb);
} | /* Traverses all the GBBs of the SCOP and add their constraints to the
iteration domains. */ | Traverses all the GBBs of the SCOP and add their constraints to the
iteration domains. | [
"Traverses",
"all",
"the",
"GBBs",
"of",
"the",
"SCOP",
"and",
"add",
"their",
"constraints",
"to",
"the",
"iteration",
"domains",
"."
] | static void
add_conditions_to_constraints (scop_p scop)
{
int i;
poly_bb_p pbb;
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
add_conditions_to_domain (pbb);
} | [
"static",
"void",
"add_conditions_to_constraints",
"(",
"scop_p",
"scop",
")",
"{",
"int",
"i",
";",
"poly_bb_p",
"pbb",
";",
"FOR_EACH_VEC_ELT",
"(",
"poly_bb_p",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"i",
",",
"pbb",
")",
"",
"add_conditions_to_domain",
"(",
"pbb",
")",
";",
"}"
] | Traverses all the GBBs of the SCOP and add their constraints to the
iteration domains. | [
"Traverses",
"all",
"the",
"GBBs",
"of",
"the",
"SCOP",
"and",
"add",
"their",
"constraints",
"to",
"the",
"iteration",
"domains",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | single_pred_cond_non_loop_exit | gimple | static gimple
single_pred_cond_non_loop_exit (basic_block bb)
{
if (single_pred_p (bb))
{
edge e = single_pred_edge (bb);
basic_block pred = e->src;
gimple stmt;
if (loop_depth (pred->loop_father) > loop_depth (bb->loop_father))
return NULL;
stmt = last_stmt (pred);
if (stmt && gimple_code (stmt) == GIMPLE_COND)
return stmt;
}
return NULL;
} | /* Returns a COND_EXPR statement when BB has a single predecessor, the
edge between BB and its predecessor is not a loop exit edge, and
the last statement of the single predecessor is a COND_EXPR. */ | Returns a COND_EXPR statement when BB has a single predecessor, the
edge between BB and its predecessor is not a loop exit edge, and
the last statement of the single predecessor is a COND_EXPR. | [
"Returns",
"a",
"COND_EXPR",
"statement",
"when",
"BB",
"has",
"a",
"single",
"predecessor",
"the",
"edge",
"between",
"BB",
"and",
"its",
"predecessor",
"is",
"not",
"a",
"loop",
"exit",
"edge",
"and",
"the",
"last",
"statement",
"of",
"the",
"single",
"predecessor",
"is",
"a",
"COND_EXPR",
"."
] | static gimple
single_pred_cond_non_loop_exit (basic_block bb)
{
if (single_pred_p (bb))
{
edge e = single_pred_edge (bb);
basic_block pred = e->src;
gimple stmt;
if (loop_depth (pred->loop_father) > loop_depth (bb->loop_father))
return NULL;
stmt = last_stmt (pred);
if (stmt && gimple_code (stmt) == GIMPLE_COND)
return stmt;
}
return NULL;
} | [
"static",
"gimple",
"single_pred_cond_non_loop_exit",
"(",
"basic_block",
"bb",
")",
"{",
"if",
"(",
"single_pred_p",
"(",
"bb",
")",
")",
"{",
"edge",
"e",
"=",
"single_pred_edge",
"(",
"bb",
")",
";",
"basic_block",
"pred",
"=",
"e",
"->",
"src",
";",
"gimple",
"stmt",
";",
"if",
"(",
"loop_depth",
"(",
"pred",
"->",
"loop_father",
")",
">",
"loop_depth",
"(",
"bb",
"->",
"loop_father",
")",
")",
"return",
"NULL",
";",
"stmt",
"=",
"last_stmt",
"(",
"pred",
")",
";",
"if",
"(",
"stmt",
"&&",
"gimple_code",
"(",
"stmt",
")",
"==",
"GIMPLE_COND",
")",
"return",
"stmt",
";",
"}",
"return",
"NULL",
";",
"}"
] | Returns a COND_EXPR statement when BB has a single predecessor, the
edge between BB and its predecessor is not a loop exit edge, and
the last statement of the single predecessor is a COND_EXPR. | [
"Returns",
"a",
"COND_EXPR",
"statement",
"when",
"BB",
"has",
"a",
"single",
"predecessor",
"the",
"edge",
"between",
"BB",
"and",
"its",
"predecessor",
"is",
"not",
"a",
"loop",
"exit",
"edge",
"and",
"the",
"last",
"statement",
"of",
"the",
"single",
"predecessor",
"is",
"a",
"COND_EXPR",
"."
] | [] | [
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_sese_conditions_before | void | static void
build_sese_conditions_before (struct dom_walk_data *dw_data,
basic_block bb)
{
struct bsc *data = (struct bsc *) dw_data->global_data;
VEC (gimple, heap) **conditions = data->conditions;
VEC (gimple, heap) **cases = data->cases;
gimple_bb_p gbb;
gimple stmt;
if (!bb_in_sese_p (bb, data->region))
return;
stmt = single_pred_cond_non_loop_exit (bb);
if (stmt)
{
edge e = single_pred_edge (bb);
VEC_safe_push (gimple, heap, *conditions, stmt);
if (e->flags & EDGE_TRUE_VALUE)
VEC_safe_push (gimple, heap, *cases, stmt);
else
VEC_safe_push (gimple, heap, *cases, NULL);
}
gbb = gbb_from_bb (bb);
if (gbb)
{
GBB_CONDITIONS (gbb) = VEC_copy (gimple, heap, *conditions);
GBB_CONDITION_CASES (gbb) = VEC_copy (gimple, heap, *cases);
}
} | /* Call-back for dom_walk executed before visiting the dominated
blocks. */ | Call-back for dom_walk executed before visiting the dominated
blocks. | [
"Call",
"-",
"back",
"for",
"dom_walk",
"executed",
"before",
"visiting",
"the",
"dominated",
"blocks",
"."
] | static void
build_sese_conditions_before (struct dom_walk_data *dw_data,
basic_block bb)
{
struct bsc *data = (struct bsc *) dw_data->global_data;
VEC (gimple, heap) **conditions = data->conditions;
VEC (gimple, heap) **cases = data->cases;
gimple_bb_p gbb;
gimple stmt;
if (!bb_in_sese_p (bb, data->region))
return;
stmt = single_pred_cond_non_loop_exit (bb);
if (stmt)
{
edge e = single_pred_edge (bb);
VEC_safe_push (gimple, heap, *conditions, stmt);
if (e->flags & EDGE_TRUE_VALUE)
VEC_safe_push (gimple, heap, *cases, stmt);
else
VEC_safe_push (gimple, heap, *cases, NULL);
}
gbb = gbb_from_bb (bb);
if (gbb)
{
GBB_CONDITIONS (gbb) = VEC_copy (gimple, heap, *conditions);
GBB_CONDITION_CASES (gbb) = VEC_copy (gimple, heap, *cases);
}
} | [
"static",
"void",
"build_sese_conditions_before",
"(",
"struct",
"dom_walk_data",
"*",
"dw_data",
",",
"basic_block",
"bb",
")",
"{",
"struct",
"bsc",
"*",
"data",
"=",
"(",
"struct",
"bsc",
"*",
")",
"dw_data",
"->",
"global_data",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"*",
"conditions",
"=",
"data",
"->",
"conditions",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"*",
"cases",
"=",
"data",
"->",
"cases",
";",
"gimple_bb_p",
"gbb",
";",
"gimple",
"stmt",
";",
"if",
"(",
"!",
"bb_in_sese_p",
"(",
"bb",
",",
"data",
"->",
"region",
")",
")",
"return",
";",
"stmt",
"=",
"single_pred_cond_non_loop_exit",
"(",
"bb",
")",
";",
"if",
"(",
"stmt",
")",
"{",
"edge",
"e",
"=",
"single_pred_edge",
"(",
"bb",
")",
";",
"VEC_safe_push",
"(",
"gimple",
",",
"heap",
",",
"*",
"conditions",
",",
"stmt",
")",
";",
"if",
"(",
"e",
"->",
"flags",
"&",
"EDGE_TRUE_VALUE",
")",
"VEC_safe_push",
"(",
"gimple",
",",
"heap",
",",
"*",
"cases",
",",
"stmt",
")",
";",
"else",
"VEC_safe_push",
"(",
"gimple",
",",
"heap",
",",
"*",
"cases",
",",
"NULL",
")",
";",
"}",
"gbb",
"=",
"gbb_from_bb",
"(",
"bb",
")",
";",
"if",
"(",
"gbb",
")",
"{",
"GBB_CONDITIONS",
"(",
"gbb",
")",
"=",
"VEC_copy",
"(",
"gimple",
",",
"heap",
",",
"*",
"conditions",
")",
";",
"GBB_CONDITION_CASES",
"(",
"gbb",
")",
"=",
"VEC_copy",
"(",
"gimple",
",",
"heap",
",",
"*",
"cases",
")",
";",
"}",
"}"
] | Call-back for dom_walk executed before visiting the dominated
blocks. | [
"Call",
"-",
"back",
"for",
"dom_walk",
"executed",
"before",
"visiting",
"the",
"dominated",
"blocks",
"."
] | [] | [
{
"param": "dw_data",
"type": "struct dom_walk_data"
},
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dw_data",
"type": "struct dom_walk_data",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_sese_conditions_after | void | static void
build_sese_conditions_after (struct dom_walk_data *dw_data,
basic_block bb)
{
struct bsc *data = (struct bsc *) dw_data->global_data;
VEC (gimple, heap) **conditions = data->conditions;
VEC (gimple, heap) **cases = data->cases;
if (!bb_in_sese_p (bb, data->region))
return;
if (single_pred_cond_non_loop_exit (bb))
{
VEC_pop (gimple, *conditions);
VEC_pop (gimple, *cases);
}
} | /* Call-back for dom_walk executed after visiting the dominated
blocks. */ | Call-back for dom_walk executed after visiting the dominated
blocks. | [
"Call",
"-",
"back",
"for",
"dom_walk",
"executed",
"after",
"visiting",
"the",
"dominated",
"blocks",
"."
] | static void
build_sese_conditions_after (struct dom_walk_data *dw_data,
basic_block bb)
{
struct bsc *data = (struct bsc *) dw_data->global_data;
VEC (gimple, heap) **conditions = data->conditions;
VEC (gimple, heap) **cases = data->cases;
if (!bb_in_sese_p (bb, data->region))
return;
if (single_pred_cond_non_loop_exit (bb))
{
VEC_pop (gimple, *conditions);
VEC_pop (gimple, *cases);
}
} | [
"static",
"void",
"build_sese_conditions_after",
"(",
"struct",
"dom_walk_data",
"*",
"dw_data",
",",
"basic_block",
"bb",
")",
"{",
"struct",
"bsc",
"*",
"data",
"=",
"(",
"struct",
"bsc",
"*",
")",
"dw_data",
"->",
"global_data",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"*",
"conditions",
"=",
"data",
"->",
"conditions",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"*",
"cases",
"=",
"data",
"->",
"cases",
";",
"if",
"(",
"!",
"bb_in_sese_p",
"(",
"bb",
",",
"data",
"->",
"region",
")",
")",
"return",
";",
"if",
"(",
"single_pred_cond_non_loop_exit",
"(",
"bb",
")",
")",
"{",
"VEC_pop",
"(",
"gimple",
",",
"*",
"conditions",
")",
";",
"VEC_pop",
"(",
"gimple",
",",
"*",
"cases",
")",
";",
"}",
"}"
] | Call-back for dom_walk executed after visiting the dominated
blocks. | [
"Call",
"-",
"back",
"for",
"dom_walk",
"executed",
"after",
"visiting",
"the",
"dominated",
"blocks",
"."
] | [] | [
{
"param": "dw_data",
"type": "struct dom_walk_data"
},
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dw_data",
"type": "struct dom_walk_data",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_sese_conditions | void | static void
build_sese_conditions (sese region)
{
struct dom_walk_data walk_data;
VEC (gimple, heap) *conditions = VEC_alloc (gimple, heap, 3);
VEC (gimple, heap) *cases = VEC_alloc (gimple, heap, 3);
struct bsc data;
data.conditions = &conditions;
data.cases = &cases;
data.region = region;
walk_data.dom_direction = CDI_DOMINATORS;
walk_data.initialize_block_local_data = NULL;
walk_data.before_dom_children = build_sese_conditions_before;
walk_data.after_dom_children = build_sese_conditions_after;
walk_data.global_data = &data;
walk_data.block_local_data_size = 0;
init_walk_dominator_tree (&walk_data);
walk_dominator_tree (&walk_data, SESE_ENTRY_BB (region));
fini_walk_dominator_tree (&walk_data);
VEC_free (gimple, heap, conditions);
VEC_free (gimple, heap, cases);
} | /* Record all conditions in REGION. */ | Record all conditions in REGION. | [
"Record",
"all",
"conditions",
"in",
"REGION",
"."
] | static void
build_sese_conditions (sese region)
{
struct dom_walk_data walk_data;
VEC (gimple, heap) *conditions = VEC_alloc (gimple, heap, 3);
VEC (gimple, heap) *cases = VEC_alloc (gimple, heap, 3);
struct bsc data;
data.conditions = &conditions;
data.cases = &cases;
data.region = region;
walk_data.dom_direction = CDI_DOMINATORS;
walk_data.initialize_block_local_data = NULL;
walk_data.before_dom_children = build_sese_conditions_before;
walk_data.after_dom_children = build_sese_conditions_after;
walk_data.global_data = &data;
walk_data.block_local_data_size = 0;
init_walk_dominator_tree (&walk_data);
walk_dominator_tree (&walk_data, SESE_ENTRY_BB (region));
fini_walk_dominator_tree (&walk_data);
VEC_free (gimple, heap, conditions);
VEC_free (gimple, heap, cases);
} | [
"static",
"void",
"build_sese_conditions",
"(",
"sese",
"region",
")",
"{",
"struct",
"dom_walk_data",
"walk_data",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"conditions",
"=",
"VEC_alloc",
"(",
"gimple",
",",
"heap",
",",
"3",
")",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"cases",
"=",
"VEC_alloc",
"(",
"gimple",
",",
"heap",
",",
"3",
")",
";",
"struct",
"bsc",
"data",
";",
"data",
".",
"conditions",
"=",
"&",
"conditions",
";",
"data",
".",
"cases",
"=",
"&",
"cases",
";",
"data",
".",
"region",
"=",
"region",
";",
"walk_data",
".",
"dom_direction",
"=",
"CDI_DOMINATORS",
";",
"walk_data",
".",
"initialize_block_local_data",
"=",
"NULL",
";",
"walk_data",
".",
"before_dom_children",
"=",
"build_sese_conditions_before",
";",
"walk_data",
".",
"after_dom_children",
"=",
"build_sese_conditions_after",
";",
"walk_data",
".",
"global_data",
"=",
"&",
"data",
";",
"walk_data",
".",
"block_local_data_size",
"=",
"0",
";",
"init_walk_dominator_tree",
"(",
"&",
"walk_data",
")",
";",
"walk_dominator_tree",
"(",
"&",
"walk_data",
",",
"SESE_ENTRY_BB",
"(",
"region",
")",
")",
";",
"fini_walk_dominator_tree",
"(",
"&",
"walk_data",
")",
";",
"VEC_free",
"(",
"gimple",
",",
"heap",
",",
"conditions",
")",
";",
"VEC_free",
"(",
"gimple",
",",
"heap",
",",
"cases",
")",
";",
"}"
] | Record all conditions in REGION. | [
"Record",
"all",
"conditions",
"in",
"REGION",
"."
] | [] | [
{
"param": "region",
"type": "sese"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | add_param_constraints | void | static void
add_param_constraints (scop_p scop, ppl_Polyhedron_t context, graphite_dim_t p)
{
ppl_Constraint_t cstr;
ppl_Linear_Expression_t le;
tree parameter = VEC_index (tree, SESE_PARAMS (SCOP_REGION (scop)), p);
tree type = TREE_TYPE (parameter);
tree lb = NULL_TREE;
tree ub = NULL_TREE;
if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
lb = lower_bound_in_type (type, type);
else
lb = TYPE_MIN_VALUE (type);
if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type))
ub = upper_bound_in_type (type, type);
else
ub = TYPE_MAX_VALUE (type);
if (lb)
{
ppl_new_Linear_Expression_with_dimension (&le, scop_nb_params (scop));
ppl_set_coef (le, p, -1);
ppl_set_inhomogeneous_tree (le, lb);
ppl_new_Constraint (&cstr, le, PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
ppl_Polyhedron_add_constraint (context, cstr);
ppl_delete_Linear_Expression (le);
ppl_delete_Constraint (cstr);
}
if (ub)
{
ppl_new_Linear_Expression_with_dimension (&le, scop_nb_params (scop));
ppl_set_coef (le, p, -1);
ppl_set_inhomogeneous_tree (le, ub);
ppl_new_Constraint (&cstr, le, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_Polyhedron_add_constraint (context, cstr);
ppl_delete_Linear_Expression (le);
ppl_delete_Constraint (cstr);
}
} | /* Add constraints on the possible values of parameter P from the type
of P. */ | Add constraints on the possible values of parameter P from the type
of P. | [
"Add",
"constraints",
"on",
"the",
"possible",
"values",
"of",
"parameter",
"P",
"from",
"the",
"type",
"of",
"P",
"."
] | static void
add_param_constraints (scop_p scop, ppl_Polyhedron_t context, graphite_dim_t p)
{
ppl_Constraint_t cstr;
ppl_Linear_Expression_t le;
tree parameter = VEC_index (tree, SESE_PARAMS (SCOP_REGION (scop)), p);
tree type = TREE_TYPE (parameter);
tree lb = NULL_TREE;
tree ub = NULL_TREE;
if (POINTER_TYPE_P (type) || !TYPE_MIN_VALUE (type))
lb = lower_bound_in_type (type, type);
else
lb = TYPE_MIN_VALUE (type);
if (POINTER_TYPE_P (type) || !TYPE_MAX_VALUE (type))
ub = upper_bound_in_type (type, type);
else
ub = TYPE_MAX_VALUE (type);
if (lb)
{
ppl_new_Linear_Expression_with_dimension (&le, scop_nb_params (scop));
ppl_set_coef (le, p, -1);
ppl_set_inhomogeneous_tree (le, lb);
ppl_new_Constraint (&cstr, le, PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL);
ppl_Polyhedron_add_constraint (context, cstr);
ppl_delete_Linear_Expression (le);
ppl_delete_Constraint (cstr);
}
if (ub)
{
ppl_new_Linear_Expression_with_dimension (&le, scop_nb_params (scop));
ppl_set_coef (le, p, -1);
ppl_set_inhomogeneous_tree (le, ub);
ppl_new_Constraint (&cstr, le, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_Polyhedron_add_constraint (context, cstr);
ppl_delete_Linear_Expression (le);
ppl_delete_Constraint (cstr);
}
} | [
"static",
"void",
"add_param_constraints",
"(",
"scop_p",
"scop",
",",
"ppl_Polyhedron_t",
"context",
",",
"graphite_dim_t",
"p",
")",
"{",
"ppl_Constraint_t",
"cstr",
";",
"ppl_Linear_Expression_t",
"le",
";",
"tree",
"parameter",
"=",
"VEC_index",
"(",
"tree",
",",
"SESE_PARAMS",
"(",
"SCOP_REGION",
"(",
"scop",
")",
")",
",",
"p",
")",
";",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"parameter",
")",
";",
"tree",
"lb",
"=",
"NULL_TREE",
";",
"tree",
"ub",
"=",
"NULL_TREE",
";",
"if",
"(",
"POINTER_TYPE_P",
"(",
"type",
")",
"||",
"!",
"TYPE_MIN_VALUE",
"(",
"type",
")",
")",
"lb",
"=",
"lower_bound_in_type",
"(",
"type",
",",
"type",
")",
";",
"else",
"lb",
"=",
"TYPE_MIN_VALUE",
"(",
"type",
")",
";",
"if",
"(",
"POINTER_TYPE_P",
"(",
"type",
")",
"||",
"!",
"TYPE_MAX_VALUE",
"(",
"type",
")",
")",
"ub",
"=",
"upper_bound_in_type",
"(",
"type",
",",
"type",
")",
";",
"else",
"ub",
"=",
"TYPE_MAX_VALUE",
"(",
"type",
")",
";",
"if",
"(",
"lb",
")",
"{",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"le",
",",
"scop_nb_params",
"(",
"scop",
")",
")",
";",
"ppl_set_coef",
"(",
"le",
",",
"p",
",",
"-1",
")",
";",
"ppl_set_inhomogeneous_tree",
"(",
"le",
",",
"lb",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"le",
",",
"PPL_CONSTRAINT_TYPE_LESS_OR_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"context",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"le",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}",
"if",
"(",
"ub",
")",
"{",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"le",
",",
"scop_nb_params",
"(",
"scop",
")",
")",
";",
"ppl_set_coef",
"(",
"le",
",",
"p",
",",
"-1",
")",
";",
"ppl_set_inhomogeneous_tree",
"(",
"le",
",",
"ub",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"le",
",",
"PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"context",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"le",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}",
"}"
] | Add constraints on the possible values of parameter P from the type
of P. | [
"Add",
"constraints",
"on",
"the",
"possible",
"values",
"of",
"parameter",
"P",
"from",
"the",
"type",
"of",
"P",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "context",
"type": "ppl_Polyhedron_t"
},
{
"param": "p",
"type": "graphite_dim_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "context",
"type": "ppl_Polyhedron_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "p",
"type": "graphite_dim_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_scop_context | void | static void
build_scop_context (scop_p scop)
{
ppl_Polyhedron_t context;
ppl_Pointset_Powerset_C_Polyhedron_t ps;
graphite_dim_t p, n = scop_nb_params (scop);
ppl_new_C_Polyhedron_from_space_dimension (&context, n, 0);
for (p = 0; p < n; p++)
add_param_constraints (scop, context, p);
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
(&ps, context);
ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
(SCOP_CONTEXT (scop), ps);
ppl_delete_Pointset_Powerset_C_Polyhedron (ps);
ppl_delete_Polyhedron (context);
} | /* Build the context of the SCOP. The context usually contains extra
constraints that are added to the iteration domains that constrain
some parameters. */ | Build the context of the SCOP. The context usually contains extra
constraints that are added to the iteration domains that constrain
some parameters. | [
"Build",
"the",
"context",
"of",
"the",
"SCOP",
".",
"The",
"context",
"usually",
"contains",
"extra",
"constraints",
"that",
"are",
"added",
"to",
"the",
"iteration",
"domains",
"that",
"constrain",
"some",
"parameters",
"."
] | static void
build_scop_context (scop_p scop)
{
ppl_Polyhedron_t context;
ppl_Pointset_Powerset_C_Polyhedron_t ps;
graphite_dim_t p, n = scop_nb_params (scop);
ppl_new_C_Polyhedron_from_space_dimension (&context, n, 0);
for (p = 0; p < n; p++)
add_param_constraints (scop, context, p);
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron
(&ps, context);
ppl_Pointset_Powerset_C_Polyhedron_intersection_assign
(SCOP_CONTEXT (scop), ps);
ppl_delete_Pointset_Powerset_C_Polyhedron (ps);
ppl_delete_Polyhedron (context);
} | [
"static",
"void",
"build_scop_context",
"(",
"scop_p",
"scop",
")",
"{",
"ppl_Polyhedron_t",
"context",
";",
"ppl_Pointset_Powerset_C_Polyhedron_t",
"ps",
";",
"graphite_dim_t",
"p",
",",
"n",
"=",
"scop_nb_params",
"(",
"scop",
")",
";",
"ppl_new_C_Polyhedron_from_space_dimension",
"(",
"&",
"context",
",",
"n",
",",
"0",
")",
";",
"for",
"(",
"p",
"=",
"0",
";",
"p",
"<",
"n",
";",
"p",
"++",
")",
"add_param_constraints",
"(",
"scop",
",",
"context",
",",
"p",
")",
";",
"ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron",
"(",
"&",
"ps",
",",
"context",
")",
";",
"ppl_Pointset_Powerset_C_Polyhedron_intersection_assign",
"(",
"SCOP_CONTEXT",
"(",
"scop",
")",
",",
"ps",
")",
";",
"ppl_delete_Pointset_Powerset_C_Polyhedron",
"(",
"ps",
")",
";",
"ppl_delete_Polyhedron",
"(",
"context",
")",
";",
"}"
] | Build the context of the SCOP. | [
"Build",
"the",
"context",
"of",
"the",
"SCOP",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | pdr_add_alias_set | void | static void
pdr_add_alias_set (ppl_Polyhedron_t accesses, data_reference_p dr,
ppl_dimension_type accessp_nb_dims,
ppl_dimension_type dom_nb_dims)
{
ppl_Linear_Expression_t alias;
ppl_Constraint_t cstr;
int alias_set_num = 0;
base_alias_pair *bap = (base_alias_pair *)(dr->aux);
if (bap && bap->alias_set)
alias_set_num = *(bap->alias_set);
ppl_new_Linear_Expression_with_dimension (&alias, accessp_nb_dims);
ppl_set_coef (alias, dom_nb_dims, 1);
ppl_set_inhomogeneous (alias, -alias_set_num);
ppl_new_Constraint (&cstr, alias, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (alias);
ppl_delete_Constraint (cstr);
} | /* Add a constrain to the ACCESSES polyhedron for the alias set of
data reference DR. ACCESSP_NB_DIMS is the dimension of the
ACCESSES polyhedron, DOM_NB_DIMS is the dimension of the iteration
domain. */ | Add a constrain to the ACCESSES polyhedron for the alias set of
data reference DR. ACCESSP_NB_DIMS is the dimension of the
ACCESSES polyhedron, DOM_NB_DIMS is the dimension of the iteration
domain. | [
"Add",
"a",
"constrain",
"to",
"the",
"ACCESSES",
"polyhedron",
"for",
"the",
"alias",
"set",
"of",
"data",
"reference",
"DR",
".",
"ACCESSP_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"ACCESSES",
"polyhedron",
"DOM_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"iteration",
"domain",
"."
] | static void
pdr_add_alias_set (ppl_Polyhedron_t accesses, data_reference_p dr,
ppl_dimension_type accessp_nb_dims,
ppl_dimension_type dom_nb_dims)
{
ppl_Linear_Expression_t alias;
ppl_Constraint_t cstr;
int alias_set_num = 0;
base_alias_pair *bap = (base_alias_pair *)(dr->aux);
if (bap && bap->alias_set)
alias_set_num = *(bap->alias_set);
ppl_new_Linear_Expression_with_dimension (&alias, accessp_nb_dims);
ppl_set_coef (alias, dom_nb_dims, 1);
ppl_set_inhomogeneous (alias, -alias_set_num);
ppl_new_Constraint (&cstr, alias, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (alias);
ppl_delete_Constraint (cstr);
} | [
"static",
"void",
"pdr_add_alias_set",
"(",
"ppl_Polyhedron_t",
"accesses",
",",
"data_reference_p",
"dr",
",",
"ppl_dimension_type",
"accessp_nb_dims",
",",
"ppl_dimension_type",
"dom_nb_dims",
")",
"{",
"ppl_Linear_Expression_t",
"alias",
";",
"ppl_Constraint_t",
"cstr",
";",
"int",
"alias_set_num",
"=",
"0",
";",
"base_alias_pair",
"*",
"bap",
"=",
"(",
"base_alias_pair",
"*",
")",
"(",
"dr",
"->",
"aux",
")",
";",
"if",
"(",
"bap",
"&&",
"bap",
"->",
"alias_set",
")",
"alias_set_num",
"=",
"*",
"(",
"bap",
"->",
"alias_set",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"alias",
",",
"accessp_nb_dims",
")",
";",
"ppl_set_coef",
"(",
"alias",
",",
"dom_nb_dims",
",",
"1",
")",
";",
"ppl_set_inhomogeneous",
"(",
"alias",
",",
"-",
"alias_set_num",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"alias",
",",
"PPL_CONSTRAINT_TYPE_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"accesses",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"alias",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}"
] | Add a constrain to the ACCESSES polyhedron for the alias set of
data reference DR. ACCESSP_NB_DIMS is the dimension of the
ACCESSES polyhedron, DOM_NB_DIMS is the dimension of the iteration
domain. | [
"Add",
"a",
"constrain",
"to",
"the",
"ACCESSES",
"polyhedron",
"for",
"the",
"alias",
"set",
"of",
"data",
"reference",
"DR",
".",
"ACCESSP_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"ACCESSES",
"polyhedron",
"DOM_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"iteration",
"domain",
"."
] | [] | [
{
"param": "accesses",
"type": "ppl_Polyhedron_t"
},
{
"param": "dr",
"type": "data_reference_p"
},
{
"param": "accessp_nb_dims",
"type": "ppl_dimension_type"
},
{
"param": "dom_nb_dims",
"type": "ppl_dimension_type"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "accesses",
"type": "ppl_Polyhedron_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dr",
"type": "data_reference_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "accessp_nb_dims",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dom_nb_dims",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | pdr_add_memory_accesses | void | static void
pdr_add_memory_accesses (ppl_Polyhedron_t accesses, data_reference_p dr,
ppl_dimension_type accessp_nb_dims,
ppl_dimension_type dom_nb_dims,
poly_bb_p pbb)
{
int i, nb_subscripts = DR_NUM_DIMENSIONS (dr);
mpz_t v;
scop_p scop = PBB_SCOP (pbb);
sese region = SCOP_REGION (scop);
mpz_init (v);
for (i = 0; i < nb_subscripts; i++)
{
ppl_Linear_Expression_t fn, access;
ppl_Constraint_t cstr;
ppl_dimension_type subscript = dom_nb_dims + 1 + i;
tree afn = DR_ACCESS_FN (dr, nb_subscripts - 1 - i);
ppl_new_Linear_Expression_with_dimension (&fn, dom_nb_dims);
ppl_new_Linear_Expression_with_dimension (&access, accessp_nb_dims);
mpz_set_si (v, 1);
scan_tree_for_params (region, afn, fn, v);
ppl_assign_Linear_Expression_from_Linear_Expression (access, fn);
ppl_set_coef (access, subscript, -1);
ppl_new_Constraint (&cstr, access, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (fn);
ppl_delete_Linear_Expression (access);
ppl_delete_Constraint (cstr);
}
mpz_clear (v);
} | /* Add to ACCESSES polyhedron equalities defining the access functions
to the memory. ACCESSP_NB_DIMS is the dimension of the ACCESSES
polyhedron, DOM_NB_DIMS is the dimension of the iteration domain.
PBB is the poly_bb_p that contains the data reference DR. */ | Add to ACCESSES polyhedron equalities defining the access functions
to the memory. ACCESSP_NB_DIMS is the dimension of the ACCESSES
polyhedron, DOM_NB_DIMS is the dimension of the iteration domain.
PBB is the poly_bb_p that contains the data reference DR. | [
"Add",
"to",
"ACCESSES",
"polyhedron",
"equalities",
"defining",
"the",
"access",
"functions",
"to",
"the",
"memory",
".",
"ACCESSP_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"ACCESSES",
"polyhedron",
"DOM_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"iteration",
"domain",
".",
"PBB",
"is",
"the",
"poly_bb_p",
"that",
"contains",
"the",
"data",
"reference",
"DR",
"."
] | static void
pdr_add_memory_accesses (ppl_Polyhedron_t accesses, data_reference_p dr,
ppl_dimension_type accessp_nb_dims,
ppl_dimension_type dom_nb_dims,
poly_bb_p pbb)
{
int i, nb_subscripts = DR_NUM_DIMENSIONS (dr);
mpz_t v;
scop_p scop = PBB_SCOP (pbb);
sese region = SCOP_REGION (scop);
mpz_init (v);
for (i = 0; i < nb_subscripts; i++)
{
ppl_Linear_Expression_t fn, access;
ppl_Constraint_t cstr;
ppl_dimension_type subscript = dom_nb_dims + 1 + i;
tree afn = DR_ACCESS_FN (dr, nb_subscripts - 1 - i);
ppl_new_Linear_Expression_with_dimension (&fn, dom_nb_dims);
ppl_new_Linear_Expression_with_dimension (&access, accessp_nb_dims);
mpz_set_si (v, 1);
scan_tree_for_params (region, afn, fn, v);
ppl_assign_Linear_Expression_from_Linear_Expression (access, fn);
ppl_set_coef (access, subscript, -1);
ppl_new_Constraint (&cstr, access, PPL_CONSTRAINT_TYPE_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (fn);
ppl_delete_Linear_Expression (access);
ppl_delete_Constraint (cstr);
}
mpz_clear (v);
} | [
"static",
"void",
"pdr_add_memory_accesses",
"(",
"ppl_Polyhedron_t",
"accesses",
",",
"data_reference_p",
"dr",
",",
"ppl_dimension_type",
"accessp_nb_dims",
",",
"ppl_dimension_type",
"dom_nb_dims",
",",
"poly_bb_p",
"pbb",
")",
"{",
"int",
"i",
",",
"nb_subscripts",
"=",
"DR_NUM_DIMENSIONS",
"(",
"dr",
")",
";",
"mpz_t",
"v",
";",
"scop_p",
"scop",
"=",
"PBB_SCOP",
"(",
"pbb",
")",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"mpz_init",
"(",
"v",
")",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"nb_subscripts",
";",
"i",
"++",
")",
"{",
"ppl_Linear_Expression_t",
"fn",
",",
"access",
";",
"ppl_Constraint_t",
"cstr",
";",
"ppl_dimension_type",
"subscript",
"=",
"dom_nb_dims",
"+",
"1",
"+",
"i",
";",
"tree",
"afn",
"=",
"DR_ACCESS_FN",
"(",
"dr",
",",
"nb_subscripts",
"-",
"1",
"-",
"i",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"fn",
",",
"dom_nb_dims",
")",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"access",
",",
"accessp_nb_dims",
")",
";",
"mpz_set_si",
"(",
"v",
",",
"1",
")",
";",
"scan_tree_for_params",
"(",
"region",
",",
"afn",
",",
"fn",
",",
"v",
")",
";",
"ppl_assign_Linear_Expression_from_Linear_Expression",
"(",
"access",
",",
"fn",
")",
";",
"ppl_set_coef",
"(",
"access",
",",
"subscript",
",",
"-1",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"access",
",",
"PPL_CONSTRAINT_TYPE_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"accesses",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"fn",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"access",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}",
"mpz_clear",
"(",
"v",
")",
";",
"}"
] | Add to ACCESSES polyhedron equalities defining the access functions
to the memory. | [
"Add",
"to",
"ACCESSES",
"polyhedron",
"equalities",
"defining",
"the",
"access",
"functions",
"to",
"the",
"memory",
"."
] | [] | [
{
"param": "accesses",
"type": "ppl_Polyhedron_t"
},
{
"param": "dr",
"type": "data_reference_p"
},
{
"param": "accessp_nb_dims",
"type": "ppl_dimension_type"
},
{
"param": "dom_nb_dims",
"type": "ppl_dimension_type"
},
{
"param": "pbb",
"type": "poly_bb_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "accesses",
"type": "ppl_Polyhedron_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dr",
"type": "data_reference_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "accessp_nb_dims",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dom_nb_dims",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | pdr_add_data_dimensions | void | static void
pdr_add_data_dimensions (ppl_Polyhedron_t accesses, data_reference_p dr,
ppl_dimension_type accessp_nb_dims,
ppl_dimension_type dom_nb_dims)
{
tree ref = DR_REF (dr);
int i, nb_subscripts = DR_NUM_DIMENSIONS (dr);
for (i = nb_subscripts - 1; i >= 0; i--, ref = TREE_OPERAND (ref, 0))
{
ppl_Linear_Expression_t expr;
ppl_Constraint_t cstr;
ppl_dimension_type subscript = dom_nb_dims + 1 + i;
tree low, high;
if (TREE_CODE (ref) != ARRAY_REF)
break;
low = array_ref_low_bound (ref);
/* subscript - low >= 0 */
if (host_integerp (low, 0))
{
tree minus_low;
ppl_new_Linear_Expression_with_dimension (&expr, accessp_nb_dims);
ppl_set_coef (expr, subscript, 1);
minus_low = fold_build1 (NEGATE_EXPR, TREE_TYPE (low), low);
ppl_set_inhomogeneous_tree (expr, minus_low);
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
}
high = array_ref_up_bound (ref);
/* high - subscript >= 0 */
if (high && host_integerp (high, 0)
/* 1-element arrays at end of structures may extend over
their declared size. */
&& !(array_at_struct_end_p (ref)
&& operand_equal_p (low, high, 0)))
{
ppl_new_Linear_Expression_with_dimension (&expr, accessp_nb_dims);
ppl_set_coef (expr, subscript, -1);
ppl_set_inhomogeneous_tree (expr, high);
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
}
}
} | /* Add constrains representing the size of the accessed data to the
ACCESSES polyhedron. ACCESSP_NB_DIMS is the dimension of the
ACCESSES polyhedron, DOM_NB_DIMS is the dimension of the iteration
domain. */ | Add constrains representing the size of the accessed data to the
ACCESSES polyhedron. ACCESSP_NB_DIMS is the dimension of the
ACCESSES polyhedron, DOM_NB_DIMS is the dimension of the iteration
domain. | [
"Add",
"constrains",
"representing",
"the",
"size",
"of",
"the",
"accessed",
"data",
"to",
"the",
"ACCESSES",
"polyhedron",
".",
"ACCESSP_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"ACCESSES",
"polyhedron",
"DOM_NB_DIMS",
"is",
"the",
"dimension",
"of",
"the",
"iteration",
"domain",
"."
] | static void
pdr_add_data_dimensions (ppl_Polyhedron_t accesses, data_reference_p dr,
ppl_dimension_type accessp_nb_dims,
ppl_dimension_type dom_nb_dims)
{
tree ref = DR_REF (dr);
int i, nb_subscripts = DR_NUM_DIMENSIONS (dr);
for (i = nb_subscripts - 1; i >= 0; i--, ref = TREE_OPERAND (ref, 0))
{
ppl_Linear_Expression_t expr;
ppl_Constraint_t cstr;
ppl_dimension_type subscript = dom_nb_dims + 1 + i;
tree low, high;
if (TREE_CODE (ref) != ARRAY_REF)
break;
low = array_ref_low_bound (ref);
if (host_integerp (low, 0))
{
tree minus_low;
ppl_new_Linear_Expression_with_dimension (&expr, accessp_nb_dims);
ppl_set_coef (expr, subscript, 1);
minus_low = fold_build1 (NEGATE_EXPR, TREE_TYPE (low), low);
ppl_set_inhomogeneous_tree (expr, minus_low);
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
}
high = array_ref_up_bound (ref);
if (high && host_integerp (high, 0)
&& !(array_at_struct_end_p (ref)
&& operand_equal_p (low, high, 0)))
{
ppl_new_Linear_Expression_with_dimension (&expr, accessp_nb_dims);
ppl_set_coef (expr, subscript, -1);
ppl_set_inhomogeneous_tree (expr, high);
ppl_new_Constraint (&cstr, expr, PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL);
ppl_Polyhedron_add_constraint (accesses, cstr);
ppl_delete_Linear_Expression (expr);
ppl_delete_Constraint (cstr);
}
}
} | [
"static",
"void",
"pdr_add_data_dimensions",
"(",
"ppl_Polyhedron_t",
"accesses",
",",
"data_reference_p",
"dr",
",",
"ppl_dimension_type",
"accessp_nb_dims",
",",
"ppl_dimension_type",
"dom_nb_dims",
")",
"{",
"tree",
"ref",
"=",
"DR_REF",
"(",
"dr",
")",
";",
"int",
"i",
",",
"nb_subscripts",
"=",
"DR_NUM_DIMENSIONS",
"(",
"dr",
")",
";",
"for",
"(",
"i",
"=",
"nb_subscripts",
"-",
"1",
";",
"i",
">=",
"0",
";",
"i",
"--",
",",
"ref",
"=",
"TREE_OPERAND",
"(",
"ref",
",",
"0",
")",
")",
"{",
"ppl_Linear_Expression_t",
"expr",
";",
"ppl_Constraint_t",
"cstr",
";",
"ppl_dimension_type",
"subscript",
"=",
"dom_nb_dims",
"+",
"1",
"+",
"i",
";",
"tree",
"low",
",",
"high",
";",
"if",
"(",
"TREE_CODE",
"(",
"ref",
")",
"!=",
"ARRAY_REF",
")",
"break",
";",
"low",
"=",
"array_ref_low_bound",
"(",
"ref",
")",
";",
"if",
"(",
"host_integerp",
"(",
"low",
",",
"0",
")",
")",
"{",
"tree",
"minus_low",
";",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"expr",
",",
"accessp_nb_dims",
")",
";",
"ppl_set_coef",
"(",
"expr",
",",
"subscript",
",",
"1",
")",
";",
"minus_low",
"=",
"fold_build1",
"(",
"NEGATE_EXPR",
",",
"TREE_TYPE",
"(",
"low",
")",
",",
"low",
")",
";",
"ppl_set_inhomogeneous_tree",
"(",
"expr",
",",
"minus_low",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"expr",
",",
"PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"accesses",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"expr",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}",
"high",
"=",
"array_ref_up_bound",
"(",
"ref",
")",
";",
"if",
"(",
"high",
"&&",
"host_integerp",
"(",
"high",
",",
"0",
")",
"&&",
"!",
"(",
"array_at_struct_end_p",
"(",
"ref",
")",
"&&",
"operand_equal_p",
"(",
"low",
",",
"high",
",",
"0",
")",
")",
")",
"{",
"ppl_new_Linear_Expression_with_dimension",
"(",
"&",
"expr",
",",
"accessp_nb_dims",
")",
";",
"ppl_set_coef",
"(",
"expr",
",",
"subscript",
",",
"-1",
")",
";",
"ppl_set_inhomogeneous_tree",
"(",
"expr",
",",
"high",
")",
";",
"ppl_new_Constraint",
"(",
"&",
"cstr",
",",
"expr",
",",
"PPL_CONSTRAINT_TYPE_GREATER_OR_EQUAL",
")",
";",
"ppl_Polyhedron_add_constraint",
"(",
"accesses",
",",
"cstr",
")",
";",
"ppl_delete_Linear_Expression",
"(",
"expr",
")",
";",
"ppl_delete_Constraint",
"(",
"cstr",
")",
";",
"}",
"}",
"}"
] | Add constrains representing the size of the accessed data to the
ACCESSES polyhedron. | [
"Add",
"constrains",
"representing",
"the",
"size",
"of",
"the",
"accessed",
"data",
"to",
"the",
"ACCESSES",
"polyhedron",
"."
] | [
"/* subscript - low >= 0 */",
"/* high - subscript >= 0 */",
"/* 1-element arrays at end of structures may extend over\n\t their declared size. */"
] | [
{
"param": "accesses",
"type": "ppl_Polyhedron_t"
},
{
"param": "dr",
"type": "data_reference_p"
},
{
"param": "accessp_nb_dims",
"type": "ppl_dimension_type"
},
{
"param": "dom_nb_dims",
"type": "ppl_dimension_type"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "accesses",
"type": "ppl_Polyhedron_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dr",
"type": "data_reference_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "accessp_nb_dims",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dom_nb_dims",
"type": "ppl_dimension_type",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_poly_dr | void | static void
build_poly_dr (data_reference_p dr, poly_bb_p pbb)
{
ppl_Polyhedron_t accesses;
ppl_Pointset_Powerset_C_Polyhedron_t accesses_ps;
ppl_dimension_type dom_nb_dims;
ppl_dimension_type accessp_nb_dims;
int dr_base_object_set;
ppl_Pointset_Powerset_C_Polyhedron_space_dimension (PBB_DOMAIN (pbb),
&dom_nb_dims);
accessp_nb_dims = dom_nb_dims + 1 + DR_NUM_DIMENSIONS (dr);
ppl_new_C_Polyhedron_from_space_dimension (&accesses, accessp_nb_dims, 0);
pdr_add_alias_set (accesses, dr, accessp_nb_dims, dom_nb_dims);
pdr_add_memory_accesses (accesses, dr, accessp_nb_dims, dom_nb_dims, pbb);
pdr_add_data_dimensions (accesses, dr, accessp_nb_dims, dom_nb_dims);
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron (&accesses_ps,
accesses);
ppl_delete_Polyhedron (accesses);
gcc_assert (dr->aux);
dr_base_object_set = ((base_alias_pair *)(dr->aux))->base_obj_set;
new_poly_dr (pbb, dr_base_object_set, accesses_ps,
DR_IS_READ (dr) ? PDR_READ : PDR_WRITE,
dr, DR_NUM_DIMENSIONS (dr));
} | /* Build data accesses for DR in PBB. */ | Build data accesses for DR in PBB. | [
"Build",
"data",
"accesses",
"for",
"DR",
"in",
"PBB",
"."
] | static void
build_poly_dr (data_reference_p dr, poly_bb_p pbb)
{
ppl_Polyhedron_t accesses;
ppl_Pointset_Powerset_C_Polyhedron_t accesses_ps;
ppl_dimension_type dom_nb_dims;
ppl_dimension_type accessp_nb_dims;
int dr_base_object_set;
ppl_Pointset_Powerset_C_Polyhedron_space_dimension (PBB_DOMAIN (pbb),
&dom_nb_dims);
accessp_nb_dims = dom_nb_dims + 1 + DR_NUM_DIMENSIONS (dr);
ppl_new_C_Polyhedron_from_space_dimension (&accesses, accessp_nb_dims, 0);
pdr_add_alias_set (accesses, dr, accessp_nb_dims, dom_nb_dims);
pdr_add_memory_accesses (accesses, dr, accessp_nb_dims, dom_nb_dims, pbb);
pdr_add_data_dimensions (accesses, dr, accessp_nb_dims, dom_nb_dims);
ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron (&accesses_ps,
accesses);
ppl_delete_Polyhedron (accesses);
gcc_assert (dr->aux);
dr_base_object_set = ((base_alias_pair *)(dr->aux))->base_obj_set;
new_poly_dr (pbb, dr_base_object_set, accesses_ps,
DR_IS_READ (dr) ? PDR_READ : PDR_WRITE,
dr, DR_NUM_DIMENSIONS (dr));
} | [
"static",
"void",
"build_poly_dr",
"(",
"data_reference_p",
"dr",
",",
"poly_bb_p",
"pbb",
")",
"{",
"ppl_Polyhedron_t",
"accesses",
";",
"ppl_Pointset_Powerset_C_Polyhedron_t",
"accesses_ps",
";",
"ppl_dimension_type",
"dom_nb_dims",
";",
"ppl_dimension_type",
"accessp_nb_dims",
";",
"int",
"dr_base_object_set",
";",
"ppl_Pointset_Powerset_C_Polyhedron_space_dimension",
"(",
"PBB_DOMAIN",
"(",
"pbb",
")",
",",
"&",
"dom_nb_dims",
")",
";",
"accessp_nb_dims",
"=",
"dom_nb_dims",
"+",
"1",
"+",
"DR_NUM_DIMENSIONS",
"(",
"dr",
")",
";",
"ppl_new_C_Polyhedron_from_space_dimension",
"(",
"&",
"accesses",
",",
"accessp_nb_dims",
",",
"0",
")",
";",
"pdr_add_alias_set",
"(",
"accesses",
",",
"dr",
",",
"accessp_nb_dims",
",",
"dom_nb_dims",
")",
";",
"pdr_add_memory_accesses",
"(",
"accesses",
",",
"dr",
",",
"accessp_nb_dims",
",",
"dom_nb_dims",
",",
"pbb",
")",
";",
"pdr_add_data_dimensions",
"(",
"accesses",
",",
"dr",
",",
"accessp_nb_dims",
",",
"dom_nb_dims",
")",
";",
"ppl_new_Pointset_Powerset_C_Polyhedron_from_C_Polyhedron",
"(",
"&",
"accesses_ps",
",",
"accesses",
")",
";",
"ppl_delete_Polyhedron",
"(",
"accesses",
")",
";",
"gcc_assert",
"(",
"dr",
"->",
"aux",
")",
";",
"dr_base_object_set",
"=",
"(",
"(",
"base_alias_pair",
"*",
")",
"(",
"dr",
"->",
"aux",
")",
")",
"->",
"base_obj_set",
";",
"new_poly_dr",
"(",
"pbb",
",",
"dr_base_object_set",
",",
"accesses_ps",
",",
"DR_IS_READ",
"(",
"dr",
")",
"?",
"PDR_READ",
":",
"PDR_WRITE",
",",
"dr",
",",
"DR_NUM_DIMENSIONS",
"(",
"dr",
")",
")",
";",
"}"
] | Build data accesses for DR in PBB. | [
"Build",
"data",
"accesses",
"for",
"DR",
"in",
"PBB",
"."
] | [] | [
{
"param": "dr",
"type": "data_reference_p"
},
{
"param": "pbb",
"type": "poly_bb_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dr",
"type": "data_reference_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | dr_same_base_object_p | bool | static bool
dr_same_base_object_p (const struct data_reference *dr1,
const struct data_reference *dr2)
{
return operand_equal_p (DR_BASE_OBJECT (dr1), DR_BASE_OBJECT (dr2), 0);
} | /* Check if DR1 and DR2 are in the same object set. */ | Check if DR1 and DR2 are in the same object set. | [
"Check",
"if",
"DR1",
"and",
"DR2",
"are",
"in",
"the",
"same",
"object",
"set",
"."
] | static bool
dr_same_base_object_p (const struct data_reference *dr1,
const struct data_reference *dr2)
{
return operand_equal_p (DR_BASE_OBJECT (dr1), DR_BASE_OBJECT (dr2), 0);
} | [
"static",
"bool",
"dr_same_base_object_p",
"(",
"const",
"struct",
"data_reference",
"*",
"dr1",
",",
"const",
"struct",
"data_reference",
"*",
"dr2",
")",
"{",
"return",
"operand_equal_p",
"(",
"DR_BASE_OBJECT",
"(",
"dr1",
")",
",",
"DR_BASE_OBJECT",
"(",
"dr2",
")",
",",
"0",
")",
";",
"}"
] | Check if DR1 and DR2 are in the same object set. | [
"Check",
"if",
"DR1",
"and",
"DR2",
"are",
"in",
"the",
"same",
"object",
"set",
"."
] | [] | [
{
"param": "dr1",
"type": "struct data_reference"
},
{
"param": "dr2",
"type": "struct data_reference"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "dr1",
"type": "struct data_reference",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "dr2",
"type": "struct data_reference",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_pbb_drs | void | static void
build_pbb_drs (poly_bb_p pbb)
{
int j;
data_reference_p dr;
VEC (data_reference_p, heap) *gbb_drs = GBB_DATA_REFS (PBB_BLACK_BOX (pbb));
FOR_EACH_VEC_ELT (data_reference_p, gbb_drs, j, dr)
build_poly_dr (dr, pbb);
} | /* Build the data references for PBB. */ | Build the data references for PBB. | [
"Build",
"the",
"data",
"references",
"for",
"PBB",
"."
] | static void
build_pbb_drs (poly_bb_p pbb)
{
int j;
data_reference_p dr;
VEC (data_reference_p, heap) *gbb_drs = GBB_DATA_REFS (PBB_BLACK_BOX (pbb));
FOR_EACH_VEC_ELT (data_reference_p, gbb_drs, j, dr)
build_poly_dr (dr, pbb);
} | [
"static",
"void",
"build_pbb_drs",
"(",
"poly_bb_p",
"pbb",
")",
"{",
"int",
"j",
";",
"data_reference_p",
"dr",
";",
"VEC",
"(",
"data_reference_p",
",",
"heap",
")",
"*",
"gbb_drs",
"=",
"GBB_DATA_REFS",
"(",
"PBB_BLACK_BOX",
"(",
"pbb",
")",
")",
";",
"FOR_EACH_VEC_ELT",
"(",
"data_reference_p",
",",
"gbb_drs",
",",
"j",
",",
"dr",
")",
"",
"build_poly_dr",
"(",
"dr",
",",
"pbb",
")",
";",
"}"
] | Build the data references for PBB. | [
"Build",
"the",
"data",
"references",
"for",
"PBB",
"."
] | [] | [
{
"param": "pbb",
"type": "poly_bb_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | gsi_for_phi_node | gimple_stmt_iterator | static gimple_stmt_iterator
gsi_for_phi_node (gimple stmt)
{
gimple_stmt_iterator psi;
basic_block bb = gimple_bb (stmt);
for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
if (stmt == gsi_stmt (psi))
return psi;
gcc_unreachable ();
return psi;
} | /* Return a gsi at the position of the phi node STMT. */ | Return a gsi at the position of the phi node STMT. | [
"Return",
"a",
"gsi",
"at",
"the",
"position",
"of",
"the",
"phi",
"node",
"STMT",
"."
] | static gimple_stmt_iterator
gsi_for_phi_node (gimple stmt)
{
gimple_stmt_iterator psi;
basic_block bb = gimple_bb (stmt);
for (psi = gsi_start_phis (bb); !gsi_end_p (psi); gsi_next (&psi))
if (stmt == gsi_stmt (psi))
return psi;
gcc_unreachable ();
return psi;
} | [
"static",
"gimple_stmt_iterator",
"gsi_for_phi_node",
"(",
"gimple",
"stmt",
")",
"{",
"gimple_stmt_iterator",
"psi",
";",
"basic_block",
"bb",
"=",
"gimple_bb",
"(",
"stmt",
")",
";",
"for",
"(",
"psi",
"=",
"gsi_start_phis",
"(",
"bb",
")",
";",
"!",
"gsi_end_p",
"(",
"psi",
")",
";",
"gsi_next",
"(",
"&",
"psi",
")",
")",
"if",
"(",
"stmt",
"==",
"gsi_stmt",
"(",
"psi",
")",
")",
"return",
"psi",
";",
"gcc_unreachable",
"(",
")",
";",
"return",
"psi",
";",
"}"
] | Return a gsi at the position of the phi node STMT. | [
"Return",
"a",
"gsi",
"at",
"the",
"position",
"of",
"the",
"phi",
"node",
"STMT",
"."
] | [] | [
{
"param": "stmt",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | insert_stmts | void | static void
insert_stmts (scop_p scop, gimple stmt, gimple_seq stmts,
gimple_stmt_iterator insert_gsi)
{
gimple_stmt_iterator gsi;
VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
if (!stmts)
stmts = gimple_seq_alloc ();
gsi = gsi_last (stmts);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
gsi_insert_seq_before (&insert_gsi, stmts, GSI_SAME_STMT);
analyze_drs_in_stmts (scop, gsi_bb (insert_gsi), x);
VEC_free (gimple, heap, x);
} | /* Insert STMT at the end of the STMTS sequence and then insert the
statements from STMTS at INSERT_GSI and call analyze_drs_in_stmts
on STMTS. */ | Insert STMT at the end of the STMTS sequence and then insert the
statements from STMTS at INSERT_GSI and call analyze_drs_in_stmts
on STMTS. | [
"Insert",
"STMT",
"at",
"the",
"end",
"of",
"the",
"STMTS",
"sequence",
"and",
"then",
"insert",
"the",
"statements",
"from",
"STMTS",
"at",
"INSERT_GSI",
"and",
"call",
"analyze_drs_in_stmts",
"on",
"STMTS",
"."
] | static void
insert_stmts (scop_p scop, gimple stmt, gimple_seq stmts,
gimple_stmt_iterator insert_gsi)
{
gimple_stmt_iterator gsi;
VEC (gimple, heap) *x = VEC_alloc (gimple, heap, 3);
if (!stmts)
stmts = gimple_seq_alloc ();
gsi = gsi_last (stmts);
gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
for (gsi = gsi_start (stmts); !gsi_end_p (gsi); gsi_next (&gsi))
VEC_safe_push (gimple, heap, x, gsi_stmt (gsi));
gsi_insert_seq_before (&insert_gsi, stmts, GSI_SAME_STMT);
analyze_drs_in_stmts (scop, gsi_bb (insert_gsi), x);
VEC_free (gimple, heap, x);
} | [
"static",
"void",
"insert_stmts",
"(",
"scop_p",
"scop",
",",
"gimple",
"stmt",
",",
"gimple_seq",
"stmts",
",",
"gimple_stmt_iterator",
"insert_gsi",
")",
"{",
"gimple_stmt_iterator",
"gsi",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"x",
"=",
"VEC_alloc",
"(",
"gimple",
",",
"heap",
",",
"3",
")",
";",
"if",
"(",
"!",
"stmts",
")",
"stmts",
"=",
"gimple_seq_alloc",
"(",
")",
";",
"gsi",
"=",
"gsi_last",
"(",
"stmts",
")",
";",
"gsi_insert_after",
"(",
"&",
"gsi",
",",
"stmt",
",",
"GSI_NEW_STMT",
")",
";",
"for",
"(",
"gsi",
"=",
"gsi_start",
"(",
"stmts",
")",
";",
"!",
"gsi_end_p",
"(",
"gsi",
")",
";",
"gsi_next",
"(",
"&",
"gsi",
")",
")",
"VEC_safe_push",
"(",
"gimple",
",",
"heap",
",",
"x",
",",
"gsi_stmt",
"(",
"gsi",
")",
")",
";",
"gsi_insert_seq_before",
"(",
"&",
"insert_gsi",
",",
"stmts",
",",
"GSI_SAME_STMT",
")",
";",
"analyze_drs_in_stmts",
"(",
"scop",
",",
"gsi_bb",
"(",
"insert_gsi",
")",
",",
"x",
")",
";",
"VEC_free",
"(",
"gimple",
",",
"heap",
",",
"x",
")",
";",
"}"
] | Insert STMT at the end of the STMTS sequence and then insert the
statements from STMTS at INSERT_GSI and call analyze_drs_in_stmts
on STMTS. | [
"Insert",
"STMT",
"at",
"the",
"end",
"of",
"the",
"STMTS",
"sequence",
"and",
"then",
"insert",
"the",
"statements",
"from",
"STMTS",
"at",
"INSERT_GSI",
"and",
"call",
"analyze_drs_in_stmts",
"on",
"STMTS",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "stmt",
"type": "gimple"
},
{
"param": "stmts",
"type": "gimple_seq"
},
{
"param": "insert_gsi",
"type": "gimple_stmt_iterator"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmts",
"type": "gimple_seq",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "insert_gsi",
"type": "gimple_stmt_iterator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | new_pbb_from_pbb | void | static void
new_pbb_from_pbb (scop_p scop, poly_bb_p pbb, basic_block bb)
{
VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 3);
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
gimple_bb_p gbb1 = new_gimple_bb (bb, drs);
poly_bb_p pbb1 = new_poly_bb (scop, gbb1);
int index, n = VEC_length (poly_bb_p, SCOP_BBS (scop));
/* The INDEX of PBB in SCOP_BBS. */
for (index = 0; index < n; index++)
if (VEC_index (poly_bb_p, SCOP_BBS (scop), index) == pbb)
break;
if (PBB_DOMAIN (pbb))
ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
(&PBB_DOMAIN (pbb1), PBB_DOMAIN (pbb));
GBB_PBB (gbb1) = pbb1;
GBB_CONDITIONS (gbb1) = VEC_copy (gimple, heap, GBB_CONDITIONS (gbb));
GBB_CONDITION_CASES (gbb1) = VEC_copy (gimple, heap, GBB_CONDITION_CASES (gbb));
VEC_safe_insert (poly_bb_p, heap, SCOP_BBS (scop), index + 1, pbb1);
} | /* Creates a poly_bb_p for basic_block BB from the existing PBB. */ | Creates a poly_bb_p for basic_block BB from the existing PBB. | [
"Creates",
"a",
"poly_bb_p",
"for",
"basic_block",
"BB",
"from",
"the",
"existing",
"PBB",
"."
] | static void
new_pbb_from_pbb (scop_p scop, poly_bb_p pbb, basic_block bb)
{
VEC (data_reference_p, heap) *drs = VEC_alloc (data_reference_p, heap, 3);
gimple_bb_p gbb = PBB_BLACK_BOX (pbb);
gimple_bb_p gbb1 = new_gimple_bb (bb, drs);
poly_bb_p pbb1 = new_poly_bb (scop, gbb1);
int index, n = VEC_length (poly_bb_p, SCOP_BBS (scop));
for (index = 0; index < n; index++)
if (VEC_index (poly_bb_p, SCOP_BBS (scop), index) == pbb)
break;
if (PBB_DOMAIN (pbb))
ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron
(&PBB_DOMAIN (pbb1), PBB_DOMAIN (pbb));
GBB_PBB (gbb1) = pbb1;
GBB_CONDITIONS (gbb1) = VEC_copy (gimple, heap, GBB_CONDITIONS (gbb));
GBB_CONDITION_CASES (gbb1) = VEC_copy (gimple, heap, GBB_CONDITION_CASES (gbb));
VEC_safe_insert (poly_bb_p, heap, SCOP_BBS (scop), index + 1, pbb1);
} | [
"static",
"void",
"new_pbb_from_pbb",
"(",
"scop_p",
"scop",
",",
"poly_bb_p",
"pbb",
",",
"basic_block",
"bb",
")",
"{",
"VEC",
"(",
"data_reference_p",
",",
"heap",
")",
"*",
"drs",
"=",
"VEC_alloc",
"(",
"data_reference_p",
",",
"heap",
",",
"3",
")",
";",
"gimple_bb_p",
"gbb",
"=",
"PBB_BLACK_BOX",
"(",
"pbb",
")",
";",
"gimple_bb_p",
"gbb1",
"=",
"new_gimple_bb",
"(",
"bb",
",",
"drs",
")",
";",
"poly_bb_p",
"pbb1",
"=",
"new_poly_bb",
"(",
"scop",
",",
"gbb1",
")",
";",
"int",
"index",
",",
"n",
"=",
"VEC_length",
"(",
"poly_bb_p",
",",
"SCOP_BBS",
"(",
"scop",
")",
")",
";",
"for",
"(",
"index",
"=",
"0",
";",
"index",
"<",
"n",
";",
"index",
"++",
")",
"if",
"(",
"VEC_index",
"(",
"poly_bb_p",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"index",
")",
"==",
"pbb",
")",
"break",
";",
"if",
"(",
"PBB_DOMAIN",
"(",
"pbb",
")",
")",
"ppl_new_Pointset_Powerset_C_Polyhedron_from_Pointset_Powerset_C_Polyhedron",
"(",
"&",
"PBB_DOMAIN",
"(",
"pbb1",
")",
",",
"PBB_DOMAIN",
"(",
"pbb",
")",
")",
";",
"GBB_PBB",
"(",
"gbb1",
")",
"=",
"pbb1",
";",
"GBB_CONDITIONS",
"(",
"gbb1",
")",
"=",
"VEC_copy",
"(",
"gimple",
",",
"heap",
",",
"GBB_CONDITIONS",
"(",
"gbb",
")",
")",
";",
"GBB_CONDITION_CASES",
"(",
"gbb1",
")",
"=",
"VEC_copy",
"(",
"gimple",
",",
"heap",
",",
"GBB_CONDITION_CASES",
"(",
"gbb",
")",
")",
";",
"VEC_safe_insert",
"(",
"poly_bb_p",
",",
"heap",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"index",
"+",
"1",
",",
"pbb1",
")",
";",
"}"
] | Creates a poly_bb_p for basic_block BB from the existing PBB. | [
"Creates",
"a",
"poly_bb_p",
"for",
"basic_block",
"BB",
"from",
"the",
"existing",
"PBB",
"."
] | [
"/* The INDEX of PBB in SCOP_BBS. */"
] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "pbb",
"type": "poly_bb_p"
},
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | create_zero_dim_array | tree | static tree
create_zero_dim_array (tree var, const char *base_name)
{
tree index_type = build_index_type (integer_zero_node);
tree elt_type = TREE_TYPE (var);
tree array_type = build_array_type (elt_type, index_type);
tree base = create_tmp_var (array_type, base_name);
add_referenced_var (base);
return build4 (ARRAY_REF, elt_type, base, integer_zero_node, NULL_TREE,
NULL_TREE);
} | /* Creates a zero dimension array of the same type as VAR. */ | Creates a zero dimension array of the same type as VAR. | [
"Creates",
"a",
"zero",
"dimension",
"array",
"of",
"the",
"same",
"type",
"as",
"VAR",
"."
] | static tree
create_zero_dim_array (tree var, const char *base_name)
{
tree index_type = build_index_type (integer_zero_node);
tree elt_type = TREE_TYPE (var);
tree array_type = build_array_type (elt_type, index_type);
tree base = create_tmp_var (array_type, base_name);
add_referenced_var (base);
return build4 (ARRAY_REF, elt_type, base, integer_zero_node, NULL_TREE,
NULL_TREE);
} | [
"static",
"tree",
"create_zero_dim_array",
"(",
"tree",
"var",
",",
"const",
"char",
"*",
"base_name",
")",
"{",
"tree",
"index_type",
"=",
"build_index_type",
"(",
"integer_zero_node",
")",
";",
"tree",
"elt_type",
"=",
"TREE_TYPE",
"(",
"var",
")",
";",
"tree",
"array_type",
"=",
"build_array_type",
"(",
"elt_type",
",",
"index_type",
")",
";",
"tree",
"base",
"=",
"create_tmp_var",
"(",
"array_type",
",",
"base_name",
")",
";",
"add_referenced_var",
"(",
"base",
")",
";",
"return",
"build4",
"(",
"ARRAY_REF",
",",
"elt_type",
",",
"base",
",",
"integer_zero_node",
",",
"NULL_TREE",
",",
"NULL_TREE",
")",
";",
"}"
] | Creates a zero dimension array of the same type as VAR. | [
"Creates",
"a",
"zero",
"dimension",
"array",
"of",
"the",
"same",
"type",
"as",
"VAR",
"."
] | [] | [
{
"param": "var",
"type": "tree"
},
{
"param": "base_name",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "var",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "base_name",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | scalar_close_phi_node_p | bool | static bool
scalar_close_phi_node_p (gimple phi)
{
if (gimple_code (phi) != GIMPLE_PHI
|| !is_gimple_reg (gimple_phi_result (phi)))
return false;
/* Note that loop close phi nodes should have a single argument
because we translated the representation into a canonical form
before Graphite: see canonicalize_loop_closed_ssa_form. */
return (gimple_phi_num_args (phi) == 1);
} | /* Returns true when PHI is a loop close phi node. */ | Returns true when PHI is a loop close phi node. | [
"Returns",
"true",
"when",
"PHI",
"is",
"a",
"loop",
"close",
"phi",
"node",
"."
] | static bool
scalar_close_phi_node_p (gimple phi)
{
if (gimple_code (phi) != GIMPLE_PHI
|| !is_gimple_reg (gimple_phi_result (phi)))
return false;
return (gimple_phi_num_args (phi) == 1);
} | [
"static",
"bool",
"scalar_close_phi_node_p",
"(",
"gimple",
"phi",
")",
"{",
"if",
"(",
"gimple_code",
"(",
"phi",
")",
"!=",
"GIMPLE_PHI",
"||",
"!",
"is_gimple_reg",
"(",
"gimple_phi_result",
"(",
"phi",
")",
")",
")",
"return",
"false",
";",
"return",
"(",
"gimple_phi_num_args",
"(",
"phi",
")",
"==",
"1",
")",
";",
"}"
] | Returns true when PHI is a loop close phi node. | [
"Returns",
"true",
"when",
"PHI",
"is",
"a",
"loop",
"close",
"phi",
"node",
"."
] | [
"/* Note that loop close phi nodes should have a single argument\n because we translated the representation into a canonical form\n before Graphite: see canonicalize_loop_closed_ssa_form. */"
] | [
{
"param": "phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | propagate_expr_outside_region | void | static void
propagate_expr_outside_region (tree def, tree expr, sese region)
{
imm_use_iterator imm_iter;
gimple use_stmt;
gimple_seq stmts;
bool replaced_once = false;
gcc_assert (TREE_CODE (def) == SSA_NAME);
expr = force_gimple_operand (unshare_expr (expr), &stmts, true,
NULL_TREE);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
if (!is_gimple_debug (use_stmt)
&& !bb_in_sese_p (gimple_bb (use_stmt), region))
{
ssa_op_iter iter;
use_operand_p use_p;
FOR_EACH_PHI_OR_STMT_USE (use_p, use_stmt, iter, SSA_OP_ALL_USES)
if (operand_equal_p (def, USE_FROM_PTR (use_p), 0)
&& (replaced_once = true))
replace_exp (use_p, expr);
update_stmt (use_stmt);
}
if (replaced_once)
{
gsi_insert_seq_on_edge (SESE_ENTRY (region), stmts);
gsi_commit_edge_inserts ();
}
} | /* For a definition DEF in REGION, propagates the expression EXPR in
all the uses of DEF outside REGION. */ | For a definition DEF in REGION, propagates the expression EXPR in
all the uses of DEF outside REGION. | [
"For",
"a",
"definition",
"DEF",
"in",
"REGION",
"propagates",
"the",
"expression",
"EXPR",
"in",
"all",
"the",
"uses",
"of",
"DEF",
"outside",
"REGION",
"."
] | static void
propagate_expr_outside_region (tree def, tree expr, sese region)
{
imm_use_iterator imm_iter;
gimple use_stmt;
gimple_seq stmts;
bool replaced_once = false;
gcc_assert (TREE_CODE (def) == SSA_NAME);
expr = force_gimple_operand (unshare_expr (expr), &stmts, true,
NULL_TREE);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
if (!is_gimple_debug (use_stmt)
&& !bb_in_sese_p (gimple_bb (use_stmt), region))
{
ssa_op_iter iter;
use_operand_p use_p;
FOR_EACH_PHI_OR_STMT_USE (use_p, use_stmt, iter, SSA_OP_ALL_USES)
if (operand_equal_p (def, USE_FROM_PTR (use_p), 0)
&& (replaced_once = true))
replace_exp (use_p, expr);
update_stmt (use_stmt);
}
if (replaced_once)
{
gsi_insert_seq_on_edge (SESE_ENTRY (region), stmts);
gsi_commit_edge_inserts ();
}
} | [
"static",
"void",
"propagate_expr_outside_region",
"(",
"tree",
"def",
",",
"tree",
"expr",
",",
"sese",
"region",
")",
"{",
"imm_use_iterator",
"imm_iter",
";",
"gimple",
"use_stmt",
";",
"gimple_seq",
"stmts",
";",
"bool",
"replaced_once",
"=",
"false",
";",
"gcc_assert",
"(",
"TREE_CODE",
"(",
"def",
")",
"==",
"SSA_NAME",
")",
";",
"expr",
"=",
"force_gimple_operand",
"(",
"unshare_expr",
"(",
"expr",
")",
",",
"&",
"stmts",
",",
"true",
",",
"NULL_TREE",
")",
";",
"FOR_EACH_IMM_USE_STMT",
"(",
"use_stmt",
",",
"imm_iter",
",",
"def",
")",
"",
"if",
"(",
"!",
"is_gimple_debug",
"(",
"use_stmt",
")",
"&&",
"!",
"bb_in_sese_p",
"(",
"gimple_bb",
"(",
"use_stmt",
")",
",",
"region",
")",
")",
"{",
"ssa_op_iter",
"iter",
";",
"use_operand_p",
"use_p",
";",
"FOR_EACH_PHI_OR_STMT_USE",
"(",
"use_p",
",",
"use_stmt",
",",
"iter",
",",
"SSA_OP_ALL_USES",
")",
"",
"if",
"(",
"operand_equal_p",
"(",
"def",
",",
"USE_FROM_PTR",
"(",
"use_p",
")",
",",
"0",
")",
"&&",
"(",
"replaced_once",
"=",
"true",
")",
")",
"replace_exp",
"(",
"use_p",
",",
"expr",
")",
";",
"update_stmt",
"(",
"use_stmt",
")",
";",
"}",
"if",
"(",
"replaced_once",
")",
"{",
"gsi_insert_seq_on_edge",
"(",
"SESE_ENTRY",
"(",
"region",
")",
",",
"stmts",
")",
";",
"gsi_commit_edge_inserts",
"(",
")",
";",
"}",
"}"
] | For a definition DEF in REGION, propagates the expression EXPR in
all the uses of DEF outside REGION. | [
"For",
"a",
"definition",
"DEF",
"in",
"REGION",
"propagates",
"the",
"expression",
"EXPR",
"in",
"all",
"the",
"uses",
"of",
"DEF",
"outside",
"REGION",
"."
] | [] | [
{
"param": "def",
"type": "tree"
},
{
"param": "expr",
"type": "tree"
},
{
"param": "region",
"type": "sese"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "def",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "expr",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "region",
"type": "sese",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_close_phi_out_of_ssa | void | static void
rewrite_close_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
{
sese region = SCOP_REGION (scop);
gimple phi = gsi_stmt (*psi);
tree res = gimple_phi_result (phi);
tree var = SSA_NAME_VAR (res);
basic_block bb = gimple_bb (phi);
gimple_stmt_iterator gsi = gsi_after_labels (bb);
tree arg = gimple_phi_arg_def (phi, 0);
gimple stmt;
/* Note that loop close phi nodes should have a single argument
because we translated the representation into a canonical form
before Graphite: see canonicalize_loop_closed_ssa_form. */
gcc_assert (gimple_phi_num_args (phi) == 1);
/* The phi node can be a non close phi node, when its argument is
invariant, or a default definition. */
if (is_gimple_min_invariant (arg)
|| SSA_NAME_IS_DEFAULT_DEF (arg))
{
propagate_expr_outside_region (res, arg, region);
gsi_next (psi);
return;
}
else if (gimple_bb (SSA_NAME_DEF_STMT (arg))->loop_father == bb->loop_father)
{
propagate_expr_outside_region (res, arg, region);
stmt = gimple_build_assign (res, arg);
remove_phi_node (psi, false);
gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
SSA_NAME_DEF_STMT (res) = stmt;
return;
}
/* If res is scev analyzable and is not a scalar value, it is safe
to ignore the close phi node: it will be code generated in the
out of Graphite pass. */
else if (scev_analyzable_p (res, region))
{
loop_p loop = loop_containing_stmt (SSA_NAME_DEF_STMT (res));
tree scev;
if (!loop_in_sese_p (loop, region))
{
loop = loop_containing_stmt (SSA_NAME_DEF_STMT (arg));
scev = scalar_evolution_in_region (region, loop, arg);
scev = compute_overall_effect_of_inner_loop (loop, scev);
}
else
scev = scalar_evolution_in_region (region, loop, res);
if (tree_does_not_contain_chrecs (scev))
propagate_expr_outside_region (res, scev, region);
gsi_next (psi);
return;
}
else
{
tree zero_dim_array = create_zero_dim_array (var, "Close_Phi");
stmt = gimple_build_assign (res, zero_dim_array);
if (TREE_CODE (arg) == SSA_NAME)
insert_out_of_ssa_copy (scop, zero_dim_array, arg,
SSA_NAME_DEF_STMT (arg));
else
insert_out_of_ssa_copy_on_edge (scop, single_pred_edge (bb),
zero_dim_array, arg);
}
remove_phi_node (psi, false);
SSA_NAME_DEF_STMT (res) = stmt;
insert_stmts (scop, stmt, NULL, gsi_after_labels (bb));
} | /* Rewrite out of SSA the reduction phi node at PSI by creating a zero
dimension array for it. */ | Rewrite out of SSA the reduction phi node at PSI by creating a zero
dimension array for it. | [
"Rewrite",
"out",
"of",
"SSA",
"the",
"reduction",
"phi",
"node",
"at",
"PSI",
"by",
"creating",
"a",
"zero",
"dimension",
"array",
"for",
"it",
"."
] | static void
rewrite_close_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
{
sese region = SCOP_REGION (scop);
gimple phi = gsi_stmt (*psi);
tree res = gimple_phi_result (phi);
tree var = SSA_NAME_VAR (res);
basic_block bb = gimple_bb (phi);
gimple_stmt_iterator gsi = gsi_after_labels (bb);
tree arg = gimple_phi_arg_def (phi, 0);
gimple stmt;
gcc_assert (gimple_phi_num_args (phi) == 1);
if (is_gimple_min_invariant (arg)
|| SSA_NAME_IS_DEFAULT_DEF (arg))
{
propagate_expr_outside_region (res, arg, region);
gsi_next (psi);
return;
}
else if (gimple_bb (SSA_NAME_DEF_STMT (arg))->loop_father == bb->loop_father)
{
propagate_expr_outside_region (res, arg, region);
stmt = gimple_build_assign (res, arg);
remove_phi_node (psi, false);
gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
SSA_NAME_DEF_STMT (res) = stmt;
return;
}
else if (scev_analyzable_p (res, region))
{
loop_p loop = loop_containing_stmt (SSA_NAME_DEF_STMT (res));
tree scev;
if (!loop_in_sese_p (loop, region))
{
loop = loop_containing_stmt (SSA_NAME_DEF_STMT (arg));
scev = scalar_evolution_in_region (region, loop, arg);
scev = compute_overall_effect_of_inner_loop (loop, scev);
}
else
scev = scalar_evolution_in_region (region, loop, res);
if (tree_does_not_contain_chrecs (scev))
propagate_expr_outside_region (res, scev, region);
gsi_next (psi);
return;
}
else
{
tree zero_dim_array = create_zero_dim_array (var, "Close_Phi");
stmt = gimple_build_assign (res, zero_dim_array);
if (TREE_CODE (arg) == SSA_NAME)
insert_out_of_ssa_copy (scop, zero_dim_array, arg,
SSA_NAME_DEF_STMT (arg));
else
insert_out_of_ssa_copy_on_edge (scop, single_pred_edge (bb),
zero_dim_array, arg);
}
remove_phi_node (psi, false);
SSA_NAME_DEF_STMT (res) = stmt;
insert_stmts (scop, stmt, NULL, gsi_after_labels (bb));
} | [
"static",
"void",
"rewrite_close_phi_out_of_ssa",
"(",
"scop_p",
"scop",
",",
"gimple_stmt_iterator",
"*",
"psi",
")",
"{",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"gimple",
"phi",
"=",
"gsi_stmt",
"(",
"*",
"psi",
")",
";",
"tree",
"res",
"=",
"gimple_phi_result",
"(",
"phi",
")",
";",
"tree",
"var",
"=",
"SSA_NAME_VAR",
"(",
"res",
")",
";",
"basic_block",
"bb",
"=",
"gimple_bb",
"(",
"phi",
")",
";",
"gimple_stmt_iterator",
"gsi",
"=",
"gsi_after_labels",
"(",
"bb",
")",
";",
"tree",
"arg",
"=",
"gimple_phi_arg_def",
"(",
"phi",
",",
"0",
")",
";",
"gimple",
"stmt",
";",
"gcc_assert",
"(",
"gimple_phi_num_args",
"(",
"phi",
")",
"==",
"1",
")",
";",
"if",
"(",
"is_gimple_min_invariant",
"(",
"arg",
")",
"||",
"SSA_NAME_IS_DEFAULT_DEF",
"(",
"arg",
")",
")",
"{",
"propagate_expr_outside_region",
"(",
"res",
",",
"arg",
",",
"region",
")",
";",
"gsi_next",
"(",
"psi",
")",
";",
"return",
";",
"}",
"else",
"if",
"(",
"gimple_bb",
"(",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
")",
"->",
"loop_father",
"==",
"bb",
"->",
"loop_father",
")",
"{",
"propagate_expr_outside_region",
"(",
"res",
",",
"arg",
",",
"region",
")",
";",
"stmt",
"=",
"gimple_build_assign",
"(",
"res",
",",
"arg",
")",
";",
"remove_phi_node",
"(",
"psi",
",",
"false",
")",
";",
"gsi_insert_before",
"(",
"&",
"gsi",
",",
"stmt",
",",
"GSI_NEW_STMT",
")",
";",
"SSA_NAME_DEF_STMT",
"(",
"res",
")",
"=",
"stmt",
";",
"return",
";",
"}",
"else",
"if",
"(",
"scev_analyzable_p",
"(",
"res",
",",
"region",
")",
")",
"{",
"loop_p",
"loop",
"=",
"loop_containing_stmt",
"(",
"SSA_NAME_DEF_STMT",
"(",
"res",
")",
")",
";",
"tree",
"scev",
";",
"if",
"(",
"!",
"loop_in_sese_p",
"(",
"loop",
",",
"region",
")",
")",
"{",
"loop",
"=",
"loop_containing_stmt",
"(",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
")",
";",
"scev",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"arg",
")",
";",
"scev",
"=",
"compute_overall_effect_of_inner_loop",
"(",
"loop",
",",
"scev",
")",
";",
"}",
"else",
"scev",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"res",
")",
";",
"if",
"(",
"tree_does_not_contain_chrecs",
"(",
"scev",
")",
")",
"propagate_expr_outside_region",
"(",
"res",
",",
"scev",
",",
"region",
")",
";",
"gsi_next",
"(",
"psi",
")",
";",
"return",
";",
"}",
"else",
"{",
"tree",
"zero_dim_array",
"=",
"create_zero_dim_array",
"(",
"var",
",",
"\"",
"\"",
")",
";",
"stmt",
"=",
"gimple_build_assign",
"(",
"res",
",",
"zero_dim_array",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"arg",
")",
"==",
"SSA_NAME",
")",
"insert_out_of_ssa_copy",
"(",
"scop",
",",
"zero_dim_array",
",",
"arg",
",",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
")",
";",
"else",
"insert_out_of_ssa_copy_on_edge",
"(",
"scop",
",",
"single_pred_edge",
"(",
"bb",
")",
",",
"zero_dim_array",
",",
"arg",
")",
";",
"}",
"remove_phi_node",
"(",
"psi",
",",
"false",
")",
";",
"SSA_NAME_DEF_STMT",
"(",
"res",
")",
"=",
"stmt",
";",
"insert_stmts",
"(",
"scop",
",",
"stmt",
",",
"NULL",
",",
"gsi_after_labels",
"(",
"bb",
")",
")",
";",
"}"
] | Rewrite out of SSA the reduction phi node at PSI by creating a zero
dimension array for it. | [
"Rewrite",
"out",
"of",
"SSA",
"the",
"reduction",
"phi",
"node",
"at",
"PSI",
"by",
"creating",
"a",
"zero",
"dimension",
"array",
"for",
"it",
"."
] | [
"/* Note that loop close phi nodes should have a single argument\n because we translated the representation into a canonical form\n before Graphite: see canonicalize_loop_closed_ssa_form. */",
"/* The phi node can be a non close phi node, when its argument is\n invariant, or a default definition. */",
"/* If res is scev analyzable and is not a scalar value, it is safe\n to ignore the close phi node: it will be code generated in the\n out of Graphite pass. */"
] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "psi",
"type": "gimple_stmt_iterator"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "psi",
"type": "gimple_stmt_iterator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_phi_out_of_ssa | void | static void
rewrite_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
{
size_t i;
gimple phi = gsi_stmt (*psi);
basic_block bb = gimple_bb (phi);
tree res = gimple_phi_result (phi);
tree var = SSA_NAME_VAR (res);
tree zero_dim_array = create_zero_dim_array (var, "phi_out_of_ssa");
gimple stmt;
gimple_seq stmts;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
/* Avoid the insertion of code in the loop latch to please the
pattern matching of the vectorizer. */
if (TREE_CODE (arg) == SSA_NAME
&& e->src == bb->loop_father->latch)
insert_out_of_ssa_copy (scop, zero_dim_array, arg,
SSA_NAME_DEF_STMT (arg));
else
insert_out_of_ssa_copy_on_edge (scop, e, zero_dim_array, arg);
}
var = force_gimple_operand (zero_dim_array, &stmts, true, NULL_TREE);
stmt = gimple_build_assign (res, var);
remove_phi_node (psi, false);
SSA_NAME_DEF_STMT (res) = stmt;
insert_stmts (scop, stmt, stmts, gsi_after_labels (bb));
} | /* Rewrite out of SSA the reduction phi node at PSI by creating a zero
dimension array for it. */ | Rewrite out of SSA the reduction phi node at PSI by creating a zero
dimension array for it. | [
"Rewrite",
"out",
"of",
"SSA",
"the",
"reduction",
"phi",
"node",
"at",
"PSI",
"by",
"creating",
"a",
"zero",
"dimension",
"array",
"for",
"it",
"."
] | static void
rewrite_phi_out_of_ssa (scop_p scop, gimple_stmt_iterator *psi)
{
size_t i;
gimple phi = gsi_stmt (*psi);
basic_block bb = gimple_bb (phi);
tree res = gimple_phi_result (phi);
tree var = SSA_NAME_VAR (res);
tree zero_dim_array = create_zero_dim_array (var, "phi_out_of_ssa");
gimple stmt;
gimple_seq stmts;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
tree arg = gimple_phi_arg_def (phi, i);
edge e = gimple_phi_arg_edge (phi, i);
if (TREE_CODE (arg) == SSA_NAME
&& e->src == bb->loop_father->latch)
insert_out_of_ssa_copy (scop, zero_dim_array, arg,
SSA_NAME_DEF_STMT (arg));
else
insert_out_of_ssa_copy_on_edge (scop, e, zero_dim_array, arg);
}
var = force_gimple_operand (zero_dim_array, &stmts, true, NULL_TREE);
stmt = gimple_build_assign (res, var);
remove_phi_node (psi, false);
SSA_NAME_DEF_STMT (res) = stmt;
insert_stmts (scop, stmt, stmts, gsi_after_labels (bb));
} | [
"static",
"void",
"rewrite_phi_out_of_ssa",
"(",
"scop_p",
"scop",
",",
"gimple_stmt_iterator",
"*",
"psi",
")",
"{",
"size_t",
"i",
";",
"gimple",
"phi",
"=",
"gsi_stmt",
"(",
"*",
"psi",
")",
";",
"basic_block",
"bb",
"=",
"gimple_bb",
"(",
"phi",
")",
";",
"tree",
"res",
"=",
"gimple_phi_result",
"(",
"phi",
")",
";",
"tree",
"var",
"=",
"SSA_NAME_VAR",
"(",
"res",
")",
";",
"tree",
"zero_dim_array",
"=",
"create_zero_dim_array",
"(",
"var",
",",
"\"",
"\"",
")",
";",
"gimple",
"stmt",
";",
"gimple_seq",
"stmts",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"gimple_phi_num_args",
"(",
"phi",
")",
";",
"i",
"++",
")",
"{",
"tree",
"arg",
"=",
"gimple_phi_arg_def",
"(",
"phi",
",",
"i",
")",
";",
"edge",
"e",
"=",
"gimple_phi_arg_edge",
"(",
"phi",
",",
"i",
")",
";",
"if",
"(",
"TREE_CODE",
"(",
"arg",
")",
"==",
"SSA_NAME",
"&&",
"e",
"->",
"src",
"==",
"bb",
"->",
"loop_father",
"->",
"latch",
")",
"insert_out_of_ssa_copy",
"(",
"scop",
",",
"zero_dim_array",
",",
"arg",
",",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
")",
";",
"else",
"insert_out_of_ssa_copy_on_edge",
"(",
"scop",
",",
"e",
",",
"zero_dim_array",
",",
"arg",
")",
";",
"}",
"var",
"=",
"force_gimple_operand",
"(",
"zero_dim_array",
",",
"&",
"stmts",
",",
"true",
",",
"NULL_TREE",
")",
";",
"stmt",
"=",
"gimple_build_assign",
"(",
"res",
",",
"var",
")",
";",
"remove_phi_node",
"(",
"psi",
",",
"false",
")",
";",
"SSA_NAME_DEF_STMT",
"(",
"res",
")",
"=",
"stmt",
";",
"insert_stmts",
"(",
"scop",
",",
"stmt",
",",
"stmts",
",",
"gsi_after_labels",
"(",
"bb",
")",
")",
";",
"}"
] | Rewrite out of SSA the reduction phi node at PSI by creating a zero
dimension array for it. | [
"Rewrite",
"out",
"of",
"SSA",
"the",
"reduction",
"phi",
"node",
"at",
"PSI",
"by",
"creating",
"a",
"zero",
"dimension",
"array",
"for",
"it",
"."
] | [
"/* Avoid the insertion of code in the loop latch to please the\n\t pattern matching of the vectorizer. */"
] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "psi",
"type": "gimple_stmt_iterator"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "psi",
"type": "gimple_stmt_iterator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_reductions_out_of_ssa | void | static void
rewrite_reductions_out_of_ssa (scop_p scop)
{
basic_block bb;
gimple_stmt_iterator psi;
sese region = SCOP_REGION (scop);
FOR_EACH_BB (bb)
if (bb_in_sese_p (bb, region))
for (psi = gsi_start_phis (bb); !gsi_end_p (psi);)
{
gimple phi = gsi_stmt (psi);
if (!is_gimple_reg (gimple_phi_result (phi)))
{
gsi_next (&psi);
continue;
}
if (gimple_phi_num_args (phi) > 1
&& degenerate_phi_result (phi))
rewrite_degenerate_phi (&psi);
else if (scalar_close_phi_node_p (phi))
rewrite_close_phi_out_of_ssa (scop, &psi);
else if (reduction_phi_p (region, &psi))
rewrite_phi_out_of_ssa (scop, &psi);
}
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
verify_loop_closed_ssa (true);
#endif
} | /* Rewrite out of SSA all the reduction phi nodes of SCOP. */ | Rewrite out of SSA all the reduction phi nodes of SCOP. | [
"Rewrite",
"out",
"of",
"SSA",
"all",
"the",
"reduction",
"phi",
"nodes",
"of",
"SCOP",
"."
] | static void
rewrite_reductions_out_of_ssa (scop_p scop)
{
basic_block bb;
gimple_stmt_iterator psi;
sese region = SCOP_REGION (scop);
FOR_EACH_BB (bb)
if (bb_in_sese_p (bb, region))
for (psi = gsi_start_phis (bb); !gsi_end_p (psi);)
{
gimple phi = gsi_stmt (psi);
if (!is_gimple_reg (gimple_phi_result (phi)))
{
gsi_next (&psi);
continue;
}
if (gimple_phi_num_args (phi) > 1
&& degenerate_phi_result (phi))
rewrite_degenerate_phi (&psi);
else if (scalar_close_phi_node_p (phi))
rewrite_close_phi_out_of_ssa (scop, &psi);
else if (reduction_phi_p (region, &psi))
rewrite_phi_out_of_ssa (scop, &psi);
}
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
verify_loop_closed_ssa (true);
#endif
} | [
"static",
"void",
"rewrite_reductions_out_of_ssa",
"(",
"scop_p",
"scop",
")",
"{",
"basic_block",
"bb",
";",
"gimple_stmt_iterator",
"psi",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"FOR_EACH_BB",
"(",
"bb",
")",
"if",
"(",
"bb_in_sese_p",
"(",
"bb",
",",
"region",
")",
")",
"",
"for",
"(",
"psi",
"=",
"gsi_start_phis",
"(",
"bb",
")",
";",
"!",
"gsi_end_p",
"(",
"psi",
")",
";",
")",
"{",
"gimple",
"phi",
"=",
"gsi_stmt",
"(",
"psi",
")",
";",
"if",
"(",
"!",
"is_gimple_reg",
"(",
"gimple_phi_result",
"(",
"phi",
")",
")",
")",
"{",
"gsi_next",
"(",
"&",
"psi",
")",
";",
"continue",
";",
"}",
"if",
"(",
"gimple_phi_num_args",
"(",
"phi",
")",
">",
"1",
"&&",
"degenerate_phi_result",
"(",
"phi",
")",
")",
"rewrite_degenerate_phi",
"(",
"&",
"psi",
")",
";",
"else",
"if",
"(",
"scalar_close_phi_node_p",
"(",
"phi",
")",
")",
"rewrite_close_phi_out_of_ssa",
"(",
"scop",
",",
"&",
"psi",
")",
";",
"else",
"if",
"(",
"reduction_phi_p",
"(",
"region",
",",
"&",
"psi",
")",
")",
"rewrite_phi_out_of_ssa",
"(",
"scop",
",",
"&",
"psi",
")",
";",
"}",
"update_ssa",
"(",
"TODO_update_ssa",
")",
";",
"#ifdef",
"ENABLE_CHECKING",
"verify_loop_closed_ssa",
"(",
"true",
")",
";",
"#endif",
"}"
] | Rewrite out of SSA all the reduction phi nodes of SCOP. | [
"Rewrite",
"out",
"of",
"SSA",
"all",
"the",
"reduction",
"phi",
"nodes",
"of",
"SCOP",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_cross_bb_scalar_dependence | void | static void
rewrite_cross_bb_scalar_dependence (scop_p scop, tree zero_dim_array,
tree def, gimple use_stmt)
{
tree var = SSA_NAME_VAR (def);
gimple name_stmt = gimple_build_assign (var, zero_dim_array);
tree name = make_ssa_name (var, name_stmt);
ssa_op_iter iter;
use_operand_p use_p;
gcc_assert (gimple_code (use_stmt) != GIMPLE_PHI);
gimple_assign_set_lhs (name_stmt, name);
insert_stmts (scop, name_stmt, NULL, gsi_for_stmt (use_stmt));
FOR_EACH_SSA_USE_OPERAND (use_p, use_stmt, iter, SSA_OP_ALL_USES)
if (operand_equal_p (def, USE_FROM_PTR (use_p), 0))
replace_exp (use_p, name);
update_stmt (use_stmt);
} | /* Rewrite the scalar dependence of DEF used in USE_STMT with a memory
read from ZERO_DIM_ARRAY. */ | Rewrite the scalar dependence of DEF used in USE_STMT with a memory
read from ZERO_DIM_ARRAY. | [
"Rewrite",
"the",
"scalar",
"dependence",
"of",
"DEF",
"used",
"in",
"USE_STMT",
"with",
"a",
"memory",
"read",
"from",
"ZERO_DIM_ARRAY",
"."
] | static void
rewrite_cross_bb_scalar_dependence (scop_p scop, tree zero_dim_array,
tree def, gimple use_stmt)
{
tree var = SSA_NAME_VAR (def);
gimple name_stmt = gimple_build_assign (var, zero_dim_array);
tree name = make_ssa_name (var, name_stmt);
ssa_op_iter iter;
use_operand_p use_p;
gcc_assert (gimple_code (use_stmt) != GIMPLE_PHI);
gimple_assign_set_lhs (name_stmt, name);
insert_stmts (scop, name_stmt, NULL, gsi_for_stmt (use_stmt));
FOR_EACH_SSA_USE_OPERAND (use_p, use_stmt, iter, SSA_OP_ALL_USES)
if (operand_equal_p (def, USE_FROM_PTR (use_p), 0))
replace_exp (use_p, name);
update_stmt (use_stmt);
} | [
"static",
"void",
"rewrite_cross_bb_scalar_dependence",
"(",
"scop_p",
"scop",
",",
"tree",
"zero_dim_array",
",",
"tree",
"def",
",",
"gimple",
"use_stmt",
")",
"{",
"tree",
"var",
"=",
"SSA_NAME_VAR",
"(",
"def",
")",
";",
"gimple",
"name_stmt",
"=",
"gimple_build_assign",
"(",
"var",
",",
"zero_dim_array",
")",
";",
"tree",
"name",
"=",
"make_ssa_name",
"(",
"var",
",",
"name_stmt",
")",
";",
"ssa_op_iter",
"iter",
";",
"use_operand_p",
"use_p",
";",
"gcc_assert",
"(",
"gimple_code",
"(",
"use_stmt",
")",
"!=",
"GIMPLE_PHI",
")",
";",
"gimple_assign_set_lhs",
"(",
"name_stmt",
",",
"name",
")",
";",
"insert_stmts",
"(",
"scop",
",",
"name_stmt",
",",
"NULL",
",",
"gsi_for_stmt",
"(",
"use_stmt",
")",
")",
";",
"FOR_EACH_SSA_USE_OPERAND",
"(",
"use_p",
",",
"use_stmt",
",",
"iter",
",",
"SSA_OP_ALL_USES",
")",
"",
"if",
"(",
"operand_equal_p",
"(",
"def",
",",
"USE_FROM_PTR",
"(",
"use_p",
")",
",",
"0",
")",
")",
"replace_exp",
"(",
"use_p",
",",
"name",
")",
";",
"update_stmt",
"(",
"use_stmt",
")",
";",
"}"
] | Rewrite the scalar dependence of DEF used in USE_STMT with a memory
read from ZERO_DIM_ARRAY. | [
"Rewrite",
"the",
"scalar",
"dependence",
"of",
"DEF",
"used",
"in",
"USE_STMT",
"with",
"a",
"memory",
"read",
"from",
"ZERO_DIM_ARRAY",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "zero_dim_array",
"type": "tree"
},
{
"param": "def",
"type": "tree"
},
{
"param": "use_stmt",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "zero_dim_array",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "def",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "use_stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | handle_scalar_deps_crossing_scop_limits | void | static void
handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple stmt)
{
tree var = create_tmp_reg (TREE_TYPE (def), NULL);
tree new_name = make_ssa_name (var, stmt);
bool needs_copy = false;
use_operand_p use_p;
imm_use_iterator imm_iter;
gimple use_stmt;
sese region = SCOP_REGION (scop);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
{
if (!bb_in_sese_p (gimple_bb (use_stmt), region))
{
FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
{
SET_USE (use_p, new_name);
}
update_stmt (use_stmt);
needs_copy = true;
}
}
/* Insert in the empty BB just after the scop a use of DEF such
that the rewrite of cross_bb_scalar_dependences won't insert
arrays everywhere else. */
if (needs_copy)
{
gimple assign = gimple_build_assign (new_name, def);
gimple_stmt_iterator psi = gsi_after_labels (SESE_EXIT (region)->dest);
add_referenced_var (var);
SSA_NAME_DEF_STMT (new_name) = assign;
update_stmt (assign);
gsi_insert_before (&psi, assign, GSI_SAME_STMT);
}
} | /* For every definition DEF in the SCOP that is used outside the scop,
insert a closing-scop definition in the basic block just after this
SCOP. */ | For every definition DEF in the SCOP that is used outside the scop,
insert a closing-scop definition in the basic block just after this
SCOP. | [
"For",
"every",
"definition",
"DEF",
"in",
"the",
"SCOP",
"that",
"is",
"used",
"outside",
"the",
"scop",
"insert",
"a",
"closing",
"-",
"scop",
"definition",
"in",
"the",
"basic",
"block",
"just",
"after",
"this",
"SCOP",
"."
] | static void
handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple stmt)
{
tree var = create_tmp_reg (TREE_TYPE (def), NULL);
tree new_name = make_ssa_name (var, stmt);
bool needs_copy = false;
use_operand_p use_p;
imm_use_iterator imm_iter;
gimple use_stmt;
sese region = SCOP_REGION (scop);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
{
if (!bb_in_sese_p (gimple_bb (use_stmt), region))
{
FOR_EACH_IMM_USE_ON_STMT (use_p, imm_iter)
{
SET_USE (use_p, new_name);
}
update_stmt (use_stmt);
needs_copy = true;
}
}
if (needs_copy)
{
gimple assign = gimple_build_assign (new_name, def);
gimple_stmt_iterator psi = gsi_after_labels (SESE_EXIT (region)->dest);
add_referenced_var (var);
SSA_NAME_DEF_STMT (new_name) = assign;
update_stmt (assign);
gsi_insert_before (&psi, assign, GSI_SAME_STMT);
}
} | [
"static",
"void",
"handle_scalar_deps_crossing_scop_limits",
"(",
"scop_p",
"scop",
",",
"tree",
"def",
",",
"gimple",
"stmt",
")",
"{",
"tree",
"var",
"=",
"create_tmp_reg",
"(",
"TREE_TYPE",
"(",
"def",
")",
",",
"NULL",
")",
";",
"tree",
"new_name",
"=",
"make_ssa_name",
"(",
"var",
",",
"stmt",
")",
";",
"bool",
"needs_copy",
"=",
"false",
";",
"use_operand_p",
"use_p",
";",
"imm_use_iterator",
"imm_iter",
";",
"gimple",
"use_stmt",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"FOR_EACH_IMM_USE_STMT",
"(",
"use_stmt",
",",
"imm_iter",
",",
"def",
")",
"",
"{",
"if",
"(",
"!",
"bb_in_sese_p",
"(",
"gimple_bb",
"(",
"use_stmt",
")",
",",
"region",
")",
")",
"{",
"FOR_EACH_IMM_USE_ON_STMT",
"(",
"use_p",
",",
"imm_iter",
")",
"",
"{",
"SET_USE",
"(",
"use_p",
",",
"new_name",
")",
";",
"}",
"update_stmt",
"(",
"use_stmt",
")",
";",
"needs_copy",
"=",
"true",
";",
"}",
"}",
"if",
"(",
"needs_copy",
")",
"{",
"gimple",
"assign",
"=",
"gimple_build_assign",
"(",
"new_name",
",",
"def",
")",
";",
"gimple_stmt_iterator",
"psi",
"=",
"gsi_after_labels",
"(",
"SESE_EXIT",
"(",
"region",
")",
"->",
"dest",
")",
";",
"add_referenced_var",
"(",
"var",
")",
";",
"SSA_NAME_DEF_STMT",
"(",
"new_name",
")",
"=",
"assign",
";",
"update_stmt",
"(",
"assign",
")",
";",
"gsi_insert_before",
"(",
"&",
"psi",
",",
"assign",
",",
"GSI_SAME_STMT",
")",
";",
"}",
"}"
] | For every definition DEF in the SCOP that is used outside the scop,
insert a closing-scop definition in the basic block just after this
SCOP. | [
"For",
"every",
"definition",
"DEF",
"in",
"the",
"SCOP",
"that",
"is",
"used",
"outside",
"the",
"scop",
"insert",
"a",
"closing",
"-",
"scop",
"definition",
"in",
"the",
"basic",
"block",
"just",
"after",
"this",
"SCOP",
"."
] | [
"/* Insert in the empty BB just after the scop a use of DEF such\n that the rewrite of cross_bb_scalar_dependences won't insert\n arrays everywhere else. */"
] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "def",
"type": "tree"
},
{
"param": "stmt",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "def",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_cross_bb_scalar_deps | bool | static bool
rewrite_cross_bb_scalar_deps (scop_p scop, gimple_stmt_iterator *gsi)
{
sese region = SCOP_REGION (scop);
gimple stmt = gsi_stmt (*gsi);
imm_use_iterator imm_iter;
tree def;
basic_block def_bb;
tree zero_dim_array = NULL_TREE;
gimple use_stmt;
bool res = false;
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
def = gimple_assign_lhs (stmt);
break;
case GIMPLE_CALL:
def = gimple_call_lhs (stmt);
break;
default:
return false;
}
if (!def
|| !is_gimple_reg (def))
return false;
if (scev_analyzable_p (def, region))
{
loop_p loop = loop_containing_stmt (SSA_NAME_DEF_STMT (def));
tree scev = scalar_evolution_in_region (region, loop, def);
if (tree_contains_chrecs (scev, NULL))
return false;
propagate_expr_outside_region (def, scev, region);
return true;
}
def_bb = gimple_bb (stmt);
handle_scalar_deps_crossing_scop_limits (scop, def, stmt);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
if (gimple_code (use_stmt) == GIMPLE_PHI
&& (res = true))
{
gimple_stmt_iterator psi = gsi_for_stmt (use_stmt);
if (scalar_close_phi_node_p (gsi_stmt (psi)))
rewrite_close_phi_out_of_ssa (scop, &psi);
else
rewrite_phi_out_of_ssa (scop, &psi);
}
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
if (gimple_code (use_stmt) != GIMPLE_PHI
&& def_bb != gimple_bb (use_stmt)
&& !is_gimple_debug (use_stmt)
&& (res = true))
{
if (!zero_dim_array)
{
zero_dim_array = create_zero_dim_array
(SSA_NAME_VAR (def), "Cross_BB_scalar_dependence");
insert_out_of_ssa_copy (scop, zero_dim_array, def,
SSA_NAME_DEF_STMT (def));
gsi_next (gsi);
}
rewrite_cross_bb_scalar_dependence (scop, zero_dim_array,
def, use_stmt);
}
return res;
} | /* Rewrite the scalar dependences crossing the boundary of the BB
containing STMT with an array. Return true when something has been
changed. */ | Rewrite the scalar dependences crossing the boundary of the BB
containing STMT with an array. Return true when something has been
changed. | [
"Rewrite",
"the",
"scalar",
"dependences",
"crossing",
"the",
"boundary",
"of",
"the",
"BB",
"containing",
"STMT",
"with",
"an",
"array",
".",
"Return",
"true",
"when",
"something",
"has",
"been",
"changed",
"."
] | static bool
rewrite_cross_bb_scalar_deps (scop_p scop, gimple_stmt_iterator *gsi)
{
sese region = SCOP_REGION (scop);
gimple stmt = gsi_stmt (*gsi);
imm_use_iterator imm_iter;
tree def;
basic_block def_bb;
tree zero_dim_array = NULL_TREE;
gimple use_stmt;
bool res = false;
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
def = gimple_assign_lhs (stmt);
break;
case GIMPLE_CALL:
def = gimple_call_lhs (stmt);
break;
default:
return false;
}
if (!def
|| !is_gimple_reg (def))
return false;
if (scev_analyzable_p (def, region))
{
loop_p loop = loop_containing_stmt (SSA_NAME_DEF_STMT (def));
tree scev = scalar_evolution_in_region (region, loop, def);
if (tree_contains_chrecs (scev, NULL))
return false;
propagate_expr_outside_region (def, scev, region);
return true;
}
def_bb = gimple_bb (stmt);
handle_scalar_deps_crossing_scop_limits (scop, def, stmt);
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
if (gimple_code (use_stmt) == GIMPLE_PHI
&& (res = true))
{
gimple_stmt_iterator psi = gsi_for_stmt (use_stmt);
if (scalar_close_phi_node_p (gsi_stmt (psi)))
rewrite_close_phi_out_of_ssa (scop, &psi);
else
rewrite_phi_out_of_ssa (scop, &psi);
}
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter, def)
if (gimple_code (use_stmt) != GIMPLE_PHI
&& def_bb != gimple_bb (use_stmt)
&& !is_gimple_debug (use_stmt)
&& (res = true))
{
if (!zero_dim_array)
{
zero_dim_array = create_zero_dim_array
(SSA_NAME_VAR (def), "Cross_BB_scalar_dependence");
insert_out_of_ssa_copy (scop, zero_dim_array, def,
SSA_NAME_DEF_STMT (def));
gsi_next (gsi);
}
rewrite_cross_bb_scalar_dependence (scop, zero_dim_array,
def, use_stmt);
}
return res;
} | [
"static",
"bool",
"rewrite_cross_bb_scalar_deps",
"(",
"scop_p",
"scop",
",",
"gimple_stmt_iterator",
"*",
"gsi",
")",
"{",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"gimple",
"stmt",
"=",
"gsi_stmt",
"(",
"*",
"gsi",
")",
";",
"imm_use_iterator",
"imm_iter",
";",
"tree",
"def",
";",
"basic_block",
"def_bb",
";",
"tree",
"zero_dim_array",
"=",
"NULL_TREE",
";",
"gimple",
"use_stmt",
";",
"bool",
"res",
"=",
"false",
";",
"switch",
"(",
"gimple_code",
"(",
"stmt",
")",
")",
"{",
"case",
"GIMPLE_ASSIGN",
":",
"def",
"=",
"gimple_assign_lhs",
"(",
"stmt",
")",
";",
"break",
";",
"case",
"GIMPLE_CALL",
":",
"def",
"=",
"gimple_call_lhs",
"(",
"stmt",
")",
";",
"break",
";",
"default",
":",
"return",
"false",
";",
"}",
"if",
"(",
"!",
"def",
"||",
"!",
"is_gimple_reg",
"(",
"def",
")",
")",
"return",
"false",
";",
"if",
"(",
"scev_analyzable_p",
"(",
"def",
",",
"region",
")",
")",
"{",
"loop_p",
"loop",
"=",
"loop_containing_stmt",
"(",
"SSA_NAME_DEF_STMT",
"(",
"def",
")",
")",
";",
"tree",
"scev",
"=",
"scalar_evolution_in_region",
"(",
"region",
",",
"loop",
",",
"def",
")",
";",
"if",
"(",
"tree_contains_chrecs",
"(",
"scev",
",",
"NULL",
")",
")",
"return",
"false",
";",
"propagate_expr_outside_region",
"(",
"def",
",",
"scev",
",",
"region",
")",
";",
"return",
"true",
";",
"}",
"def_bb",
"=",
"gimple_bb",
"(",
"stmt",
")",
";",
"handle_scalar_deps_crossing_scop_limits",
"(",
"scop",
",",
"def",
",",
"stmt",
")",
";",
"FOR_EACH_IMM_USE_STMT",
"(",
"use_stmt",
",",
"imm_iter",
",",
"def",
")",
"",
"if",
"(",
"gimple_code",
"(",
"use_stmt",
")",
"==",
"GIMPLE_PHI",
"&&",
"(",
"res",
"=",
"true",
")",
")",
"{",
"gimple_stmt_iterator",
"psi",
"=",
"gsi_for_stmt",
"(",
"use_stmt",
")",
";",
"if",
"(",
"scalar_close_phi_node_p",
"(",
"gsi_stmt",
"(",
"psi",
")",
")",
")",
"rewrite_close_phi_out_of_ssa",
"(",
"scop",
",",
"&",
"psi",
")",
";",
"else",
"rewrite_phi_out_of_ssa",
"(",
"scop",
",",
"&",
"psi",
")",
";",
"}",
"FOR_EACH_IMM_USE_STMT",
"(",
"use_stmt",
",",
"imm_iter",
",",
"def",
")",
"",
"if",
"(",
"gimple_code",
"(",
"use_stmt",
")",
"!=",
"GIMPLE_PHI",
"&&",
"def_bb",
"!=",
"gimple_bb",
"(",
"use_stmt",
")",
"&&",
"!",
"is_gimple_debug",
"(",
"use_stmt",
")",
"&&",
"(",
"res",
"=",
"true",
")",
")",
"{",
"if",
"(",
"!",
"zero_dim_array",
")",
"{",
"zero_dim_array",
"=",
"create_zero_dim_array",
"(",
"SSA_NAME_VAR",
"(",
"def",
")",
",",
"\"",
"\"",
")",
";",
"insert_out_of_ssa_copy",
"(",
"scop",
",",
"zero_dim_array",
",",
"def",
",",
"SSA_NAME_DEF_STMT",
"(",
"def",
")",
")",
";",
"gsi_next",
"(",
"gsi",
")",
";",
"}",
"rewrite_cross_bb_scalar_dependence",
"(",
"scop",
",",
"zero_dim_array",
",",
"def",
",",
"use_stmt",
")",
";",
"}",
"return",
"res",
";",
"}"
] | Rewrite the scalar dependences crossing the boundary of the BB
containing STMT with an array. | [
"Rewrite",
"the",
"scalar",
"dependences",
"crossing",
"the",
"boundary",
"of",
"the",
"BB",
"containing",
"STMT",
"with",
"an",
"array",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "gsi",
"type": "gimple_stmt_iterator"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "gsi",
"type": "gimple_stmt_iterator",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_cross_bb_scalar_deps_out_of_ssa | void | static void
rewrite_cross_bb_scalar_deps_out_of_ssa (scop_p scop)
{
basic_block bb;
gimple_stmt_iterator psi;
sese region = SCOP_REGION (scop);
bool changed = false;
/* Create an extra empty BB after the scop. */
split_edge (SESE_EXIT (region));
FOR_EACH_BB (bb)
if (bb_in_sese_p (bb, region))
for (psi = gsi_start_bb (bb); !gsi_end_p (psi); gsi_next (&psi))
changed |= rewrite_cross_bb_scalar_deps (scop, &psi);
if (changed)
{
scev_reset_htab ();
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
verify_loop_closed_ssa (true);
#endif
}
} | /* Rewrite out of SSA all the reduction phi nodes of SCOP. */ | Rewrite out of SSA all the reduction phi nodes of SCOP. | [
"Rewrite",
"out",
"of",
"SSA",
"all",
"the",
"reduction",
"phi",
"nodes",
"of",
"SCOP",
"."
] | static void
rewrite_cross_bb_scalar_deps_out_of_ssa (scop_p scop)
{
basic_block bb;
gimple_stmt_iterator psi;
sese region = SCOP_REGION (scop);
bool changed = false;
split_edge (SESE_EXIT (region));
FOR_EACH_BB (bb)
if (bb_in_sese_p (bb, region))
for (psi = gsi_start_bb (bb); !gsi_end_p (psi); gsi_next (&psi))
changed |= rewrite_cross_bb_scalar_deps (scop, &psi);
if (changed)
{
scev_reset_htab ();
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
verify_loop_closed_ssa (true);
#endif
}
} | [
"static",
"void",
"rewrite_cross_bb_scalar_deps_out_of_ssa",
"(",
"scop_p",
"scop",
")",
"{",
"basic_block",
"bb",
";",
"gimple_stmt_iterator",
"psi",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"bool",
"changed",
"=",
"false",
";",
"split_edge",
"(",
"SESE_EXIT",
"(",
"region",
")",
")",
";",
"FOR_EACH_BB",
"(",
"bb",
")",
"if",
"(",
"bb_in_sese_p",
"(",
"bb",
",",
"region",
")",
")",
"",
"for",
"(",
"psi",
"=",
"gsi_start_bb",
"(",
"bb",
")",
";",
"!",
"gsi_end_p",
"(",
"psi",
")",
";",
"gsi_next",
"(",
"&",
"psi",
")",
")",
"changed",
"|=",
"rewrite_cross_bb_scalar_deps",
"(",
"scop",
",",
"&",
"psi",
")",
";",
"if",
"(",
"changed",
")",
"{",
"scev_reset_htab",
"(",
")",
";",
"update_ssa",
"(",
"TODO_update_ssa",
")",
";",
"#ifdef",
"ENABLE_CHECKING",
"verify_loop_closed_ssa",
"(",
"true",
")",
";",
"#endif",
"}",
"}"
] | Rewrite out of SSA all the reduction phi nodes of SCOP. | [
"Rewrite",
"out",
"of",
"SSA",
"all",
"the",
"reduction",
"phi",
"nodes",
"of",
"SCOP",
"."
] | [
"/* Create an extra empty BB after the scop. */"
] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | nb_pbbs_in_loops | int | static int
nb_pbbs_in_loops (scop_p scop)
{
int i;
poly_bb_p pbb;
int res = 0;
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
if (loop_in_sese_p (gbb_loop (PBB_BLACK_BOX (pbb)), SCOP_REGION (scop)))
res++;
return res;
} | /* Returns the number of pbbs that are in loops contained in SCOP. */ | Returns the number of pbbs that are in loops contained in SCOP. | [
"Returns",
"the",
"number",
"of",
"pbbs",
"that",
"are",
"in",
"loops",
"contained",
"in",
"SCOP",
"."
] | static int
nb_pbbs_in_loops (scop_p scop)
{
int i;
poly_bb_p pbb;
int res = 0;
FOR_EACH_VEC_ELT (poly_bb_p, SCOP_BBS (scop), i, pbb)
if (loop_in_sese_p (gbb_loop (PBB_BLACK_BOX (pbb)), SCOP_REGION (scop)))
res++;
return res;
} | [
"static",
"int",
"nb_pbbs_in_loops",
"(",
"scop_p",
"scop",
")",
"{",
"int",
"i",
";",
"poly_bb_p",
"pbb",
";",
"int",
"res",
"=",
"0",
";",
"FOR_EACH_VEC_ELT",
"(",
"poly_bb_p",
",",
"SCOP_BBS",
"(",
"scop",
")",
",",
"i",
",",
"pbb",
")",
"",
"if",
"(",
"loop_in_sese_p",
"(",
"gbb_loop",
"(",
"PBB_BLACK_BOX",
"(",
"pbb",
")",
")",
",",
"SCOP_REGION",
"(",
"scop",
")",
")",
")",
"res",
"++",
";",
"return",
"res",
";",
"}"
] | Returns the number of pbbs that are in loops contained in SCOP. | [
"Returns",
"the",
"number",
"of",
"pbbs",
"that",
"are",
"in",
"loops",
"contained",
"in",
"SCOP",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | nb_data_writes_in_bb | int | static int
nb_data_writes_in_bb (basic_block bb)
{
int res = 0;
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
if (gimple_vdef (gsi_stmt (gsi)))
res++;
return res;
} | /* Return the number of data references in BB that write in
memory. */ | Return the number of data references in BB that write in
memory. | [
"Return",
"the",
"number",
"of",
"data",
"references",
"in",
"BB",
"that",
"write",
"in",
"memory",
"."
] | static int
nb_data_writes_in_bb (basic_block bb)
{
int res = 0;
gimple_stmt_iterator gsi;
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
if (gimple_vdef (gsi_stmt (gsi)))
res++;
return res;
} | [
"static",
"int",
"nb_data_writes_in_bb",
"(",
"basic_block",
"bb",
")",
"{",
"int",
"res",
"=",
"0",
";",
"gimple_stmt_iterator",
"gsi",
";",
"for",
"(",
"gsi",
"=",
"gsi_start_bb",
"(",
"bb",
")",
";",
"!",
"gsi_end_p",
"(",
"gsi",
")",
";",
"gsi_next",
"(",
"&",
"gsi",
")",
")",
"if",
"(",
"gimple_vdef",
"(",
"gsi_stmt",
"(",
"gsi",
")",
")",
")",
"res",
"++",
";",
"return",
"res",
";",
"}"
] | Return the number of data references in BB that write in
memory. | [
"Return",
"the",
"number",
"of",
"data",
"references",
"in",
"BB",
"that",
"write",
"in",
"memory",
"."
] | [] | [
{
"param": "bb",
"type": "basic_block"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | split_pbb | edge | static edge
split_pbb (scop_p scop, poly_bb_p pbb, basic_block bb, gimple stmt)
{
edge e1 = split_block (bb, stmt);
new_pbb_from_pbb (scop, pbb, e1->dest);
return e1;
} | /* Splits at STMT the basic block BB represented as PBB in the
polyhedral form. */ | Splits at STMT the basic block BB represented as PBB in the
polyhedral form. | [
"Splits",
"at",
"STMT",
"the",
"basic",
"block",
"BB",
"represented",
"as",
"PBB",
"in",
"the",
"polyhedral",
"form",
"."
] | static edge
split_pbb (scop_p scop, poly_bb_p pbb, basic_block bb, gimple stmt)
{
edge e1 = split_block (bb, stmt);
new_pbb_from_pbb (scop, pbb, e1->dest);
return e1;
} | [
"static",
"edge",
"split_pbb",
"(",
"scop_p",
"scop",
",",
"poly_bb_p",
"pbb",
",",
"basic_block",
"bb",
",",
"gimple",
"stmt",
")",
"{",
"edge",
"e1",
"=",
"split_block",
"(",
"bb",
",",
"stmt",
")",
";",
"new_pbb_from_pbb",
"(",
"scop",
",",
"pbb",
",",
"e1",
"->",
"dest",
")",
";",
"return",
"e1",
";",
"}"
] | Splits at STMT the basic block BB represented as PBB in the
polyhedral form. | [
"Splits",
"at",
"STMT",
"the",
"basic",
"block",
"BB",
"represented",
"as",
"PBB",
"in",
"the",
"polyhedral",
"form",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "pbb",
"type": "poly_bb_p"
},
{
"param": "bb",
"type": "basic_block"
},
{
"param": "stmt",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pbb",
"type": "poly_bb_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bb",
"type": "basic_block",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | split_reduction_stmt | basic_block | static basic_block
split_reduction_stmt (scop_p scop, gimple stmt)
{
basic_block bb = gimple_bb (stmt);
poly_bb_p pbb = pbb_from_bb (bb);
gimple_bb_p gbb = gbb_from_bb (bb);
edge e1;
int i;
data_reference_p dr;
/* Do not split basic blocks with no writes to memory: the reduction
will be the only write to memory. */
if (nb_data_writes_in_bb (bb) == 0
/* Or if we have already marked BB as a reduction. */
|| PBB_IS_REDUCTION (pbb_from_bb (bb)))
return bb;
e1 = split_pbb (scop, pbb, bb, stmt);
/* Split once more only when the reduction stmt is not the only one
left in the original BB. */
if (!gsi_one_before_end_p (gsi_start_nondebug_bb (bb)))
{
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gsi_prev (&gsi);
e1 = split_pbb (scop, pbb, bb, gsi_stmt (gsi));
}
/* A part of the data references will end in a different basic block
after the split: move the DRs from the original GBB to the newly
created GBB1. */
FOR_EACH_VEC_ELT (data_reference_p, GBB_DATA_REFS (gbb), i, dr)
{
basic_block bb1 = gimple_bb (DR_STMT (dr));
if (bb1 != bb)
{
gimple_bb_p gbb1 = gbb_from_bb (bb1);
VEC_safe_push (data_reference_p, heap, GBB_DATA_REFS (gbb1), dr);
VEC_ordered_remove (data_reference_p, GBB_DATA_REFS (gbb), i);
i--;
}
}
return e1->dest;
} | /* Splits STMT out of its current BB. This is done for reduction
statements for which we want to ignore data dependences. */ | Splits STMT out of its current BB. This is done for reduction
statements for which we want to ignore data dependences. | [
"Splits",
"STMT",
"out",
"of",
"its",
"current",
"BB",
".",
"This",
"is",
"done",
"for",
"reduction",
"statements",
"for",
"which",
"we",
"want",
"to",
"ignore",
"data",
"dependences",
"."
] | static basic_block
split_reduction_stmt (scop_p scop, gimple stmt)
{
basic_block bb = gimple_bb (stmt);
poly_bb_p pbb = pbb_from_bb (bb);
gimple_bb_p gbb = gbb_from_bb (bb);
edge e1;
int i;
data_reference_p dr;
if (nb_data_writes_in_bb (bb) == 0
|| PBB_IS_REDUCTION (pbb_from_bb (bb)))
return bb;
e1 = split_pbb (scop, pbb, bb, stmt);
if (!gsi_one_before_end_p (gsi_start_nondebug_bb (bb)))
{
gimple_stmt_iterator gsi = gsi_last_bb (bb);
gsi_prev (&gsi);
e1 = split_pbb (scop, pbb, bb, gsi_stmt (gsi));
}
FOR_EACH_VEC_ELT (data_reference_p, GBB_DATA_REFS (gbb), i, dr)
{
basic_block bb1 = gimple_bb (DR_STMT (dr));
if (bb1 != bb)
{
gimple_bb_p gbb1 = gbb_from_bb (bb1);
VEC_safe_push (data_reference_p, heap, GBB_DATA_REFS (gbb1), dr);
VEC_ordered_remove (data_reference_p, GBB_DATA_REFS (gbb), i);
i--;
}
}
return e1->dest;
} | [
"static",
"basic_block",
"split_reduction_stmt",
"(",
"scop_p",
"scop",
",",
"gimple",
"stmt",
")",
"{",
"basic_block",
"bb",
"=",
"gimple_bb",
"(",
"stmt",
")",
";",
"poly_bb_p",
"pbb",
"=",
"pbb_from_bb",
"(",
"bb",
")",
";",
"gimple_bb_p",
"gbb",
"=",
"gbb_from_bb",
"(",
"bb",
")",
";",
"edge",
"e1",
";",
"int",
"i",
";",
"data_reference_p",
"dr",
";",
"if",
"(",
"nb_data_writes_in_bb",
"(",
"bb",
")",
"==",
"0",
"||",
"PBB_IS_REDUCTION",
"(",
"pbb_from_bb",
"(",
"bb",
")",
")",
")",
"return",
"bb",
";",
"e1",
"=",
"split_pbb",
"(",
"scop",
",",
"pbb",
",",
"bb",
",",
"stmt",
")",
";",
"if",
"(",
"!",
"gsi_one_before_end_p",
"(",
"gsi_start_nondebug_bb",
"(",
"bb",
")",
")",
")",
"{",
"gimple_stmt_iterator",
"gsi",
"=",
"gsi_last_bb",
"(",
"bb",
")",
";",
"gsi_prev",
"(",
"&",
"gsi",
")",
";",
"e1",
"=",
"split_pbb",
"(",
"scop",
",",
"pbb",
",",
"bb",
",",
"gsi_stmt",
"(",
"gsi",
")",
")",
";",
"}",
"FOR_EACH_VEC_ELT",
"(",
"data_reference_p",
",",
"GBB_DATA_REFS",
"(",
"gbb",
")",
",",
"i",
",",
"dr",
")",
"",
"{",
"basic_block",
"bb1",
"=",
"gimple_bb",
"(",
"DR_STMT",
"(",
"dr",
")",
")",
";",
"if",
"(",
"bb1",
"!=",
"bb",
")",
"{",
"gimple_bb_p",
"gbb1",
"=",
"gbb_from_bb",
"(",
"bb1",
")",
";",
"VEC_safe_push",
"(",
"data_reference_p",
",",
"heap",
",",
"GBB_DATA_REFS",
"(",
"gbb1",
")",
",",
"dr",
")",
";",
"VEC_ordered_remove",
"(",
"data_reference_p",
",",
"GBB_DATA_REFS",
"(",
"gbb",
")",
",",
"i",
")",
";",
"i",
"--",
";",
"}",
"}",
"return",
"e1",
"->",
"dest",
";",
"}"
] | Splits STMT out of its current BB. | [
"Splits",
"STMT",
"out",
"of",
"its",
"current",
"BB",
"."
] | [
"/* Do not split basic blocks with no writes to memory: the reduction\n will be the only write to memory. */",
"/* Or if we have already marked BB as a reduction. */",
"/* Split once more only when the reduction stmt is not the only one\n left in the original BB. */",
"/* A part of the data references will end in a different basic block\n after the split: move the DRs from the original GBB to the newly\n created GBB1. */"
] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "stmt",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | is_reduction_operation_p | bool | static inline bool
is_reduction_operation_p (gimple stmt)
{
enum tree_code code;
gcc_assert (is_gimple_assign (stmt));
code = gimple_assign_rhs_code (stmt);
return flag_associative_math
&& commutative_tree_code (code)
&& associative_tree_code (code);
} | /* Return true when stmt is a reduction operation. */ | Return true when stmt is a reduction operation. | [
"Return",
"true",
"when",
"stmt",
"is",
"a",
"reduction",
"operation",
"."
] | static inline bool
is_reduction_operation_p (gimple stmt)
{
enum tree_code code;
gcc_assert (is_gimple_assign (stmt));
code = gimple_assign_rhs_code (stmt);
return flag_associative_math
&& commutative_tree_code (code)
&& associative_tree_code (code);
} | [
"static",
"inline",
"bool",
"is_reduction_operation_p",
"(",
"gimple",
"stmt",
")",
"{",
"enum",
"tree_code",
"code",
";",
"gcc_assert",
"(",
"is_gimple_assign",
"(",
"stmt",
")",
")",
";",
"code",
"=",
"gimple_assign_rhs_code",
"(",
"stmt",
")",
";",
"return",
"flag_associative_math",
"&&",
"commutative_tree_code",
"(",
"code",
")",
"&&",
"associative_tree_code",
"(",
"code",
")",
";",
"}"
] | Return true when stmt is a reduction operation. | [
"Return",
"true",
"when",
"stmt",
"is",
"a",
"reduction",
"operation",
"."
] | [] | [
{
"param": "stmt",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | phi_contains_arg | bool | static bool
phi_contains_arg (gimple phi, tree arg)
{
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
if (operand_equal_p (arg, gimple_phi_arg_def (phi, i), 0))
return true;
return false;
} | /* Returns true when PHI contains an argument ARG. */ | Returns true when PHI contains an argument ARG. | [
"Returns",
"true",
"when",
"PHI",
"contains",
"an",
"argument",
"ARG",
"."
] | static bool
phi_contains_arg (gimple phi, tree arg)
{
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
if (operand_equal_p (arg, gimple_phi_arg_def (phi, i), 0))
return true;
return false;
} | [
"static",
"bool",
"phi_contains_arg",
"(",
"gimple",
"phi",
",",
"tree",
"arg",
")",
"{",
"size_t",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"gimple_phi_num_args",
"(",
"phi",
")",
";",
"i",
"++",
")",
"if",
"(",
"operand_equal_p",
"(",
"arg",
",",
"gimple_phi_arg_def",
"(",
"phi",
",",
"i",
")",
",",
"0",
")",
")",
"return",
"true",
";",
"return",
"false",
";",
"}"
] | Returns true when PHI contains an argument ARG. | [
"Returns",
"true",
"when",
"PHI",
"contains",
"an",
"argument",
"ARG",
"."
] | [] | [
{
"param": "phi",
"type": "gimple"
},
{
"param": "arg",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "arg",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | follow_ssa_with_commutative_ops | gimple | static gimple
follow_ssa_with_commutative_ops (tree arg, tree lhs)
{
gimple stmt;
if (TREE_CODE (arg) != SSA_NAME)
return NULL;
stmt = SSA_NAME_DEF_STMT (arg);
if (gimple_code (stmt) == GIMPLE_NOP
|| gimple_code (stmt) == GIMPLE_CALL)
return NULL;
if (gimple_code (stmt) == GIMPLE_PHI)
{
if (phi_contains_arg (stmt, lhs))
return stmt;
return NULL;
}
if (!is_gimple_assign (stmt))
return NULL;
if (gimple_num_ops (stmt) == 2)
return follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
if (is_reduction_operation_p (stmt))
{
gimple res = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
return res ? res :
follow_ssa_with_commutative_ops (gimple_assign_rhs2 (stmt), lhs);
}
return NULL;
} | /* Return a loop phi node that corresponds to a reduction containing LHS. */ | Return a loop phi node that corresponds to a reduction containing LHS. | [
"Return",
"a",
"loop",
"phi",
"node",
"that",
"corresponds",
"to",
"a",
"reduction",
"containing",
"LHS",
"."
] | static gimple
follow_ssa_with_commutative_ops (tree arg, tree lhs)
{
gimple stmt;
if (TREE_CODE (arg) != SSA_NAME)
return NULL;
stmt = SSA_NAME_DEF_STMT (arg);
if (gimple_code (stmt) == GIMPLE_NOP
|| gimple_code (stmt) == GIMPLE_CALL)
return NULL;
if (gimple_code (stmt) == GIMPLE_PHI)
{
if (phi_contains_arg (stmt, lhs))
return stmt;
return NULL;
}
if (!is_gimple_assign (stmt))
return NULL;
if (gimple_num_ops (stmt) == 2)
return follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
if (is_reduction_operation_p (stmt))
{
gimple res = follow_ssa_with_commutative_ops (gimple_assign_rhs1 (stmt), lhs);
return res ? res :
follow_ssa_with_commutative_ops (gimple_assign_rhs2 (stmt), lhs);
}
return NULL;
} | [
"static",
"gimple",
"follow_ssa_with_commutative_ops",
"(",
"tree",
"arg",
",",
"tree",
"lhs",
")",
"{",
"gimple",
"stmt",
";",
"if",
"(",
"TREE_CODE",
"(",
"arg",
")",
"!=",
"SSA_NAME",
")",
"return",
"NULL",
";",
"stmt",
"=",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
";",
"if",
"(",
"gimple_code",
"(",
"stmt",
")",
"==",
"GIMPLE_NOP",
"||",
"gimple_code",
"(",
"stmt",
")",
"==",
"GIMPLE_CALL",
")",
"return",
"NULL",
";",
"if",
"(",
"gimple_code",
"(",
"stmt",
")",
"==",
"GIMPLE_PHI",
")",
"{",
"if",
"(",
"phi_contains_arg",
"(",
"stmt",
",",
"lhs",
")",
")",
"return",
"stmt",
";",
"return",
"NULL",
";",
"}",
"if",
"(",
"!",
"is_gimple_assign",
"(",
"stmt",
")",
")",
"return",
"NULL",
";",
"if",
"(",
"gimple_num_ops",
"(",
"stmt",
")",
"==",
"2",
")",
"return",
"follow_ssa_with_commutative_ops",
"(",
"gimple_assign_rhs1",
"(",
"stmt",
")",
",",
"lhs",
")",
";",
"if",
"(",
"is_reduction_operation_p",
"(",
"stmt",
")",
")",
"{",
"gimple",
"res",
"=",
"follow_ssa_with_commutative_ops",
"(",
"gimple_assign_rhs1",
"(",
"stmt",
")",
",",
"lhs",
")",
";",
"return",
"res",
"?",
"res",
":",
"follow_ssa_with_commutative_ops",
"(",
"gimple_assign_rhs2",
"(",
"stmt",
")",
",",
"lhs",
")",
";",
"}",
"return",
"NULL",
";",
"}"
] | Return a loop phi node that corresponds to a reduction containing LHS. | [
"Return",
"a",
"loop",
"phi",
"node",
"that",
"corresponds",
"to",
"a",
"reduction",
"containing",
"LHS",
"."
] | [] | [
{
"param": "arg",
"type": "tree"
},
{
"param": "lhs",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "arg",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lhs",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | follow_inital_value_to_phi | gimple | static gimple
follow_inital_value_to_phi (tree arg, tree lhs)
{
gimple stmt;
if (!arg || TREE_CODE (arg) != SSA_NAME)
return NULL;
stmt = SSA_NAME_DEF_STMT (arg);
if (gimple_code (stmt) == GIMPLE_PHI
&& phi_contains_arg (stmt, lhs))
return stmt;
return NULL;
} | /* Return a loop phi node that corresponds to a reduction containing LHS. */ | Return a loop phi node that corresponds to a reduction containing LHS. | [
"Return",
"a",
"loop",
"phi",
"node",
"that",
"corresponds",
"to",
"a",
"reduction",
"containing",
"LHS",
"."
] | static gimple
follow_inital_value_to_phi (tree arg, tree lhs)
{
gimple stmt;
if (!arg || TREE_CODE (arg) != SSA_NAME)
return NULL;
stmt = SSA_NAME_DEF_STMT (arg);
if (gimple_code (stmt) == GIMPLE_PHI
&& phi_contains_arg (stmt, lhs))
return stmt;
return NULL;
} | [
"static",
"gimple",
"follow_inital_value_to_phi",
"(",
"tree",
"arg",
",",
"tree",
"lhs",
")",
"{",
"gimple",
"stmt",
";",
"if",
"(",
"!",
"arg",
"||",
"TREE_CODE",
"(",
"arg",
")",
"!=",
"SSA_NAME",
")",
"return",
"NULL",
";",
"stmt",
"=",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
";",
"if",
"(",
"gimple_code",
"(",
"stmt",
")",
"==",
"GIMPLE_PHI",
"&&",
"phi_contains_arg",
"(",
"stmt",
",",
"lhs",
")",
")",
"return",
"stmt",
";",
"return",
"NULL",
";",
"}"
] | Return a loop phi node that corresponds to a reduction containing LHS. | [
"Return",
"a",
"loop",
"phi",
"node",
"that",
"corresponds",
"to",
"a",
"reduction",
"containing",
"LHS",
"."
] | [] | [
{
"param": "arg",
"type": "tree"
},
{
"param": "lhs",
"type": "tree"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "arg",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lhs",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | edge_initial_value_for_loop_phi | edge | static edge
edge_initial_value_for_loop_phi (gimple phi)
{
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
edge e = gimple_phi_arg_edge (phi, i);
if (loop_depth (e->src->loop_father)
< loop_depth (e->dest->loop_father))
return e;
}
return NULL;
} | /* Return the argument of the loop PHI that is the inital value coming
from outside the loop. */ | Return the argument of the loop PHI that is the inital value coming
from outside the loop. | [
"Return",
"the",
"argument",
"of",
"the",
"loop",
"PHI",
"that",
"is",
"the",
"inital",
"value",
"coming",
"from",
"outside",
"the",
"loop",
"."
] | static edge
edge_initial_value_for_loop_phi (gimple phi)
{
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
edge e = gimple_phi_arg_edge (phi, i);
if (loop_depth (e->src->loop_father)
< loop_depth (e->dest->loop_father))
return e;
}
return NULL;
} | [
"static",
"edge",
"edge_initial_value_for_loop_phi",
"(",
"gimple",
"phi",
")",
"{",
"size_t",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"gimple_phi_num_args",
"(",
"phi",
")",
";",
"i",
"++",
")",
"{",
"edge",
"e",
"=",
"gimple_phi_arg_edge",
"(",
"phi",
",",
"i",
")",
";",
"if",
"(",
"loop_depth",
"(",
"e",
"->",
"src",
"->",
"loop_father",
")",
"<",
"loop_depth",
"(",
"e",
"->",
"dest",
"->",
"loop_father",
")",
")",
"return",
"e",
";",
"}",
"return",
"NULL",
";",
"}"
] | Return the argument of the loop PHI that is the inital value coming
from outside the loop. | [
"Return",
"the",
"argument",
"of",
"the",
"loop",
"PHI",
"that",
"is",
"the",
"inital",
"value",
"coming",
"from",
"outside",
"the",
"loop",
"."
] | [] | [
{
"param": "phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | initial_value_for_loop_phi | tree | static tree
initial_value_for_loop_phi (gimple phi)
{
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
edge e = gimple_phi_arg_edge (phi, i);
if (loop_depth (e->src->loop_father)
< loop_depth (e->dest->loop_father))
return gimple_phi_arg_def (phi, i);
}
return NULL_TREE;
} | /* Return the argument of the loop PHI that is the inital value coming
from outside the loop. */ | Return the argument of the loop PHI that is the inital value coming
from outside the loop. | [
"Return",
"the",
"argument",
"of",
"the",
"loop",
"PHI",
"that",
"is",
"the",
"inital",
"value",
"coming",
"from",
"outside",
"the",
"loop",
"."
] | static tree
initial_value_for_loop_phi (gimple phi)
{
size_t i;
for (i = 0; i < gimple_phi_num_args (phi); i++)
{
edge e = gimple_phi_arg_edge (phi, i);
if (loop_depth (e->src->loop_father)
< loop_depth (e->dest->loop_father))
return gimple_phi_arg_def (phi, i);
}
return NULL_TREE;
} | [
"static",
"tree",
"initial_value_for_loop_phi",
"(",
"gimple",
"phi",
")",
"{",
"size_t",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"gimple_phi_num_args",
"(",
"phi",
")",
";",
"i",
"++",
")",
"{",
"edge",
"e",
"=",
"gimple_phi_arg_edge",
"(",
"phi",
",",
"i",
")",
";",
"if",
"(",
"loop_depth",
"(",
"e",
"->",
"src",
"->",
"loop_father",
")",
"<",
"loop_depth",
"(",
"e",
"->",
"dest",
"->",
"loop_father",
")",
")",
"return",
"gimple_phi_arg_def",
"(",
"phi",
",",
"i",
")",
";",
"}",
"return",
"NULL_TREE",
";",
"}"
] | Return the argument of the loop PHI that is the inital value coming
from outside the loop. | [
"Return",
"the",
"argument",
"of",
"the",
"loop",
"PHI",
"that",
"is",
"the",
"inital",
"value",
"coming",
"from",
"outside",
"the",
"loop",
"."
] | [] | [
{
"param": "phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | used_outside_reduction | bool | static bool
used_outside_reduction (tree def, gimple loop_phi)
{
use_operand_p use_p;
imm_use_iterator imm_iter;
loop_p loop = loop_containing_stmt (loop_phi);
/* In LOOP, DEF should be used only in LOOP_PHI. */
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
{
gimple stmt = USE_STMT (use_p);
if (stmt != loop_phi
&& !is_gimple_debug (stmt)
&& flow_bb_inside_loop_p (loop, gimple_bb (stmt)))
return true;
}
return false;
} | /* Returns true when DEF is used outside the reduction cycle of
LOOP_PHI. */ | Returns true when DEF is used outside the reduction cycle of
LOOP_PHI. | [
"Returns",
"true",
"when",
"DEF",
"is",
"used",
"outside",
"the",
"reduction",
"cycle",
"of",
"LOOP_PHI",
"."
] | static bool
used_outside_reduction (tree def, gimple loop_phi)
{
use_operand_p use_p;
imm_use_iterator imm_iter;
loop_p loop = loop_containing_stmt (loop_phi);
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
{
gimple stmt = USE_STMT (use_p);
if (stmt != loop_phi
&& !is_gimple_debug (stmt)
&& flow_bb_inside_loop_p (loop, gimple_bb (stmt)))
return true;
}
return false;
} | [
"static",
"bool",
"used_outside_reduction",
"(",
"tree",
"def",
",",
"gimple",
"loop_phi",
")",
"{",
"use_operand_p",
"use_p",
";",
"imm_use_iterator",
"imm_iter",
";",
"loop_p",
"loop",
"=",
"loop_containing_stmt",
"(",
"loop_phi",
")",
";",
"FOR_EACH_IMM_USE_FAST",
"(",
"use_p",
",",
"imm_iter",
",",
"def",
")",
"",
"{",
"gimple",
"stmt",
"=",
"USE_STMT",
"(",
"use_p",
")",
";",
"if",
"(",
"stmt",
"!=",
"loop_phi",
"&&",
"!",
"is_gimple_debug",
"(",
"stmt",
")",
"&&",
"flow_bb_inside_loop_p",
"(",
"loop",
",",
"gimple_bb",
"(",
"stmt",
")",
")",
")",
"return",
"true",
";",
"}",
"return",
"false",
";",
"}"
] | Returns true when DEF is used outside the reduction cycle of
LOOP_PHI. | [
"Returns",
"true",
"when",
"DEF",
"is",
"used",
"outside",
"the",
"reduction",
"cycle",
"of",
"LOOP_PHI",
"."
] | [
"/* In LOOP, DEF should be used only in LOOP_PHI. */"
] | [
{
"param": "def",
"type": "tree"
},
{
"param": "loop_phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "def",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "loop_phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | translate_scalar_reduction_to_array_for_stmt | void | static void
translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red,
gimple stmt, gimple loop_phi)
{
tree res = gimple_phi_result (loop_phi);
gimple assign = gimple_build_assign (res, unshare_expr (red));
gimple_stmt_iterator gsi;
insert_stmts (scop, assign, NULL, gsi_after_labels (gimple_bb (loop_phi)));
assign = gimple_build_assign (unshare_expr (red), gimple_assign_lhs (stmt));
gsi = gsi_for_stmt (stmt);
gsi_next (&gsi);
insert_stmts (scop, assign, NULL, gsi);
} | /* Translate the scalar reduction statement STMT to an array RED
knowing that its recursive phi node is LOOP_PHI. */ | Translate the scalar reduction statement STMT to an array RED
knowing that its recursive phi node is LOOP_PHI. | [
"Translate",
"the",
"scalar",
"reduction",
"statement",
"STMT",
"to",
"an",
"array",
"RED",
"knowing",
"that",
"its",
"recursive",
"phi",
"node",
"is",
"LOOP_PHI",
"."
] | static void
translate_scalar_reduction_to_array_for_stmt (scop_p scop, tree red,
gimple stmt, gimple loop_phi)
{
tree res = gimple_phi_result (loop_phi);
gimple assign = gimple_build_assign (res, unshare_expr (red));
gimple_stmt_iterator gsi;
insert_stmts (scop, assign, NULL, gsi_after_labels (gimple_bb (loop_phi)));
assign = gimple_build_assign (unshare_expr (red), gimple_assign_lhs (stmt));
gsi = gsi_for_stmt (stmt);
gsi_next (&gsi);
insert_stmts (scop, assign, NULL, gsi);
} | [
"static",
"void",
"translate_scalar_reduction_to_array_for_stmt",
"(",
"scop_p",
"scop",
",",
"tree",
"red",
",",
"gimple",
"stmt",
",",
"gimple",
"loop_phi",
")",
"{",
"tree",
"res",
"=",
"gimple_phi_result",
"(",
"loop_phi",
")",
";",
"gimple",
"assign",
"=",
"gimple_build_assign",
"(",
"res",
",",
"unshare_expr",
"(",
"red",
")",
")",
";",
"gimple_stmt_iterator",
"gsi",
";",
"insert_stmts",
"(",
"scop",
",",
"assign",
",",
"NULL",
",",
"gsi_after_labels",
"(",
"gimple_bb",
"(",
"loop_phi",
")",
")",
")",
";",
"assign",
"=",
"gimple_build_assign",
"(",
"unshare_expr",
"(",
"red",
")",
",",
"gimple_assign_lhs",
"(",
"stmt",
")",
")",
";",
"gsi",
"=",
"gsi_for_stmt",
"(",
"stmt",
")",
";",
"gsi_next",
"(",
"&",
"gsi",
")",
";",
"insert_stmts",
"(",
"scop",
",",
"assign",
",",
"NULL",
",",
"gsi",
")",
";",
"}"
] | Translate the scalar reduction statement STMT to an array RED
knowing that its recursive phi node is LOOP_PHI. | [
"Translate",
"the",
"scalar",
"reduction",
"statement",
"STMT",
"to",
"an",
"array",
"RED",
"knowing",
"that",
"its",
"recursive",
"phi",
"node",
"is",
"LOOP_PHI",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "red",
"type": "tree"
},
{
"param": "stmt",
"type": "gimple"
},
{
"param": "loop_phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "red",
"type": "tree",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "stmt",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "loop_phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | remove_phi | void | static void
remove_phi (gimple phi)
{
imm_use_iterator imm_iter;
tree def;
use_operand_p use_p;
gimple_stmt_iterator gsi;
VEC (gimple, heap) *update = VEC_alloc (gimple, heap, 3);
unsigned int i;
gimple stmt;
def = PHI_RESULT (phi);
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
{
stmt = USE_STMT (use_p);
if (is_gimple_debug (stmt))
{
gimple_debug_bind_reset_value (stmt);
VEC_safe_push (gimple, heap, update, stmt);
}
}
FOR_EACH_VEC_ELT (gimple, update, i, stmt)
update_stmt (stmt);
VEC_free (gimple, heap, update);
gsi = gsi_for_phi_node (phi);
remove_phi_node (&gsi, false);
} | /* Removes the PHI node and resets all the debug stmts that are using
the PHI_RESULT. */ | Removes the PHI node and resets all the debug stmts that are using
the PHI_RESULT. | [
"Removes",
"the",
"PHI",
"node",
"and",
"resets",
"all",
"the",
"debug",
"stmts",
"that",
"are",
"using",
"the",
"PHI_RESULT",
"."
] | static void
remove_phi (gimple phi)
{
imm_use_iterator imm_iter;
tree def;
use_operand_p use_p;
gimple_stmt_iterator gsi;
VEC (gimple, heap) *update = VEC_alloc (gimple, heap, 3);
unsigned int i;
gimple stmt;
def = PHI_RESULT (phi);
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
{
stmt = USE_STMT (use_p);
if (is_gimple_debug (stmt))
{
gimple_debug_bind_reset_value (stmt);
VEC_safe_push (gimple, heap, update, stmt);
}
}
FOR_EACH_VEC_ELT (gimple, update, i, stmt)
update_stmt (stmt);
VEC_free (gimple, heap, update);
gsi = gsi_for_phi_node (phi);
remove_phi_node (&gsi, false);
} | [
"static",
"void",
"remove_phi",
"(",
"gimple",
"phi",
")",
"{",
"imm_use_iterator",
"imm_iter",
";",
"tree",
"def",
";",
"use_operand_p",
"use_p",
";",
"gimple_stmt_iterator",
"gsi",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"update",
"=",
"VEC_alloc",
"(",
"gimple",
",",
"heap",
",",
"3",
")",
";",
"unsigned",
"int",
"i",
";",
"gimple",
"stmt",
";",
"def",
"=",
"PHI_RESULT",
"(",
"phi",
")",
";",
"FOR_EACH_IMM_USE_FAST",
"(",
"use_p",
",",
"imm_iter",
",",
"def",
")",
"",
"{",
"stmt",
"=",
"USE_STMT",
"(",
"use_p",
")",
";",
"if",
"(",
"is_gimple_debug",
"(",
"stmt",
")",
")",
"{",
"gimple_debug_bind_reset_value",
"(",
"stmt",
")",
";",
"VEC_safe_push",
"(",
"gimple",
",",
"heap",
",",
"update",
",",
"stmt",
")",
";",
"}",
"}",
"FOR_EACH_VEC_ELT",
"(",
"gimple",
",",
"update",
",",
"i",
",",
"stmt",
")",
"",
"update_stmt",
"(",
"stmt",
")",
";",
"VEC_free",
"(",
"gimple",
",",
"heap",
",",
"update",
")",
";",
"gsi",
"=",
"gsi_for_phi_node",
"(",
"phi",
")",
";",
"remove_phi_node",
"(",
"&",
"gsi",
",",
"false",
")",
";",
"}"
] | Removes the PHI node and resets all the debug stmts that are using
the PHI_RESULT. | [
"Removes",
"the",
"PHI",
"node",
"and",
"resets",
"all",
"the",
"debug",
"stmts",
"that",
"are",
"using",
"the",
"PHI_RESULT",
"."
] | [] | [
{
"param": "phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | close_phi_written_to_memory | tree | static tree
close_phi_written_to_memory (gimple close_phi)
{
imm_use_iterator imm_iter;
use_operand_p use_p;
gimple stmt;
tree res, def = gimple_phi_result (close_phi);
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
if ((stmt = USE_STMT (use_p))
&& gimple_code (stmt) == GIMPLE_ASSIGN
&& (res = gimple_assign_lhs (stmt)))
{
switch (TREE_CODE (res))
{
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
return res;
case ARRAY_REF:
case MEM_REF:
{
tree arg = gimple_phi_arg_def (close_phi, 0);
loop_p nest = loop_containing_stmt (SSA_NAME_DEF_STMT (arg));
/* FIXME: this restriction is for id-{24,25}.f and
could be handled by duplicating the computation of
array indices before the loop of the close_phi. */
if (for_each_index (&res, dr_indices_valid_in_loop, &nest))
return res;
}
/* Fallthru. */
default:
continue;
}
}
return NULL_TREE;
} | /* When the result of a CLOSE_PHI is written to a memory location,
return a pointer to that memory reference, otherwise return
NULL_TREE. */ | When the result of a CLOSE_PHI is written to a memory location,
return a pointer to that memory reference, otherwise return
NULL_TREE. | [
"When",
"the",
"result",
"of",
"a",
"CLOSE_PHI",
"is",
"written",
"to",
"a",
"memory",
"location",
"return",
"a",
"pointer",
"to",
"that",
"memory",
"reference",
"otherwise",
"return",
"NULL_TREE",
"."
] | static tree
close_phi_written_to_memory (gimple close_phi)
{
imm_use_iterator imm_iter;
use_operand_p use_p;
gimple stmt;
tree res, def = gimple_phi_result (close_phi);
FOR_EACH_IMM_USE_FAST (use_p, imm_iter, def)
if ((stmt = USE_STMT (use_p))
&& gimple_code (stmt) == GIMPLE_ASSIGN
&& (res = gimple_assign_lhs (stmt)))
{
switch (TREE_CODE (res))
{
case VAR_DECL:
case PARM_DECL:
case RESULT_DECL:
return res;
case ARRAY_REF:
case MEM_REF:
{
tree arg = gimple_phi_arg_def (close_phi, 0);
loop_p nest = loop_containing_stmt (SSA_NAME_DEF_STMT (arg));
if (for_each_index (&res, dr_indices_valid_in_loop, &nest))
return res;
}
default:
continue;
}
}
return NULL_TREE;
} | [
"static",
"tree",
"close_phi_written_to_memory",
"(",
"gimple",
"close_phi",
")",
"{",
"imm_use_iterator",
"imm_iter",
";",
"use_operand_p",
"use_p",
";",
"gimple",
"stmt",
";",
"tree",
"res",
",",
"def",
"=",
"gimple_phi_result",
"(",
"close_phi",
")",
";",
"FOR_EACH_IMM_USE_FAST",
"(",
"use_p",
",",
"imm_iter",
",",
"def",
")",
"",
"if",
"(",
"(",
"stmt",
"=",
"USE_STMT",
"(",
"use_p",
")",
")",
"&&",
"gimple_code",
"(",
"stmt",
")",
"==",
"GIMPLE_ASSIGN",
"&&",
"(",
"res",
"=",
"gimple_assign_lhs",
"(",
"stmt",
")",
")",
")",
"{",
"switch",
"(",
"TREE_CODE",
"(",
"res",
")",
")",
"{",
"case",
"VAR_DECL",
":",
"case",
"PARM_DECL",
":",
"case",
"RESULT_DECL",
":",
"return",
"res",
";",
"case",
"ARRAY_REF",
":",
"case",
"MEM_REF",
":",
"{",
"tree",
"arg",
"=",
"gimple_phi_arg_def",
"(",
"close_phi",
",",
"0",
")",
";",
"loop_p",
"nest",
"=",
"loop_containing_stmt",
"(",
"SSA_NAME_DEF_STMT",
"(",
"arg",
")",
")",
";",
"if",
"(",
"for_each_index",
"(",
"&",
"res",
",",
"dr_indices_valid_in_loop",
",",
"&",
"nest",
")",
")",
"return",
"res",
";",
"}",
"default",
":",
"continue",
";",
"}",
"}",
"return",
"NULL_TREE",
";",
"}"
] | When the result of a CLOSE_PHI is written to a memory location,
return a pointer to that memory reference, otherwise return
NULL_TREE. | [
"When",
"the",
"result",
"of",
"a",
"CLOSE_PHI",
"is",
"written",
"to",
"a",
"memory",
"location",
"return",
"a",
"pointer",
"to",
"that",
"memory",
"reference",
"otherwise",
"return",
"NULL_TREE",
"."
] | [
"/* FIXME: this restriction is for id-{24,25}.f and\n\t\t could be handled by duplicating the computation of\n\t\t array indices before the loop of the close_phi. */",
"/* Fallthru. */"
] | [
{
"param": "close_phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "close_phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_commutative_reductions_out_of_ssa_close_phi | bool | static bool
rewrite_commutative_reductions_out_of_ssa_close_phi (scop_p scop,
gimple close_phi)
{
bool res;
VEC (gimple, heap) *in = VEC_alloc (gimple, heap, 10);
VEC (gimple, heap) *out = VEC_alloc (gimple, heap, 10);
detect_commutative_reduction (scop, close_phi, &in, &out);
res = VEC_length (gimple, in) > 1;
if (res)
translate_scalar_reduction_to_array (scop, in, out);
VEC_free (gimple, heap, in);
VEC_free (gimple, heap, out);
return res;
} | /* Rewrites out of SSA a commutative reduction at CLOSE_PHI. Returns
true when something has been changed. */ | Rewrites out of SSA a commutative reduction at CLOSE_PHI. Returns
true when something has been changed. | [
"Rewrites",
"out",
"of",
"SSA",
"a",
"commutative",
"reduction",
"at",
"CLOSE_PHI",
".",
"Returns",
"true",
"when",
"something",
"has",
"been",
"changed",
"."
] | static bool
rewrite_commutative_reductions_out_of_ssa_close_phi (scop_p scop,
gimple close_phi)
{
bool res;
VEC (gimple, heap) *in = VEC_alloc (gimple, heap, 10);
VEC (gimple, heap) *out = VEC_alloc (gimple, heap, 10);
detect_commutative_reduction (scop, close_phi, &in, &out);
res = VEC_length (gimple, in) > 1;
if (res)
translate_scalar_reduction_to_array (scop, in, out);
VEC_free (gimple, heap, in);
VEC_free (gimple, heap, out);
return res;
} | [
"static",
"bool",
"rewrite_commutative_reductions_out_of_ssa_close_phi",
"(",
"scop_p",
"scop",
",",
"gimple",
"close_phi",
")",
"{",
"bool",
"res",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"in",
"=",
"VEC_alloc",
"(",
"gimple",
",",
"heap",
",",
"10",
")",
";",
"VEC",
"(",
"gimple",
",",
"heap",
")",
"*",
"out",
"=",
"VEC_alloc",
"(",
"gimple",
",",
"heap",
",",
"10",
")",
";",
"detect_commutative_reduction",
"(",
"scop",
",",
"close_phi",
",",
"&",
"in",
",",
"&",
"out",
")",
";",
"res",
"=",
"VEC_length",
"(",
"gimple",
",",
"in",
")",
">",
"1",
";",
"if",
"(",
"res",
")",
"translate_scalar_reduction_to_array",
"(",
"scop",
",",
"in",
",",
"out",
")",
";",
"VEC_free",
"(",
"gimple",
",",
"heap",
",",
"in",
")",
";",
"VEC_free",
"(",
"gimple",
",",
"heap",
",",
"out",
")",
";",
"return",
"res",
";",
"}"
] | Rewrites out of SSA a commutative reduction at CLOSE_PHI. | [
"Rewrites",
"out",
"of",
"SSA",
"a",
"commutative",
"reduction",
"at",
"CLOSE_PHI",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "close_phi",
"type": "gimple"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "close_phi",
"type": "gimple",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_commutative_reductions_out_of_ssa_loop | bool | static bool
rewrite_commutative_reductions_out_of_ssa_loop (scop_p scop,
loop_p loop)
{
gimple_stmt_iterator gsi;
edge exit = single_exit (loop);
tree res;
bool changed = false;
if (!exit)
return false;
for (gsi = gsi_start_phis (exit->dest); !gsi_end_p (gsi); gsi_next (&gsi))
if ((res = gimple_phi_result (gsi_stmt (gsi)))
&& is_gimple_reg (res)
&& !scev_analyzable_p (res, SCOP_REGION (scop)))
changed |= rewrite_commutative_reductions_out_of_ssa_close_phi
(scop, gsi_stmt (gsi));
return changed;
} | /* Rewrites all the commutative reductions from LOOP out of SSA.
Returns true when something has been changed. */ | Rewrites all the commutative reductions from LOOP out of SSA.
Returns true when something has been changed. | [
"Rewrites",
"all",
"the",
"commutative",
"reductions",
"from",
"LOOP",
"out",
"of",
"SSA",
".",
"Returns",
"true",
"when",
"something",
"has",
"been",
"changed",
"."
] | static bool
rewrite_commutative_reductions_out_of_ssa_loop (scop_p scop,
loop_p loop)
{
gimple_stmt_iterator gsi;
edge exit = single_exit (loop);
tree res;
bool changed = false;
if (!exit)
return false;
for (gsi = gsi_start_phis (exit->dest); !gsi_end_p (gsi); gsi_next (&gsi))
if ((res = gimple_phi_result (gsi_stmt (gsi)))
&& is_gimple_reg (res)
&& !scev_analyzable_p (res, SCOP_REGION (scop)))
changed |= rewrite_commutative_reductions_out_of_ssa_close_phi
(scop, gsi_stmt (gsi));
return changed;
} | [
"static",
"bool",
"rewrite_commutative_reductions_out_of_ssa_loop",
"(",
"scop_p",
"scop",
",",
"loop_p",
"loop",
")",
"{",
"gimple_stmt_iterator",
"gsi",
";",
"edge",
"exit",
"=",
"single_exit",
"(",
"loop",
")",
";",
"tree",
"res",
";",
"bool",
"changed",
"=",
"false",
";",
"if",
"(",
"!",
"exit",
")",
"return",
"false",
";",
"for",
"(",
"gsi",
"=",
"gsi_start_phis",
"(",
"exit",
"->",
"dest",
")",
";",
"!",
"gsi_end_p",
"(",
"gsi",
")",
";",
"gsi_next",
"(",
"&",
"gsi",
")",
")",
"if",
"(",
"(",
"res",
"=",
"gimple_phi_result",
"(",
"gsi_stmt",
"(",
"gsi",
")",
")",
")",
"&&",
"is_gimple_reg",
"(",
"res",
")",
"&&",
"!",
"scev_analyzable_p",
"(",
"res",
",",
"SCOP_REGION",
"(",
"scop",
")",
")",
")",
"changed",
"|=",
"rewrite_commutative_reductions_out_of_ssa_close_phi",
"(",
"scop",
",",
"gsi_stmt",
"(",
"gsi",
")",
")",
";",
"return",
"changed",
";",
"}"
] | Rewrites all the commutative reductions from LOOP out of SSA. | [
"Rewrites",
"all",
"the",
"commutative",
"reductions",
"from",
"LOOP",
"out",
"of",
"SSA",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
},
{
"param": "loop",
"type": "loop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "loop",
"type": "loop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | rewrite_commutative_reductions_out_of_ssa | void | static void
rewrite_commutative_reductions_out_of_ssa (scop_p scop)
{
loop_iterator li;
loop_p loop;
bool changed = false;
sese region = SCOP_REGION (scop);
FOR_EACH_LOOP (li, loop, 0)
if (loop_in_sese_p (loop, region))
changed |= rewrite_commutative_reductions_out_of_ssa_loop (scop, loop);
if (changed)
{
scev_reset_htab ();
gsi_commit_edge_inserts ();
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
verify_loop_closed_ssa (true);
#endif
}
} | /* Rewrites all the commutative reductions from SCOP out of SSA. */ | Rewrites all the commutative reductions from SCOP out of SSA. | [
"Rewrites",
"all",
"the",
"commutative",
"reductions",
"from",
"SCOP",
"out",
"of",
"SSA",
"."
] | static void
rewrite_commutative_reductions_out_of_ssa (scop_p scop)
{
loop_iterator li;
loop_p loop;
bool changed = false;
sese region = SCOP_REGION (scop);
FOR_EACH_LOOP (li, loop, 0)
if (loop_in_sese_p (loop, region))
changed |= rewrite_commutative_reductions_out_of_ssa_loop (scop, loop);
if (changed)
{
scev_reset_htab ();
gsi_commit_edge_inserts ();
update_ssa (TODO_update_ssa);
#ifdef ENABLE_CHECKING
verify_loop_closed_ssa (true);
#endif
}
} | [
"static",
"void",
"rewrite_commutative_reductions_out_of_ssa",
"(",
"scop_p",
"scop",
")",
"{",
"loop_iterator",
"li",
";",
"loop_p",
"loop",
";",
"bool",
"changed",
"=",
"false",
";",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"FOR_EACH_LOOP",
"(",
"li",
",",
"loop",
",",
"0",
")",
"",
"if",
"(",
"loop_in_sese_p",
"(",
"loop",
",",
"region",
")",
")",
"changed",
"|=",
"rewrite_commutative_reductions_out_of_ssa_loop",
"(",
"scop",
",",
"loop",
")",
";",
"if",
"(",
"changed",
")",
"{",
"scev_reset_htab",
"(",
")",
";",
"gsi_commit_edge_inserts",
"(",
")",
";",
"update_ssa",
"(",
"TODO_update_ssa",
")",
";",
"#ifdef",
"ENABLE_CHECKING",
"verify_loop_closed_ssa",
"(",
"true",
")",
";",
"#endif",
"}",
"}"
] | Rewrites all the commutative reductions from SCOP out of SSA. | [
"Rewrites",
"all",
"the",
"commutative",
"reductions",
"from",
"SCOP",
"out",
"of",
"SSA",
"."
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | scop_ivs_can_be_represented | bool | static bool
scop_ivs_can_be_represented (scop_p scop)
{
loop_iterator li;
loop_p loop;
gimple_stmt_iterator psi;
bool result = true;
FOR_EACH_LOOP (li, loop, 0)
{
if (!loop_in_sese_p (loop, SCOP_REGION (scop)))
continue;
for (psi = gsi_start_phis (loop->header);
!gsi_end_p (psi); gsi_next (&psi))
{
gimple phi = gsi_stmt (psi);
tree res = PHI_RESULT (phi);
tree type = TREE_TYPE (res);
if (TYPE_UNSIGNED (type)
&& TYPE_PRECISION (type) >= TYPE_PRECISION (long_long_integer_type_node))
{
result = false;
break;
}
}
if (!result)
FOR_EACH_LOOP_BREAK (li);
}
return result;
} | /* Can all ivs be represented by a signed integer?
As CLooG might generate negative values in its expressions, signed loop ivs
are required in the backend. */ | Can all ivs be represented by a signed integer.
As CLooG might generate negative values in its expressions, signed loop ivs
are required in the backend. | [
"Can",
"all",
"ivs",
"be",
"represented",
"by",
"a",
"signed",
"integer",
".",
"As",
"CLooG",
"might",
"generate",
"negative",
"values",
"in",
"its",
"expressions",
"signed",
"loop",
"ivs",
"are",
"required",
"in",
"the",
"backend",
"."
] | static bool
scop_ivs_can_be_represented (scop_p scop)
{
loop_iterator li;
loop_p loop;
gimple_stmt_iterator psi;
bool result = true;
FOR_EACH_LOOP (li, loop, 0)
{
if (!loop_in_sese_p (loop, SCOP_REGION (scop)))
continue;
for (psi = gsi_start_phis (loop->header);
!gsi_end_p (psi); gsi_next (&psi))
{
gimple phi = gsi_stmt (psi);
tree res = PHI_RESULT (phi);
tree type = TREE_TYPE (res);
if (TYPE_UNSIGNED (type)
&& TYPE_PRECISION (type) >= TYPE_PRECISION (long_long_integer_type_node))
{
result = false;
break;
}
}
if (!result)
FOR_EACH_LOOP_BREAK (li);
}
return result;
} | [
"static",
"bool",
"scop_ivs_can_be_represented",
"(",
"scop_p",
"scop",
")",
"{",
"loop_iterator",
"li",
";",
"loop_p",
"loop",
";",
"gimple_stmt_iterator",
"psi",
";",
"bool",
"result",
"=",
"true",
";",
"FOR_EACH_LOOP",
"(",
"li",
",",
"loop",
",",
"0",
")",
"",
"{",
"if",
"(",
"!",
"loop_in_sese_p",
"(",
"loop",
",",
"SCOP_REGION",
"(",
"scop",
")",
")",
")",
"continue",
";",
"for",
"(",
"psi",
"=",
"gsi_start_phis",
"(",
"loop",
"->",
"header",
")",
";",
"!",
"gsi_end_p",
"(",
"psi",
")",
";",
"gsi_next",
"(",
"&",
"psi",
")",
")",
"{",
"gimple",
"phi",
"=",
"gsi_stmt",
"(",
"psi",
")",
";",
"tree",
"res",
"=",
"PHI_RESULT",
"(",
"phi",
")",
";",
"tree",
"type",
"=",
"TREE_TYPE",
"(",
"res",
")",
";",
"if",
"(",
"TYPE_UNSIGNED",
"(",
"type",
")",
"&&",
"TYPE_PRECISION",
"(",
"type",
")",
">=",
"TYPE_PRECISION",
"(",
"long_long_integer_type_node",
")",
")",
"{",
"result",
"=",
"false",
";",
"break",
";",
"}",
"}",
"if",
"(",
"!",
"result",
")",
"FOR_EACH_LOOP_BREAK",
"(",
"li",
")",
";",
"}",
"return",
"result",
";",
"}"
] | Can all ivs be represented by a signed integer? | [
"Can",
"all",
"ivs",
"be",
"represented",
"by",
"a",
"signed",
"integer?"
] | [] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
9167a7280898982fa03adc18ab1789fc13993c8a | atrens/DragonFlyBSD-src | contrib/gcc-4.7/gcc/graphite-sese-to-poly.c | [
"BSD-3-Clause"
] | C | build_poly_scop | void | void
build_poly_scop (scop_p scop)
{
sese region = SCOP_REGION (scop);
graphite_dim_t max_dim;
build_scop_bbs (scop);
/* FIXME: This restriction is needed to avoid a problem in CLooG.
Once CLooG is fixed, remove this guard. Anyways, it makes no
sense to optimize a scop containing only PBBs that do not belong
to any loops. */
if (nb_pbbs_in_loops (scop) == 0)
return;
if (!scop_ivs_can_be_represented (scop))
return;
if (flag_associative_math)
rewrite_commutative_reductions_out_of_ssa (scop);
build_sese_loop_nests (region);
build_sese_conditions (region);
find_scop_parameters (scop);
max_dim = PARAM_VALUE (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS);
if (scop_nb_params (scop) > max_dim)
return;
build_scop_iteration_domain (scop);
build_scop_context (scop);
add_conditions_to_constraints (scop);
/* Rewrite out of SSA only after having translated the
representation to the polyhedral representation to avoid scev
analysis failures. That means that these functions will insert
new data references that they create in the right place. */
rewrite_reductions_out_of_ssa (scop);
rewrite_cross_bb_scalar_deps_out_of_ssa (scop);
build_scop_drs (scop);
scop_to_lst (scop);
build_scop_scattering (scop);
/* This SCoP has been translated to the polyhedral
representation. */
POLY_SCOP_P (scop) = true;
} | /* Builds the polyhedral representation for a SESE region. */ | Builds the polyhedral representation for a SESE region. | [
"Builds",
"the",
"polyhedral",
"representation",
"for",
"a",
"SESE",
"region",
"."
] | void
build_poly_scop (scop_p scop)
{
sese region = SCOP_REGION (scop);
graphite_dim_t max_dim;
build_scop_bbs (scop);
if (nb_pbbs_in_loops (scop) == 0)
return;
if (!scop_ivs_can_be_represented (scop))
return;
if (flag_associative_math)
rewrite_commutative_reductions_out_of_ssa (scop);
build_sese_loop_nests (region);
build_sese_conditions (region);
find_scop_parameters (scop);
max_dim = PARAM_VALUE (PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS);
if (scop_nb_params (scop) > max_dim)
return;
build_scop_iteration_domain (scop);
build_scop_context (scop);
add_conditions_to_constraints (scop);
rewrite_reductions_out_of_ssa (scop);
rewrite_cross_bb_scalar_deps_out_of_ssa (scop);
build_scop_drs (scop);
scop_to_lst (scop);
build_scop_scattering (scop);
POLY_SCOP_P (scop) = true;
} | [
"void",
"build_poly_scop",
"(",
"scop_p",
"scop",
")",
"{",
"sese",
"region",
"=",
"SCOP_REGION",
"(",
"scop",
")",
";",
"graphite_dim_t",
"max_dim",
";",
"build_scop_bbs",
"(",
"scop",
")",
";",
"if",
"(",
"nb_pbbs_in_loops",
"(",
"scop",
")",
"==",
"0",
")",
"return",
";",
"if",
"(",
"!",
"scop_ivs_can_be_represented",
"(",
"scop",
")",
")",
"return",
";",
"if",
"(",
"flag_associative_math",
")",
"rewrite_commutative_reductions_out_of_ssa",
"(",
"scop",
")",
";",
"build_sese_loop_nests",
"(",
"region",
")",
";",
"build_sese_conditions",
"(",
"region",
")",
";",
"find_scop_parameters",
"(",
"scop",
")",
";",
"max_dim",
"=",
"PARAM_VALUE",
"(",
"PARAM_GRAPHITE_MAX_NB_SCOP_PARAMS",
")",
";",
"if",
"(",
"scop_nb_params",
"(",
"scop",
")",
">",
"max_dim",
")",
"return",
";",
"build_scop_iteration_domain",
"(",
"scop",
")",
";",
"build_scop_context",
"(",
"scop",
")",
";",
"add_conditions_to_constraints",
"(",
"scop",
")",
";",
"rewrite_reductions_out_of_ssa",
"(",
"scop",
")",
";",
"rewrite_cross_bb_scalar_deps_out_of_ssa",
"(",
"scop",
")",
";",
"build_scop_drs",
"(",
"scop",
")",
";",
"scop_to_lst",
"(",
"scop",
")",
";",
"build_scop_scattering",
"(",
"scop",
")",
";",
"POLY_SCOP_P",
"(",
"scop",
")",
"=",
"true",
";",
"}"
] | Builds the polyhedral representation for a SESE region. | [
"Builds",
"the",
"polyhedral",
"representation",
"for",
"a",
"SESE",
"region",
"."
] | [
"/* FIXME: This restriction is needed to avoid a problem in CLooG.\n Once CLooG is fixed, remove this guard. Anyways, it makes no\n sense to optimize a scop containing only PBBs that do not belong\n to any loops. */",
"/* Rewrite out of SSA only after having translated the\n representation to the polyhedral representation to avoid scev\n analysis failures. That means that these functions will insert\n new data references that they create in the right place. */",
"/* This SCoP has been translated to the polyhedral\n representation. */"
] | [
{
"param": "scop",
"type": "scop_p"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "scop",
"type": "scop_p",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
e0211c884070b0ea294ef29589190400ca608f38 | atrens/DragonFlyBSD-src | lib/libkvm/kvm_proc.c | [
"BSD-3-Clause"
] | C | kvm_lwptraverse | uintptr_t | static uintptr_t
kvm_lwptraverse(kvm_t *kd, struct lwp *lwp, uintptr_t lwppos)
{
for (;;) {
if (KREAD(kd, lwppos, lwp)) {
_kvm_err(kd, kd->program, "can't read lwp at %p",
(void *)lwppos);
return ((uintptr_t)-1);
}
if (lwp->u.lwp_rbnode.rbe_left == NULL)
break;
lwppos = (uintptr_t)lwp->u.lwp_rbnode.rbe_left;
}
return(lwppos);
} | /*
* Helper routine which traverses the left hand side of a red-black sub-tree.
*/ | Helper routine which traverses the left hand side of a red-black sub-tree. | [
"Helper",
"routine",
"which",
"traverses",
"the",
"left",
"hand",
"side",
"of",
"a",
"red",
"-",
"black",
"sub",
"-",
"tree",
"."
] | static uintptr_t
kvm_lwptraverse(kvm_t *kd, struct lwp *lwp, uintptr_t lwppos)
{
for (;;) {
if (KREAD(kd, lwppos, lwp)) {
_kvm_err(kd, kd->program, "can't read lwp at %p",
(void *)lwppos);
return ((uintptr_t)-1);
}
if (lwp->u.lwp_rbnode.rbe_left == NULL)
break;
lwppos = (uintptr_t)lwp->u.lwp_rbnode.rbe_left;
}
return(lwppos);
} | [
"static",
"uintptr_t",
"kvm_lwptraverse",
"(",
"kvm_t",
"*",
"kd",
",",
"struct",
"lwp",
"*",
"lwp",
",",
"uintptr_t",
"lwppos",
")",
"{",
"for",
"(",
";",
";",
")",
"{",
"if",
"(",
"KREAD",
"(",
"kd",
",",
"lwppos",
",",
"lwp",
")",
")",
"{",
"_kvm_err",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
",",
"(",
"void",
"*",
")",
"lwppos",
")",
";",
"return",
"(",
"(",
"uintptr_t",
")",
"-1",
")",
";",
"}",
"if",
"(",
"lwp",
"->",
"u",
".",
"lwp_rbnode",
".",
"rbe_left",
"==",
"NULL",
")",
"break",
";",
"lwppos",
"=",
"(",
"uintptr_t",
")",
"lwp",
"->",
"u",
".",
"lwp_rbnode",
".",
"rbe_left",
";",
"}",
"return",
"(",
"lwppos",
")",
";",
"}"
] | Helper routine which traverses the left hand side of a red-black sub-tree. | [
"Helper",
"routine",
"which",
"traverses",
"the",
"left",
"hand",
"side",
"of",
"a",
"red",
"-",
"black",
"sub",
"-",
"tree",
"."
] | [] | [
{
"param": "kd",
"type": "kvm_t"
},
{
"param": "lwp",
"type": "struct lwp"
},
{
"param": "lwppos",
"type": "uintptr_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "kd",
"type": "kvm_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lwp",
"type": "struct lwp",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lwppos",
"type": "uintptr_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
e0211c884070b0ea294ef29589190400ca608f38 | atrens/DragonFlyBSD-src | lib/libkvm/kvm_proc.c | [
"BSD-3-Clause"
] | C | kvm_firstlwp | uintptr_t | static uintptr_t
kvm_firstlwp(kvm_t *kd, struct lwp *lwp, struct proc *proc)
{
return(kvm_lwptraverse(kd, lwp, (uintptr_t)proc->p_lwp_tree.rbh_root));
} | /*
* Iterate LWPs in a process.
*
* The first lwp in a red-black tree is a left-side traversal of the tree.
*/ | Iterate LWPs in a process.
The first lwp in a red-black tree is a left-side traversal of the tree. | [
"Iterate",
"LWPs",
"in",
"a",
"process",
".",
"The",
"first",
"lwp",
"in",
"a",
"red",
"-",
"black",
"tree",
"is",
"a",
"left",
"-",
"side",
"traversal",
"of",
"the",
"tree",
"."
] | static uintptr_t
kvm_firstlwp(kvm_t *kd, struct lwp *lwp, struct proc *proc)
{
return(kvm_lwptraverse(kd, lwp, (uintptr_t)proc->p_lwp_tree.rbh_root));
} | [
"static",
"uintptr_t",
"kvm_firstlwp",
"(",
"kvm_t",
"*",
"kd",
",",
"struct",
"lwp",
"*",
"lwp",
",",
"struct",
"proc",
"*",
"proc",
")",
"{",
"return",
"(",
"kvm_lwptraverse",
"(",
"kd",
",",
"lwp",
",",
"(",
"uintptr_t",
")",
"proc",
"->",
"p_lwp_tree",
".",
"rbh_root",
")",
")",
";",
"}"
] | Iterate LWPs in a process. | [
"Iterate",
"LWPs",
"in",
"a",
"process",
"."
] | [] | [
{
"param": "kd",
"type": "kvm_t"
},
{
"param": "lwp",
"type": "struct lwp"
},
{
"param": "proc",
"type": "struct proc"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "kd",
"type": "kvm_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lwp",
"type": "struct lwp",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "proc",
"type": "struct proc",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
e0211c884070b0ea294ef29589190400ca608f38 | atrens/DragonFlyBSD-src | lib/libkvm/kvm_proc.c | [
"BSD-3-Clause"
] | C | kvm_nextlwp | uintptr_t | static uintptr_t
kvm_nextlwp(kvm_t *kd, uintptr_t lwppos, struct lwp *lwp)
{
uintptr_t nextpos;
nextpos = (uintptr_t)lwp->u.lwp_rbnode.rbe_parent;
if (nextpos) {
if (KREAD(kd, nextpos, lwp)) {
_kvm_err(kd, kd->program, "can't read lwp at %p",
(void *)lwppos);
return ((uintptr_t)-1);
}
if (lwppos == (uintptr_t)lwp->u.lwp_rbnode.rbe_left) {
/*
* If we had gone down the left side the next element
* is a left hand traversal of the parent's right
* side, or the parent itself if there is no right
* side.
*/
lwppos = (uintptr_t)lwp->u.lwp_rbnode.rbe_right;
if (lwppos)
nextpos = kvm_lwptraverse(kd, lwp, lwppos);
} else {
/*
* If we had gone down the right side the next
* element is the parent.
*/
/* nextpos = nextpos */
}
}
return(nextpos);
} | /*
* If the current element is the left side of the parent the next element
* will be a left side traversal of the parent's right side. If the parent
* has no right side the next element will be the parent.
*
* If the current element is the right side of the parent the next element
* is the parent.
*
* If the parent is NULL we are done.
*/ | If the current element is the left side of the parent the next element
will be a left side traversal of the parent's right side. If the parent
has no right side the next element will be the parent.
If the current element is the right side of the parent the next element
is the parent.
If the parent is NULL we are done. | [
"If",
"the",
"current",
"element",
"is",
"the",
"left",
"side",
"of",
"the",
"parent",
"the",
"next",
"element",
"will",
"be",
"a",
"left",
"side",
"traversal",
"of",
"the",
"parent",
"'",
"s",
"right",
"side",
".",
"If",
"the",
"parent",
"has",
"no",
"right",
"side",
"the",
"next",
"element",
"will",
"be",
"the",
"parent",
".",
"If",
"the",
"current",
"element",
"is",
"the",
"right",
"side",
"of",
"the",
"parent",
"the",
"next",
"element",
"is",
"the",
"parent",
".",
"If",
"the",
"parent",
"is",
"NULL",
"we",
"are",
"done",
"."
] | static uintptr_t
kvm_nextlwp(kvm_t *kd, uintptr_t lwppos, struct lwp *lwp)
{
uintptr_t nextpos;
nextpos = (uintptr_t)lwp->u.lwp_rbnode.rbe_parent;
if (nextpos) {
if (KREAD(kd, nextpos, lwp)) {
_kvm_err(kd, kd->program, "can't read lwp at %p",
(void *)lwppos);
return ((uintptr_t)-1);
}
if (lwppos == (uintptr_t)lwp->u.lwp_rbnode.rbe_left) {
lwppos = (uintptr_t)lwp->u.lwp_rbnode.rbe_right;
if (lwppos)
nextpos = kvm_lwptraverse(kd, lwp, lwppos);
} else {
}
}
return(nextpos);
} | [
"static",
"uintptr_t",
"kvm_nextlwp",
"(",
"kvm_t",
"*",
"kd",
",",
"uintptr_t",
"lwppos",
",",
"struct",
"lwp",
"*",
"lwp",
")",
"{",
"uintptr_t",
"nextpos",
";",
"nextpos",
"=",
"(",
"uintptr_t",
")",
"lwp",
"->",
"u",
".",
"lwp_rbnode",
".",
"rbe_parent",
";",
"if",
"(",
"nextpos",
")",
"{",
"if",
"(",
"KREAD",
"(",
"kd",
",",
"nextpos",
",",
"lwp",
")",
")",
"{",
"_kvm_err",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
",",
"(",
"void",
"*",
")",
"lwppos",
")",
";",
"return",
"(",
"(",
"uintptr_t",
")",
"-1",
")",
";",
"}",
"if",
"(",
"lwppos",
"==",
"(",
"uintptr_t",
")",
"lwp",
"->",
"u",
".",
"lwp_rbnode",
".",
"rbe_left",
")",
"{",
"lwppos",
"=",
"(",
"uintptr_t",
")",
"lwp",
"->",
"u",
".",
"lwp_rbnode",
".",
"rbe_right",
";",
"if",
"(",
"lwppos",
")",
"nextpos",
"=",
"kvm_lwptraverse",
"(",
"kd",
",",
"lwp",
",",
"lwppos",
")",
";",
"}",
"else",
"{",
"}",
"}",
"return",
"(",
"nextpos",
")",
";",
"}"
] | If the current element is the left side of the parent the next element
will be a left side traversal of the parent's right side. | [
"If",
"the",
"current",
"element",
"is",
"the",
"left",
"side",
"of",
"the",
"parent",
"the",
"next",
"element",
"will",
"be",
"a",
"left",
"side",
"traversal",
"of",
"the",
"parent",
"'",
"s",
"right",
"side",
"."
] | [
"/*\n\t\t\t * If we had gone down the left side the next element\n\t\t\t * is a left hand traversal of the parent's right\n\t\t\t * side, or the parent itself if there is no right\n\t\t\t * side.\n\t\t\t */",
"/*\n\t\t\t * If we had gone down the right side the next\n\t\t\t * element is the parent.\n\t\t\t */",
"/* nextpos = nextpos */"
] | [
{
"param": "kd",
"type": "kvm_t"
},
{
"param": "lwppos",
"type": "uintptr_t"
},
{
"param": "lwp",
"type": "struct lwp"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "kd",
"type": "kvm_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lwppos",
"type": "uintptr_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "lwp",
"type": "struct lwp",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
e0211c884070b0ea294ef29589190400ca608f38 | atrens/DragonFlyBSD-src | lib/libkvm/kvm_proc.c | [
"BSD-3-Clause"
] | C | proc_verify | int | static int
proc_verify(const struct kinfo_proc *p)
{
struct kinfo_proc kp;
int mib[4];
size_t len;
int error;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PID;
mib[3] = p->kp_pid;
len = sizeof(kp);
error = sysctl(mib, 4, &kp, &len, NULL, 0);
if (error)
return (0);
error = (p->kp_pid == kp.kp_pid &&
(kp.kp_stat != SZOMB || p->kp_stat == SZOMB));
return (error);
} | /*
* Determine if the proc indicated by p is still active.
* This test is not 100% foolproof in theory, but chances of
* being wrong are very low.
*/ | Determine if the proc indicated by p is still active.
This test is not 100% foolproof in theory, but chances of
being wrong are very low. | [
"Determine",
"if",
"the",
"proc",
"indicated",
"by",
"p",
"is",
"still",
"active",
".",
"This",
"test",
"is",
"not",
"100%",
"foolproof",
"in",
"theory",
"but",
"chances",
"of",
"being",
"wrong",
"are",
"very",
"low",
"."
] | static int
proc_verify(const struct kinfo_proc *p)
{
struct kinfo_proc kp;
int mib[4];
size_t len;
int error;
mib[0] = CTL_KERN;
mib[1] = KERN_PROC;
mib[2] = KERN_PROC_PID;
mib[3] = p->kp_pid;
len = sizeof(kp);
error = sysctl(mib, 4, &kp, &len, NULL, 0);
if (error)
return (0);
error = (p->kp_pid == kp.kp_pid &&
(kp.kp_stat != SZOMB || p->kp_stat == SZOMB));
return (error);
} | [
"static",
"int",
"proc_verify",
"(",
"const",
"struct",
"kinfo_proc",
"*",
"p",
")",
"{",
"struct",
"kinfo_proc",
"kp",
";",
"int",
"mib",
"[",
"4",
"]",
";",
"size_t",
"len",
";",
"int",
"error",
";",
"mib",
"[",
"0",
"]",
"=",
"CTL_KERN",
";",
"mib",
"[",
"1",
"]",
"=",
"KERN_PROC",
";",
"mib",
"[",
"2",
"]",
"=",
"KERN_PROC_PID",
";",
"mib",
"[",
"3",
"]",
"=",
"p",
"->",
"kp_pid",
";",
"len",
"=",
"sizeof",
"(",
"kp",
")",
";",
"error",
"=",
"sysctl",
"(",
"mib",
",",
"4",
",",
"&",
"kp",
",",
"&",
"len",
",",
"NULL",
",",
"0",
")",
";",
"if",
"(",
"error",
")",
"return",
"(",
"0",
")",
";",
"error",
"=",
"(",
"p",
"->",
"kp_pid",
"==",
"kp",
".",
"kp_pid",
"&&",
"(",
"kp",
".",
"kp_stat",
"!=",
"SZOMB",
"||",
"p",
"->",
"kp_stat",
"==",
"SZOMB",
")",
")",
";",
"return",
"(",
"error",
")",
";",
"}"
] | Determine if the proc indicated by p is still active. | [
"Determine",
"if",
"the",
"proc",
"indicated",
"by",
"p",
"is",
"still",
"active",
"."
] | [] | [
{
"param": "p",
"type": "struct kinfo_proc"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "p",
"type": "struct kinfo_proc",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
e0211c884070b0ea294ef29589190400ca608f38 | atrens/DragonFlyBSD-src | lib/libkvm/kvm_proc.c | [
"BSD-3-Clause"
] | C | kvm_uread | ssize_t | ssize_t
kvm_uread(kvm_t *kd, pid_t pid, u_long uva, char *buf, size_t len)
{
char *cp;
char procfile[MAXPATHLEN];
ssize_t amount;
int fd;
if (!kvm_ishost(kd)) { /* XXX: vkernels */
_kvm_err(kd, kd->program,
"cannot read user space from dead kernel");
return (0);
}
sprintf(procfile, "/proc/%d/mem", pid);
fd = open(procfile, O_RDONLY, 0);
if (fd < 0) {
_kvm_err(kd, kd->program, "cannot open %s", procfile);
close(fd);
return (0);
}
cp = buf;
while (len > 0) {
errno = 0;
if (lseek(fd, (off_t)uva, 0) == -1 && errno != 0) {
_kvm_err(kd, kd->program, "invalid address (%lx) in %s",
uva, procfile);
break;
}
amount = read(fd, cp, len);
if (amount < 0) {
_kvm_syserr(kd, kd->program, "error reading %s",
procfile);
break;
}
if (amount == 0) {
_kvm_err(kd, kd->program, "EOF reading %s", procfile);
break;
}
cp += amount;
uva += amount;
len -= amount;
}
close(fd);
return ((ssize_t)(cp - buf));
} | /*
* Read from user space. The user context is given by pid.
*/ | Read from user space. The user context is given by pid. | [
"Read",
"from",
"user",
"space",
".",
"The",
"user",
"context",
"is",
"given",
"by",
"pid",
"."
] | ssize_t
kvm_uread(kvm_t *kd, pid_t pid, u_long uva, char *buf, size_t len)
{
char *cp;
char procfile[MAXPATHLEN];
ssize_t amount;
int fd;
if (!kvm_ishost(kd)) {
_kvm_err(kd, kd->program,
"cannot read user space from dead kernel");
return (0);
}
sprintf(procfile, "/proc/%d/mem", pid);
fd = open(procfile, O_RDONLY, 0);
if (fd < 0) {
_kvm_err(kd, kd->program, "cannot open %s", procfile);
close(fd);
return (0);
}
cp = buf;
while (len > 0) {
errno = 0;
if (lseek(fd, (off_t)uva, 0) == -1 && errno != 0) {
_kvm_err(kd, kd->program, "invalid address (%lx) in %s",
uva, procfile);
break;
}
amount = read(fd, cp, len);
if (amount < 0) {
_kvm_syserr(kd, kd->program, "error reading %s",
procfile);
break;
}
if (amount == 0) {
_kvm_err(kd, kd->program, "EOF reading %s", procfile);
break;
}
cp += amount;
uva += amount;
len -= amount;
}
close(fd);
return ((ssize_t)(cp - buf));
} | [
"ssize_t",
"kvm_uread",
"(",
"kvm_t",
"*",
"kd",
",",
"pid_t",
"pid",
",",
"u_long",
"uva",
",",
"char",
"*",
"buf",
",",
"size_t",
"len",
")",
"{",
"char",
"*",
"cp",
";",
"char",
"procfile",
"[",
"MAXPATHLEN",
"]",
";",
"ssize_t",
"amount",
";",
"int",
"fd",
";",
"if",
"(",
"!",
"kvm_ishost",
"(",
"kd",
")",
")",
"{",
"_kvm_err",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
")",
";",
"return",
"(",
"0",
")",
";",
"}",
"sprintf",
"(",
"procfile",
",",
"\"",
"\"",
",",
"pid",
")",
";",
"fd",
"=",
"open",
"(",
"procfile",
",",
"O_RDONLY",
",",
"0",
")",
";",
"if",
"(",
"fd",
"<",
"0",
")",
"{",
"_kvm_err",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
",",
"procfile",
")",
";",
"close",
"(",
"fd",
")",
";",
"return",
"(",
"0",
")",
";",
"}",
"cp",
"=",
"buf",
";",
"while",
"(",
"len",
">",
"0",
")",
"{",
"errno",
"=",
"0",
";",
"if",
"(",
"lseek",
"(",
"fd",
",",
"(",
"off_t",
")",
"uva",
",",
"0",
")",
"==",
"-1",
"&&",
"errno",
"!=",
"0",
")",
"{",
"_kvm_err",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
",",
"uva",
",",
"procfile",
")",
";",
"break",
";",
"}",
"amount",
"=",
"read",
"(",
"fd",
",",
"cp",
",",
"len",
")",
";",
"if",
"(",
"amount",
"<",
"0",
")",
"{",
"_kvm_syserr",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
",",
"procfile",
")",
";",
"break",
";",
"}",
"if",
"(",
"amount",
"==",
"0",
")",
"{",
"_kvm_err",
"(",
"kd",
",",
"kd",
"->",
"program",
",",
"\"",
"\"",
",",
"procfile",
")",
";",
"break",
";",
"}",
"cp",
"+=",
"amount",
";",
"uva",
"+=",
"amount",
";",
"len",
"-=",
"amount",
";",
"}",
"close",
"(",
"fd",
")",
";",
"return",
"(",
"(",
"ssize_t",
")",
"(",
"cp",
"-",
"buf",
")",
")",
";",
"}"
] | Read from user space. | [
"Read",
"from",
"user",
"space",
"."
] | [
"/* XXX: vkernels */"
] | [
{
"param": "kd",
"type": "kvm_t"
},
{
"param": "pid",
"type": "pid_t"
},
{
"param": "uva",
"type": "u_long"
},
{
"param": "buf",
"type": "char"
},
{
"param": "len",
"type": "size_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "kd",
"type": "kvm_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "pid",
"type": "pid_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "uva",
"type": "u_long",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "buf",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "len",
"type": "size_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33d046005916574f3674b52760ca044f1296a464 | atrens/DragonFlyBSD-src | sys/crypto/blowfish/bf_enc.c | [
"BSD-3-Clause"
] | C | BF_encrypt | void | void
BF_encrypt(BF_LONG *data, BF_KEY *key)
{
BF_LONG l, r, *p, *s;
p = key->P;
s= &key->S[0];
l = data[0];
r = data[1];
l^=p[0];
BF_ENC(r, l, s, p[ 1]);
BF_ENC(l, r, s, p[ 2]);
BF_ENC(r, l, s, p[ 3]);
BF_ENC(l, r, s, p[ 4]);
BF_ENC(r, l, s, p[ 5]);
BF_ENC(l, r, s, p[ 6]);
BF_ENC(r, l, s, p[ 7]);
BF_ENC(l, r, s, p[ 8]);
BF_ENC(r, l, s, p[ 9]);
BF_ENC(l, r, s, p[10]);
BF_ENC(r, l, s, p[11]);
BF_ENC(l, r, s, p[12]);
BF_ENC(r, l, s, p[13]);
BF_ENC(l, r, s, p[14]);
BF_ENC(r, l, s, p[15]);
BF_ENC(l, r, s, p[16]);
#if BF_ROUNDS == 20
BF_ENC(r, l, s, p[17]);
BF_ENC(l, r, s, p[18]);
BF_ENC(r, l, s, p[19]);
BF_ENC(l, r, s, p[20]);
#endif
r ^= p[BF_ROUNDS + 1];
data[1] = l & 0xffffffff;
data[0] = r & 0xffffffff;
} | /* XXX "data" is host endian */ | XXX "data" is host endian | [
"XXX",
"\"",
"data",
"\"",
"is",
"host",
"endian"
] | void
BF_encrypt(BF_LONG *data, BF_KEY *key)
{
BF_LONG l, r, *p, *s;
p = key->P;
s= &key->S[0];
l = data[0];
r = data[1];
l^=p[0];
BF_ENC(r, l, s, p[ 1]);
BF_ENC(l, r, s, p[ 2]);
BF_ENC(r, l, s, p[ 3]);
BF_ENC(l, r, s, p[ 4]);
BF_ENC(r, l, s, p[ 5]);
BF_ENC(l, r, s, p[ 6]);
BF_ENC(r, l, s, p[ 7]);
BF_ENC(l, r, s, p[ 8]);
BF_ENC(r, l, s, p[ 9]);
BF_ENC(l, r, s, p[10]);
BF_ENC(r, l, s, p[11]);
BF_ENC(l, r, s, p[12]);
BF_ENC(r, l, s, p[13]);
BF_ENC(l, r, s, p[14]);
BF_ENC(r, l, s, p[15]);
BF_ENC(l, r, s, p[16]);
#if BF_ROUNDS == 20
BF_ENC(r, l, s, p[17]);
BF_ENC(l, r, s, p[18]);
BF_ENC(r, l, s, p[19]);
BF_ENC(l, r, s, p[20]);
#endif
r ^= p[BF_ROUNDS + 1];
data[1] = l & 0xffffffff;
data[0] = r & 0xffffffff;
} | [
"void",
"BF_encrypt",
"(",
"BF_LONG",
"*",
"data",
",",
"BF_KEY",
"*",
"key",
")",
"{",
"BF_LONG",
"l",
",",
"r",
",",
"*",
"p",
",",
"*",
"s",
";",
"p",
"=",
"key",
"->",
"P",
";",
"s",
"=",
"&",
"key",
"->",
"S",
"[",
"0",
"]",
";",
"l",
"=",
"data",
"[",
"0",
"]",
";",
"r",
"=",
"data",
"[",
"1",
"]",
";",
"l",
"^=",
"p",
"[",
"0",
"]",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"1",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"2",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"3",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"4",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"5",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"6",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"7",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"8",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"9",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"10",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"11",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"12",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"13",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"14",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"15",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"16",
"]",
")",
";",
"#if",
"BF_ROUNDS",
"==",
"20",
"\n",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"17",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"18",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"19",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"20",
"]",
")",
";",
"#endif",
"r",
"^=",
"p",
"[",
"BF_ROUNDS",
"+",
"1",
"]",
";",
"data",
"[",
"1",
"]",
"=",
"l",
"&",
"0xffffffff",
";",
"data",
"[",
"0",
"]",
"=",
"r",
"&",
"0xffffffff",
";",
"}"
] | XXX "data" is host endian | [
"XXX",
"\"",
"data",
"\"",
"is",
"host",
"endian"
] | [] | [
{
"param": "data",
"type": "BF_LONG"
},
{
"param": "key",
"type": "BF_KEY"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "data",
"type": "BF_LONG",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "key",
"type": "BF_KEY",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33d046005916574f3674b52760ca044f1296a464 | atrens/DragonFlyBSD-src | sys/crypto/blowfish/bf_enc.c | [
"BSD-3-Clause"
] | C | BF_decrypt | void | void
BF_decrypt(BF_LONG *data, BF_KEY *key)
{
BF_LONG l, r, *p, *s;
p = key->P;
s= &key->S[0];
l = data[0];
r = data[1];
l ^= p[BF_ROUNDS + 1];
#if BF_ROUNDS == 20
BF_ENC(r, l, s, p[20]);
BF_ENC(l, r, s, p[19]);
BF_ENC(r, l, s, p[18]);
BF_ENC(l, r, s, p[17]);
#endif
BF_ENC(r, l, s, p[16]);
BF_ENC(l, r, s, p[15]);
BF_ENC(r, l, s, p[14]);
BF_ENC(l, r, s, p[13]);
BF_ENC(r, l, s, p[12]);
BF_ENC(l, r, s, p[11]);
BF_ENC(r, l, s, p[10]);
BF_ENC(l, r, s, p[ 9]);
BF_ENC(r, l, s, p[ 8]);
BF_ENC(l, r, s, p[ 7]);
BF_ENC(r, l, s, p[ 6]);
BF_ENC(l, r, s, p[ 5]);
BF_ENC(r, l, s, p[ 4]);
BF_ENC(l, r, s, p[ 3]);
BF_ENC(r, l, s, p[ 2]);
BF_ENC(l, r, s, p[ 1]);
r ^= p[0];
data[1] = l & 0xffffffff;
data[0] = r & 0xffffffff;
} | /* XXX "data" is host endian */ | XXX "data" is host endian | [
"XXX",
"\"",
"data",
"\"",
"is",
"host",
"endian"
] | void
BF_decrypt(BF_LONG *data, BF_KEY *key)
{
BF_LONG l, r, *p, *s;
p = key->P;
s= &key->S[0];
l = data[0];
r = data[1];
l ^= p[BF_ROUNDS + 1];
#if BF_ROUNDS == 20
BF_ENC(r, l, s, p[20]);
BF_ENC(l, r, s, p[19]);
BF_ENC(r, l, s, p[18]);
BF_ENC(l, r, s, p[17]);
#endif
BF_ENC(r, l, s, p[16]);
BF_ENC(l, r, s, p[15]);
BF_ENC(r, l, s, p[14]);
BF_ENC(l, r, s, p[13]);
BF_ENC(r, l, s, p[12]);
BF_ENC(l, r, s, p[11]);
BF_ENC(r, l, s, p[10]);
BF_ENC(l, r, s, p[ 9]);
BF_ENC(r, l, s, p[ 8]);
BF_ENC(l, r, s, p[ 7]);
BF_ENC(r, l, s, p[ 6]);
BF_ENC(l, r, s, p[ 5]);
BF_ENC(r, l, s, p[ 4]);
BF_ENC(l, r, s, p[ 3]);
BF_ENC(r, l, s, p[ 2]);
BF_ENC(l, r, s, p[ 1]);
r ^= p[0];
data[1] = l & 0xffffffff;
data[0] = r & 0xffffffff;
} | [
"void",
"BF_decrypt",
"(",
"BF_LONG",
"*",
"data",
",",
"BF_KEY",
"*",
"key",
")",
"{",
"BF_LONG",
"l",
",",
"r",
",",
"*",
"p",
",",
"*",
"s",
";",
"p",
"=",
"key",
"->",
"P",
";",
"s",
"=",
"&",
"key",
"->",
"S",
"[",
"0",
"]",
";",
"l",
"=",
"data",
"[",
"0",
"]",
";",
"r",
"=",
"data",
"[",
"1",
"]",
";",
"l",
"^=",
"p",
"[",
"BF_ROUNDS",
"+",
"1",
"]",
";",
"#if",
"BF_ROUNDS",
"==",
"20",
"\n",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"20",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"19",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"18",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"17",
"]",
")",
";",
"#endif",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"16",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"15",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"14",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"13",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"12",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"11",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"10",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"9",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"8",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"7",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"6",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"5",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"4",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"3",
"]",
")",
";",
"BF_ENC",
"(",
"r",
",",
"l",
",",
"s",
",",
"p",
"[",
"2",
"]",
")",
";",
"BF_ENC",
"(",
"l",
",",
"r",
",",
"s",
",",
"p",
"[",
"1",
"]",
")",
";",
"r",
"^=",
"p",
"[",
"0",
"]",
";",
"data",
"[",
"1",
"]",
"=",
"l",
"&",
"0xffffffff",
";",
"data",
"[",
"0",
"]",
"=",
"r",
"&",
"0xffffffff",
";",
"}"
] | XXX "data" is host endian | [
"XXX",
"\"",
"data",
"\"",
"is",
"host",
"endian"
] | [] | [
{
"param": "data",
"type": "BF_LONG"
},
{
"param": "key",
"type": "BF_KEY"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "data",
"type": "BF_LONG",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "key",
"type": "BF_KEY",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a799ab7a74ccca70dad2cdeb12fb31ab1e84e9fe | atrens/DragonFlyBSD-src | lib/libstand/environment.c | [
"BSD-3-Clause"
] | C | env_setenv | int | int
env_setenv(const char *name, int flags, const void *value,
ev_sethook_t sethook, ev_unsethook_t unsethook)
{
struct env_var *ev, *curr, *last;
if ((ev = env_getenv(name)) != NULL) {
/*
* If there's a set hook, let it do the work (unless we are working
* for one already.
*/
if ((ev->ev_sethook != NULL) && !(flags & EV_NOHOOK))
return(ev->ev_sethook(ev, flags, value));
} else {
/*
* New variable; create and sort into list
*/
ev = malloc(sizeof(struct env_var));
ev->ev_name = strdup(name);
ev->ev_value = NULL;
/* hooks can only be set when the variable is instantiated */
ev->ev_sethook = sethook;
ev->ev_unsethook = unsethook;
/* Sort into list */
ev->ev_prev = NULL;
ev->ev_next = NULL;
/* Search for the record to insert before */
for (last = NULL, curr = environ;
curr != NULL;
last = curr, curr = curr->ev_next) {
if (strcmp(ev->ev_name, curr->ev_name) < 0) {
if (curr->ev_prev) {
curr->ev_prev->ev_next = ev;
} else {
environ = ev;
}
ev->ev_next = curr;
ev->ev_prev = curr->ev_prev;
curr->ev_prev = ev;
break;
}
}
if (curr == NULL) {
if (last == NULL) {
environ = ev;
} else {
last->ev_next = ev;
ev->ev_prev = last;
}
}
}
/* If there is data in the variable, discard it */
if (ev->ev_value != NULL)
free(ev->ev_value);
/* If we have a new value, use it */
if (flags & EV_VOLATILE) {
ev->ev_value = strdup(value);
} else {
ev->ev_value = (char *)value;
}
/* Keep the flag components that are relevant */
ev->ev_flags = flags & (EV_DYNAMIC);
return(0);
} | /*
* Some notes:
*
* If the EV_VOLATILE flag is set, a copy of the variable is made.
* If EV_DYNAMIC is set, the the variable has been allocated with
* malloc and ownership transferred to the environment.
* If (value) is NULL, the variable is set but has no value.
*/ | Some notes:
If the EV_VOLATILE flag is set, a copy of the variable is made.
If EV_DYNAMIC is set, the the variable has been allocated with
malloc and ownership transferred to the environment.
If (value) is NULL, the variable is set but has no value. | [
"Some",
"notes",
":",
"If",
"the",
"EV_VOLATILE",
"flag",
"is",
"set",
"a",
"copy",
"of",
"the",
"variable",
"is",
"made",
".",
"If",
"EV_DYNAMIC",
"is",
"set",
"the",
"the",
"variable",
"has",
"been",
"allocated",
"with",
"malloc",
"and",
"ownership",
"transferred",
"to",
"the",
"environment",
".",
"If",
"(",
"value",
")",
"is",
"NULL",
"the",
"variable",
"is",
"set",
"but",
"has",
"no",
"value",
"."
] | int
env_setenv(const char *name, int flags, const void *value,
ev_sethook_t sethook, ev_unsethook_t unsethook)
{
struct env_var *ev, *curr, *last;
if ((ev = env_getenv(name)) != NULL) {
if ((ev->ev_sethook != NULL) && !(flags & EV_NOHOOK))
return(ev->ev_sethook(ev, flags, value));
} else {
ev = malloc(sizeof(struct env_var));
ev->ev_name = strdup(name);
ev->ev_value = NULL;
ev->ev_sethook = sethook;
ev->ev_unsethook = unsethook;
ev->ev_prev = NULL;
ev->ev_next = NULL;
for (last = NULL, curr = environ;
curr != NULL;
last = curr, curr = curr->ev_next) {
if (strcmp(ev->ev_name, curr->ev_name) < 0) {
if (curr->ev_prev) {
curr->ev_prev->ev_next = ev;
} else {
environ = ev;
}
ev->ev_next = curr;
ev->ev_prev = curr->ev_prev;
curr->ev_prev = ev;
break;
}
}
if (curr == NULL) {
if (last == NULL) {
environ = ev;
} else {
last->ev_next = ev;
ev->ev_prev = last;
}
}
}
if (ev->ev_value != NULL)
free(ev->ev_value);
if (flags & EV_VOLATILE) {
ev->ev_value = strdup(value);
} else {
ev->ev_value = (char *)value;
}
ev->ev_flags = flags & (EV_DYNAMIC);
return(0);
} | [
"int",
"env_setenv",
"(",
"const",
"char",
"*",
"name",
",",
"int",
"flags",
",",
"const",
"void",
"*",
"value",
",",
"ev_sethook_t",
"sethook",
",",
"ev_unsethook_t",
"unsethook",
")",
"{",
"struct",
"env_var",
"*",
"ev",
",",
"*",
"curr",
",",
"*",
"last",
";",
"if",
"(",
"(",
"ev",
"=",
"env_getenv",
"(",
"name",
")",
")",
"!=",
"NULL",
")",
"{",
"if",
"(",
"(",
"ev",
"->",
"ev_sethook",
"!=",
"NULL",
")",
"&&",
"!",
"(",
"flags",
"&",
"EV_NOHOOK",
")",
")",
"return",
"(",
"ev",
"->",
"ev_sethook",
"(",
"ev",
",",
"flags",
",",
"value",
")",
")",
";",
"}",
"else",
"{",
"ev",
"=",
"malloc",
"(",
"sizeof",
"(",
"struct",
"env_var",
")",
")",
";",
"ev",
"->",
"ev_name",
"=",
"strdup",
"(",
"name",
")",
";",
"ev",
"->",
"ev_value",
"=",
"NULL",
";",
"ev",
"->",
"ev_sethook",
"=",
"sethook",
";",
"ev",
"->",
"ev_unsethook",
"=",
"unsethook",
";",
"ev",
"->",
"ev_prev",
"=",
"NULL",
";",
"ev",
"->",
"ev_next",
"=",
"NULL",
";",
"for",
"(",
"last",
"=",
"NULL",
",",
"curr",
"=",
"environ",
";",
"curr",
"!=",
"NULL",
";",
"last",
"=",
"curr",
",",
"curr",
"=",
"curr",
"->",
"ev_next",
")",
"{",
"if",
"(",
"strcmp",
"(",
"ev",
"->",
"ev_name",
",",
"curr",
"->",
"ev_name",
")",
"<",
"0",
")",
"{",
"if",
"(",
"curr",
"->",
"ev_prev",
")",
"{",
"curr",
"->",
"ev_prev",
"->",
"ev_next",
"=",
"ev",
";",
"}",
"else",
"{",
"environ",
"=",
"ev",
";",
"}",
"ev",
"->",
"ev_next",
"=",
"curr",
";",
"ev",
"->",
"ev_prev",
"=",
"curr",
"->",
"ev_prev",
";",
"curr",
"->",
"ev_prev",
"=",
"ev",
";",
"break",
";",
"}",
"}",
"if",
"(",
"curr",
"==",
"NULL",
")",
"{",
"if",
"(",
"last",
"==",
"NULL",
")",
"{",
"environ",
"=",
"ev",
";",
"}",
"else",
"{",
"last",
"->",
"ev_next",
"=",
"ev",
";",
"ev",
"->",
"ev_prev",
"=",
"last",
";",
"}",
"}",
"}",
"if",
"(",
"ev",
"->",
"ev_value",
"!=",
"NULL",
")",
"free",
"(",
"ev",
"->",
"ev_value",
")",
";",
"if",
"(",
"flags",
"&",
"EV_VOLATILE",
")",
"{",
"ev",
"->",
"ev_value",
"=",
"strdup",
"(",
"value",
")",
";",
"}",
"else",
"{",
"ev",
"->",
"ev_value",
"=",
"(",
"char",
"*",
")",
"value",
";",
"}",
"ev",
"->",
"ev_flags",
"=",
"flags",
"&",
"(",
"EV_DYNAMIC",
")",
";",
"return",
"(",
"0",
")",
";",
"}"
] | Some notes:
If the EV_VOLATILE flag is set, a copy of the variable is made. | [
"Some",
"notes",
":",
"If",
"the",
"EV_VOLATILE",
"flag",
"is",
"set",
"a",
"copy",
"of",
"the",
"variable",
"is",
"made",
"."
] | [
"/*\n\t * If there's a set hook, let it do the work (unless we are working\n\t * for one already.\n\t */",
"/*\n\t * New variable; create and sort into list\n\t */",
"/* hooks can only be set when the variable is instantiated */",
"/* Sort into list */",
"/* Search for the record to insert before */",
"/* If there is data in the variable, discard it */",
"/* If we have a new value, use it */",
"/* Keep the flag components that are relevant */"
] | [
{
"param": "name",
"type": "char"
},
{
"param": "flags",
"type": "int"
},
{
"param": "value",
"type": "void"
},
{
"param": "sethook",
"type": "ev_sethook_t"
},
{
"param": "unsethook",
"type": "ev_unsethook_t"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "name",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flags",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "value",
"type": "void",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "sethook",
"type": "ev_sethook_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "unsethook",
"type": "ev_unsethook_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
33a4f30227a887ff3788226005739c379ec69d8c | atrens/DragonFlyBSD-src | sys/bus/pci/x86_64/pci_cfgreg.c | [
"BSD-3-Clause"
] | C | pci_cfgregopen | int | int
pci_cfgregopen(void)
{
static int inited = 0;
uint64_t pciebar;
uint16_t vid, did;
if (!inited) {
inited = 1;
spin_init(&pcicfg_spin, "pcicfg");
}
if (cfgmech != CFGMECH_NONE)
return 1;
cfgmech = CFGMECH_1;
/*
* Grope around in the PCI config space to see if this is a
* chipset that is capable of doing memory-mapped config cycles.
* This also implies that it can do PCIe extended config cycles.
*/
/* Check for supported chipsets */
vid = pci_cfgregread(0, 0, 0, PCIR_VENDOR, 2);
did = pci_cfgregread(0, 0, 0, PCIR_DEVICE, 2);
switch (vid) {
case 0x8086:
switch (did) {
case 0x3590:
case 0x3592:
/* Intel 7520 or 7320 */
pciebar = pci_cfgregread(0, 0, 0, 0xce, 2) << 16;
pcie_cfgregopen(pciebar, 0, 255);
break;
case 0x2580:
case 0x2584:
case 0x2590:
/* Intel 915, 925, or 915GM */
pciebar = pci_cfgregread(0, 0, 0, 0x48, 4);
pcie_cfgregopen(pciebar, 0, 255);
break;
}
}
return 1;
} | /*
* Initialise access to PCI configuration space
*/ | Initialise access to PCI configuration space | [
"Initialise",
"access",
"to",
"PCI",
"configuration",
"space"
] | int
pci_cfgregopen(void)
{
static int inited = 0;
uint64_t pciebar;
uint16_t vid, did;
if (!inited) {
inited = 1;
spin_init(&pcicfg_spin, "pcicfg");
}
if (cfgmech != CFGMECH_NONE)
return 1;
cfgmech = CFGMECH_1;
vid = pci_cfgregread(0, 0, 0, PCIR_VENDOR, 2);
did = pci_cfgregread(0, 0, 0, PCIR_DEVICE, 2);
switch (vid) {
case 0x8086:
switch (did) {
case 0x3590:
case 0x3592:
pciebar = pci_cfgregread(0, 0, 0, 0xce, 2) << 16;
pcie_cfgregopen(pciebar, 0, 255);
break;
case 0x2580:
case 0x2584:
case 0x2590:
pciebar = pci_cfgregread(0, 0, 0, 0x48, 4);
pcie_cfgregopen(pciebar, 0, 255);
break;
}
}
return 1;
} | [
"int",
"pci_cfgregopen",
"(",
"void",
")",
"{",
"static",
"int",
"inited",
"=",
"0",
";",
"uint64_t",
"pciebar",
";",
"uint16_t",
"vid",
",",
"did",
";",
"if",
"(",
"!",
"inited",
")",
"{",
"inited",
"=",
"1",
";",
"spin_init",
"(",
"&",
"pcicfg_spin",
",",
"\"",
"\"",
")",
";",
"}",
"if",
"(",
"cfgmech",
"!=",
"CFGMECH_NONE",
")",
"return",
"1",
";",
"cfgmech",
"=",
"CFGMECH_1",
";",
"vid",
"=",
"pci_cfgregread",
"(",
"0",
",",
"0",
",",
"0",
",",
"PCIR_VENDOR",
",",
"2",
")",
";",
"did",
"=",
"pci_cfgregread",
"(",
"0",
",",
"0",
",",
"0",
",",
"PCIR_DEVICE",
",",
"2",
")",
";",
"switch",
"(",
"vid",
")",
"{",
"case",
"0x8086",
":",
"switch",
"(",
"did",
")",
"{",
"case",
"0x3590",
":",
"case",
"0x3592",
":",
"pciebar",
"=",
"pci_cfgregread",
"(",
"0",
",",
"0",
",",
"0",
",",
"0xce",
",",
"2",
")",
"<<",
"16",
";",
"pcie_cfgregopen",
"(",
"pciebar",
",",
"0",
",",
"255",
")",
";",
"break",
";",
"case",
"0x2580",
":",
"case",
"0x2584",
":",
"case",
"0x2590",
":",
"pciebar",
"=",
"pci_cfgregread",
"(",
"0",
",",
"0",
",",
"0",
",",
"0x48",
",",
"4",
")",
";",
"pcie_cfgregopen",
"(",
"pciebar",
",",
"0",
",",
"255",
")",
";",
"break",
";",
"}",
"}",
"return",
"1",
";",
"}"
] | Initialise access to PCI configuration space | [
"Initialise",
"access",
"to",
"PCI",
"configuration",
"space"
] | [
"/*\n\t * Grope around in the PCI config space to see if this is a\n\t * chipset that is capable of doing memory-mapped config cycles.\n\t * This also implies that it can do PCIe extended config cycles.\n\t */",
"/* Check for supported chipsets */",
"/* Intel 7520 or 7320 */",
"/* Intel 915, 925, or 915GM */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
33a4f30227a887ff3788226005739c379ec69d8c | atrens/DragonFlyBSD-src | sys/bus/pci/x86_64/pci_cfgreg.c | [
"BSD-3-Clause"
] | C | pci_cfgenable | int | static int
pci_cfgenable(unsigned bus, unsigned slot, unsigned func, int reg, int bytes)
{
int dataport = 0;
if (bus <= PCI_BUSMAX &&
slot <= PCI_SLOTMAX &&
func <= PCI_FUNCMAX &&
(unsigned)reg <= PCI_REGMAX &&
bytes != 3 &&
(unsigned)bytes <= 4 &&
(reg & (bytes - 1)) == 0) {
outl(CONF1_ADDR_PORT, (1 << 31) | (bus << 16) | (slot << 11) |
(func << 8) | (reg & ~0x03));
dataport = CONF1_DATA_PORT + (reg & 0x03);
}
return dataport;
} | /* enable configuration space accesses and return data port address */ | enable configuration space accesses and return data port address | [
"enable",
"configuration",
"space",
"accesses",
"and",
"return",
"data",
"port",
"address"
] | static int
pci_cfgenable(unsigned bus, unsigned slot, unsigned func, int reg, int bytes)
{
int dataport = 0;
if (bus <= PCI_BUSMAX &&
slot <= PCI_SLOTMAX &&
func <= PCI_FUNCMAX &&
(unsigned)reg <= PCI_REGMAX &&
bytes != 3 &&
(unsigned)bytes <= 4 &&
(reg & (bytes - 1)) == 0) {
outl(CONF1_ADDR_PORT, (1 << 31) | (bus << 16) | (slot << 11) |
(func << 8) | (reg & ~0x03));
dataport = CONF1_DATA_PORT + (reg & 0x03);
}
return dataport;
} | [
"static",
"int",
"pci_cfgenable",
"(",
"unsigned",
"bus",
",",
"unsigned",
"slot",
",",
"unsigned",
"func",
",",
"int",
"reg",
",",
"int",
"bytes",
")",
"{",
"int",
"dataport",
"=",
"0",
";",
"if",
"(",
"bus",
"<=",
"PCI_BUSMAX",
"&&",
"slot",
"<=",
"PCI_SLOTMAX",
"&&",
"func",
"<=",
"PCI_FUNCMAX",
"&&",
"(",
"unsigned",
")",
"reg",
"<=",
"PCI_REGMAX",
"&&",
"bytes",
"!=",
"3",
"&&",
"(",
"unsigned",
")",
"bytes",
"<=",
"4",
"&&",
"(",
"reg",
"&",
"(",
"bytes",
"-",
"1",
")",
")",
"==",
"0",
")",
"{",
"outl",
"(",
"CONF1_ADDR_PORT",
",",
"(",
"1",
"<<",
"31",
")",
"|",
"(",
"bus",
"<<",
"16",
")",
"|",
"(",
"slot",
"<<",
"11",
")",
"|",
"(",
"func",
"<<",
"8",
")",
"|",
"(",
"reg",
"&",
"~",
"0x03",
")",
")",
";",
"dataport",
"=",
"CONF1_DATA_PORT",
"+",
"(",
"reg",
"&",
"0x03",
")",
";",
"}",
"return",
"dataport",
";",
"}"
] | enable configuration space accesses and return data port address | [
"enable",
"configuration",
"space",
"accesses",
"and",
"return",
"data",
"port",
"address"
] | [] | [
{
"param": "bus",
"type": "unsigned"
},
{
"param": "slot",
"type": "unsigned"
},
{
"param": "func",
"type": "unsigned"
},
{
"param": "reg",
"type": "int"
},
{
"param": "bytes",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "bus",
"type": "unsigned",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "slot",
"type": "unsigned",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "func",
"type": "unsigned",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "reg",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bytes",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
a715b9d50b352824f5de62fe4b985b8fda3c3242 | atrens/DragonFlyBSD-src | sys/boot/common/console.c | [
"BSD-3-Clause"
] | C | cons_probe | void | void
cons_probe(void)
{
int cons;
int active;
char *prefconsole;
/*
* Probe all available consoles
*/
for (cons = 0; consoles[cons] != NULL; cons++) {
consoles[cons]->c_flags = 0;
consoles[cons]->c_probe(consoles[cons]);
}
/*
* Get our console preference. If there is no preference, all
* available consoles will be made active in parallel. Otherwise
* only the specified console is activated.
*/
active = -1;
if ((prefconsole = getenv("console")) != NULL) {
for (cons = 0; consoles[cons] != NULL; cons++) {
if (strcmp(prefconsole, consoles[cons]->c_name) == 0) {
if (consoles[cons]->c_flags & (C_PRESENTIN | C_PRESENTOUT))
active = cons;
}
}
unsetenv("console");
if (active >= 0) {
env_setenv("console", EV_VOLATILE, consoles[active]->c_name,
cons_set, env_nounset);
}
}
/*
* Active the active console or all consoles if active is -1.
*/
for (cons = 0; consoles[cons] != NULL; cons++) {
if ((active == -1 || cons == active) &&
(consoles[cons]->c_flags & (C_PRESENTIN|C_PRESENTOUT))
) {
consoles[cons]->c_flags |= (C_ACTIVEIN | C_ACTIVEOUT);
consoles[cons]->c_init(0);
printf("Console: %s\n", consoles[cons]->c_desc);
}
}
} | /*
* Detect possible console(s) to use. The first probed console
* is marked active. Also create the console variable.
*
* XXX Add logic for multiple console support.
*/ | Detect possible console(s) to use. The first probed console
is marked active. Also create the console variable.
XXX Add logic for multiple console support. | [
"Detect",
"possible",
"console",
"(",
"s",
")",
"to",
"use",
".",
"The",
"first",
"probed",
"console",
"is",
"marked",
"active",
".",
"Also",
"create",
"the",
"console",
"variable",
".",
"XXX",
"Add",
"logic",
"for",
"multiple",
"console",
"support",
"."
] | void
cons_probe(void)
{
int cons;
int active;
char *prefconsole;
for (cons = 0; consoles[cons] != NULL; cons++) {
consoles[cons]->c_flags = 0;
consoles[cons]->c_probe(consoles[cons]);
}
active = -1;
if ((prefconsole = getenv("console")) != NULL) {
for (cons = 0; consoles[cons] != NULL; cons++) {
if (strcmp(prefconsole, consoles[cons]->c_name) == 0) {
if (consoles[cons]->c_flags & (C_PRESENTIN | C_PRESENTOUT))
active = cons;
}
}
unsetenv("console");
if (active >= 0) {
env_setenv("console", EV_VOLATILE, consoles[active]->c_name,
cons_set, env_nounset);
}
}
for (cons = 0; consoles[cons] != NULL; cons++) {
if ((active == -1 || cons == active) &&
(consoles[cons]->c_flags & (C_PRESENTIN|C_PRESENTOUT))
) {
consoles[cons]->c_flags |= (C_ACTIVEIN | C_ACTIVEOUT);
consoles[cons]->c_init(0);
printf("Console: %s\n", consoles[cons]->c_desc);
}
}
} | [
"void",
"cons_probe",
"(",
"void",
")",
"{",
"int",
"cons",
";",
"int",
"active",
";",
"char",
"*",
"prefconsole",
";",
"for",
"(",
"cons",
"=",
"0",
";",
"consoles",
"[",
"cons",
"]",
"!=",
"NULL",
";",
"cons",
"++",
")",
"{",
"consoles",
"[",
"cons",
"]",
"->",
"c_flags",
"=",
"0",
";",
"consoles",
"[",
"cons",
"]",
"->",
"c_probe",
"(",
"consoles",
"[",
"cons",
"]",
")",
";",
"}",
"active",
"=",
"-1",
";",
"if",
"(",
"(",
"prefconsole",
"=",
"getenv",
"(",
"\"",
"\"",
")",
")",
"!=",
"NULL",
")",
"{",
"for",
"(",
"cons",
"=",
"0",
";",
"consoles",
"[",
"cons",
"]",
"!=",
"NULL",
";",
"cons",
"++",
")",
"{",
"if",
"(",
"strcmp",
"(",
"prefconsole",
",",
"consoles",
"[",
"cons",
"]",
"->",
"c_name",
")",
"==",
"0",
")",
"{",
"if",
"(",
"consoles",
"[",
"cons",
"]",
"->",
"c_flags",
"&",
"(",
"C_PRESENTIN",
"|",
"C_PRESENTOUT",
")",
")",
"active",
"=",
"cons",
";",
"}",
"}",
"unsetenv",
"(",
"\"",
"\"",
")",
";",
"if",
"(",
"active",
">=",
"0",
")",
"{",
"env_setenv",
"(",
"\"",
"\"",
",",
"EV_VOLATILE",
",",
"consoles",
"[",
"active",
"]",
"->",
"c_name",
",",
"cons_set",
",",
"env_nounset",
")",
";",
"}",
"}",
"for",
"(",
"cons",
"=",
"0",
";",
"consoles",
"[",
"cons",
"]",
"!=",
"NULL",
";",
"cons",
"++",
")",
"{",
"if",
"(",
"(",
"active",
"==",
"-1",
"||",
"cons",
"==",
"active",
")",
"&&",
"(",
"consoles",
"[",
"cons",
"]",
"->",
"c_flags",
"&",
"(",
"C_PRESENTIN",
"|",
"C_PRESENTOUT",
")",
")",
")",
"{",
"consoles",
"[",
"cons",
"]",
"->",
"c_flags",
"|=",
"(",
"C_ACTIVEIN",
"|",
"C_ACTIVEOUT",
")",
";",
"consoles",
"[",
"cons",
"]",
"->",
"c_init",
"(",
"0",
")",
";",
"printf",
"(",
"\"",
"\\n",
"\"",
",",
"consoles",
"[",
"cons",
"]",
"->",
"c_desc",
")",
";",
"}",
"}",
"}"
] | Detect possible console(s) to use. | [
"Detect",
"possible",
"console",
"(",
"s",
")",
"to",
"use",
"."
] | [
"/*\n * Probe all available consoles\n */",
"/*\n * Get our console preference. If there is no preference, all \n * available consoles will be made active in parallel. Otherwise\n * only the specified console is activated.\n */",
"/*\n * Active the active console or all consoles if active is -1.\n */"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
a715b9d50b352824f5de62fe4b985b8fda3c3242 | atrens/DragonFlyBSD-src | sys/boot/common/console.c | [
"BSD-3-Clause"
] | C | cons_set | int | static int
cons_set(struct env_var *ev, int flags, const void *value)
{
int cons, active;
if ((value == NULL) || ((active = cons_find(value)) == -1)) {
if (value != NULL)
printf("no such console '%s'\n", (char *)value);
printf("Available consoles:\n");
for (cons = 0; consoles[cons] != NULL; cons++)
printf(" %s\n", consoles[cons]->c_name);
return(CMD_ERROR);
}
/* disable all current consoles */
for (cons = 0; consoles[cons] != NULL; cons++)
consoles[cons]->c_flags &= ~(C_ACTIVEIN | C_ACTIVEOUT);
/* enable selected console */
consoles[active]->c_flags |= C_ACTIVEIN | C_ACTIVEOUT;
consoles[active]->c_init(0);
env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
return(CMD_OK);
} | /*
* Select a console.
*
* XXX Note that the console system design allows for some extension
* here (eg. multiple consoles, input/output only, etc.)
*/ | Select a console.
XXX Note that the console system design allows for some extension
here | [
"Select",
"a",
"console",
".",
"XXX",
"Note",
"that",
"the",
"console",
"system",
"design",
"allows",
"for",
"some",
"extension",
"here"
] | static int
cons_set(struct env_var *ev, int flags, const void *value)
{
int cons, active;
if ((value == NULL) || ((active = cons_find(value)) == -1)) {
if (value != NULL)
printf("no such console '%s'\n", (char *)value);
printf("Available consoles:\n");
for (cons = 0; consoles[cons] != NULL; cons++)
printf(" %s\n", consoles[cons]->c_name);
return(CMD_ERROR);
}
for (cons = 0; consoles[cons] != NULL; cons++)
consoles[cons]->c_flags &= ~(C_ACTIVEIN | C_ACTIVEOUT);
consoles[active]->c_flags |= C_ACTIVEIN | C_ACTIVEOUT;
consoles[active]->c_init(0);
env_setenv(ev->ev_name, flags | EV_NOHOOK, value, NULL, NULL);
return(CMD_OK);
} | [
"static",
"int",
"cons_set",
"(",
"struct",
"env_var",
"*",
"ev",
",",
"int",
"flags",
",",
"const",
"void",
"*",
"value",
")",
"{",
"int",
"cons",
",",
"active",
";",
"if",
"(",
"(",
"value",
"==",
"NULL",
")",
"||",
"(",
"(",
"active",
"=",
"cons_find",
"(",
"value",
")",
")",
"==",
"-1",
")",
")",
"{",
"if",
"(",
"value",
"!=",
"NULL",
")",
"printf",
"(",
"\"",
"\\n",
"\"",
",",
"(",
"char",
"*",
")",
"value",
")",
";",
"printf",
"(",
"\"",
"\\n",
"\"",
")",
";",
"for",
"(",
"cons",
"=",
"0",
";",
"consoles",
"[",
"cons",
"]",
"!=",
"NULL",
";",
"cons",
"++",
")",
"printf",
"(",
"\"",
"\\n",
"\"",
",",
"consoles",
"[",
"cons",
"]",
"->",
"c_name",
")",
";",
"return",
"(",
"CMD_ERROR",
")",
";",
"}",
"for",
"(",
"cons",
"=",
"0",
";",
"consoles",
"[",
"cons",
"]",
"!=",
"NULL",
";",
"cons",
"++",
")",
"consoles",
"[",
"cons",
"]",
"->",
"c_flags",
"&=",
"~",
"(",
"C_ACTIVEIN",
"|",
"C_ACTIVEOUT",
")",
";",
"consoles",
"[",
"active",
"]",
"->",
"c_flags",
"|=",
"C_ACTIVEIN",
"|",
"C_ACTIVEOUT",
";",
"consoles",
"[",
"active",
"]",
"->",
"c_init",
"(",
"0",
")",
";",
"env_setenv",
"(",
"ev",
"->",
"ev_name",
",",
"flags",
"|",
"EV_NOHOOK",
",",
"value",
",",
"NULL",
",",
"NULL",
")",
";",
"return",
"(",
"CMD_OK",
")",
";",
"}"
] | Select a console. | [
"Select",
"a",
"console",
"."
] | [
"/* disable all current consoles */",
"/* enable selected console */"
] | [
{
"param": "ev",
"type": "struct env_var"
},
{
"param": "flags",
"type": "int"
},
{
"param": "value",
"type": "void"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "ev",
"type": "struct env_var",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "flags",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "value",
"type": "void",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
24732e90586d0cb0449e92abeabf23c27b0c84f2 | atrens/DragonFlyBSD-src | contrib/gdb-7/gdb/gcore.c | [
"BSD-3-Clause"
] | C | create_gcore_bfd | bfd | bfd *
create_gcore_bfd (char *filename)
{
bfd *obfd = gdb_bfd_openw (filename, default_gcore_target ());
if (!obfd)
error (_("Failed to open '%s' for output."), filename);
bfd_set_format (obfd, bfd_core);
bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ());
return obfd;
} | /* create_gcore_bfd -- helper for gcore_command (exported).
Open a new bfd core file for output, and return the handle. */ | - helper for gcore_command (exported).
Open a new bfd core file for output, and return the handle. | [
"-",
"helper",
"for",
"gcore_command",
"(",
"exported",
")",
".",
"Open",
"a",
"new",
"bfd",
"core",
"file",
"for",
"output",
"and",
"return",
"the",
"handle",
"."
] | bfd *
create_gcore_bfd (char *filename)
{
bfd *obfd = gdb_bfd_openw (filename, default_gcore_target ());
if (!obfd)
error (_("Failed to open '%s' for output."), filename);
bfd_set_format (obfd, bfd_core);
bfd_set_arch_mach (obfd, default_gcore_arch (), default_gcore_mach ());
return obfd;
} | [
"bfd",
"*",
"create_gcore_bfd",
"(",
"char",
"*",
"filename",
")",
"{",
"bfd",
"*",
"obfd",
"=",
"gdb_bfd_openw",
"(",
"filename",
",",
"default_gcore_target",
"(",
")",
")",
";",
"if",
"(",
"!",
"obfd",
")",
"error",
"(",
"_",
"(",
"\"",
"\"",
")",
",",
"filename",
")",
";",
"bfd_set_format",
"(",
"obfd",
",",
"bfd_core",
")",
";",
"bfd_set_arch_mach",
"(",
"obfd",
",",
"default_gcore_arch",
"(",
")",
",",
"default_gcore_mach",
"(",
")",
")",
";",
"return",
"obfd",
";",
"}"
] | create_gcore_bfd -- helper for gcore_command (exported). | [
"create_gcore_bfd",
"--",
"helper",
"for",
"gcore_command",
"(",
"exported",
")",
"."
] | [] | [
{
"param": "filename",
"type": "char"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "filename",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
24732e90586d0cb0449e92abeabf23c27b0c84f2 | atrens/DragonFlyBSD-src | contrib/gdb-7/gdb/gcore.c | [
"BSD-3-Clause"
] | C | write_gcore_file | void | void
write_gcore_file (bfd *obfd)
{
void *note_data = NULL;
int note_size = 0;
asection *note_sec = NULL;
/* An external target method must build the notes section. */
/* FIXME: uweigand/2011-10-06: All architectures that support core file
generation should be converted to gdbarch_make_corefile_notes; at that
point, the target vector method can be removed. */
if (!gdbarch_make_corefile_notes_p (target_gdbarch ()))
note_data = target_make_corefile_notes (obfd, ¬e_size);
else
note_data = gdbarch_make_corefile_notes (target_gdbarch (), obfd, ¬e_size);
if (note_data == NULL || note_size == 0)
error (_("Target does not support core file generation."));
/* Create the note section. */
note_sec = bfd_make_section_anyway_with_flags (obfd, "note0",
SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_ALLOC);
if (note_sec == NULL)
error (_("Failed to create 'note' section for corefile: %s"),
bfd_errmsg (bfd_get_error ()));
bfd_set_section_vma (obfd, note_sec, 0);
bfd_set_section_alignment (obfd, note_sec, 0);
bfd_set_section_size (obfd, note_sec, note_size);
/* Now create the memory/load sections. */
if (gcore_memory_sections (obfd) == 0)
error (_("gcore: failed to get corefile memory sections from target."));
/* Write out the contents of the note section. */
if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size))
warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
} | /* write_gcore_file -- helper for gcore_command (exported).
Compose and write the corefile data to the core file. */ | - helper for gcore_command (exported).
Compose and write the corefile data to the core file. | [
"-",
"helper",
"for",
"gcore_command",
"(",
"exported",
")",
".",
"Compose",
"and",
"write",
"the",
"corefile",
"data",
"to",
"the",
"core",
"file",
"."
] | void
write_gcore_file (bfd *obfd)
{
void *note_data = NULL;
int note_size = 0;
asection *note_sec = NULL;
if (!gdbarch_make_corefile_notes_p (target_gdbarch ()))
note_data = target_make_corefile_notes (obfd, ¬e_size);
else
note_data = gdbarch_make_corefile_notes (target_gdbarch (), obfd, ¬e_size);
if (note_data == NULL || note_size == 0)
error (_("Target does not support core file generation."));
note_sec = bfd_make_section_anyway_with_flags (obfd, "note0",
SEC_HAS_CONTENTS
| SEC_READONLY
| SEC_ALLOC);
if (note_sec == NULL)
error (_("Failed to create 'note' section for corefile: %s"),
bfd_errmsg (bfd_get_error ()));
bfd_set_section_vma (obfd, note_sec, 0);
bfd_set_section_alignment (obfd, note_sec, 0);
bfd_set_section_size (obfd, note_sec, note_size);
if (gcore_memory_sections (obfd) == 0)
error (_("gcore: failed to get corefile memory sections from target."));
if (!bfd_set_section_contents (obfd, note_sec, note_data, 0, note_size))
warning (_("writing note section (%s)"), bfd_errmsg (bfd_get_error ()));
} | [
"void",
"write_gcore_file",
"(",
"bfd",
"*",
"obfd",
")",
"{",
"void",
"*",
"note_data",
"=",
"NULL",
";",
"int",
"note_size",
"=",
"0",
";",
"asection",
"*",
"note_sec",
"=",
"NULL",
";",
"if",
"(",
"!",
"gdbarch_make_corefile_notes_p",
"(",
"target_gdbarch",
"(",
")",
")",
")",
"note_data",
"=",
"target_make_corefile_notes",
"(",
"obfd",
",",
"&",
"note_size",
")",
";",
"else",
"note_data",
"=",
"gdbarch_make_corefile_notes",
"(",
"target_gdbarch",
"(",
")",
",",
"obfd",
",",
"&",
"note_size",
")",
";",
"if",
"(",
"note_data",
"==",
"NULL",
"||",
"note_size",
"==",
"0",
")",
"error",
"(",
"_",
"(",
"\"",
"\"",
")",
")",
";",
"note_sec",
"=",
"bfd_make_section_anyway_with_flags",
"(",
"obfd",
",",
"\"",
"\"",
",",
"SEC_HAS_CONTENTS",
"|",
"SEC_READONLY",
"|",
"SEC_ALLOC",
")",
";",
"if",
"(",
"note_sec",
"==",
"NULL",
")",
"error",
"(",
"_",
"(",
"\"",
"\"",
")",
",",
"bfd_errmsg",
"(",
"bfd_get_error",
"(",
")",
")",
")",
";",
"bfd_set_section_vma",
"(",
"obfd",
",",
"note_sec",
",",
"0",
")",
";",
"bfd_set_section_alignment",
"(",
"obfd",
",",
"note_sec",
",",
"0",
")",
";",
"bfd_set_section_size",
"(",
"obfd",
",",
"note_sec",
",",
"note_size",
")",
";",
"if",
"(",
"gcore_memory_sections",
"(",
"obfd",
")",
"==",
"0",
")",
"error",
"(",
"_",
"(",
"\"",
"\"",
")",
")",
";",
"if",
"(",
"!",
"bfd_set_section_contents",
"(",
"obfd",
",",
"note_sec",
",",
"note_data",
",",
"0",
",",
"note_size",
")",
")",
"warning",
"(",
"_",
"(",
"\"",
"\"",
")",
",",
"bfd_errmsg",
"(",
"bfd_get_error",
"(",
")",
")",
")",
";",
"}"
] | write_gcore_file -- helper for gcore_command (exported). | [
"write_gcore_file",
"--",
"helper",
"for",
"gcore_command",
"(",
"exported",
")",
"."
] | [
"/* An external target method must build the notes section. */",
"/* FIXME: uweigand/2011-10-06: All architectures that support core file\n generation should be converted to gdbarch_make_corefile_notes; at that\n point, the target vector method can be removed. */",
"/* Create the note section. */",
"/* Now create the memory/load sections. */",
"/* Write out the contents of the note section. */"
] | [
{
"param": "obfd",
"type": "bfd"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "obfd",
"type": "bfd",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
24732e90586d0cb0449e92abeabf23c27b0c84f2 | atrens/DragonFlyBSD-src | contrib/gdb-7/gdb/gcore.c | [
"BSD-3-Clause"
] | C | gcore_command | void | static void
gcore_command (char *args, int from_tty)
{
struct cleanup *old_chain;
char *corefilename, corefilename_buffer[40];
bfd *obfd;
/* No use generating a corefile without a target process. */
if (!target_has_execution)
noprocess ();
if (args && *args)
corefilename = args;
else
{
/* Default corefile name is "core.PID". */
xsnprintf (corefilename_buffer, sizeof (corefilename_buffer),
"core.%d", PIDGET (inferior_ptid));
corefilename = corefilename_buffer;
}
if (info_verbose)
fprintf_filtered (gdb_stdout,
"Opening corefile '%s' for output.\n", corefilename);
/* Open the output file. */
obfd = create_gcore_bfd (corefilename);
/* Need a cleanup that will close and delete the file. */
old_chain = make_cleanup (do_bfd_delete_cleanup, obfd);
/* Call worker function. */
write_gcore_file (obfd);
/* Succeeded. */
fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename);
discard_cleanups (old_chain);
gdb_bfd_unref (obfd);
} | /* gcore_command -- implements the 'gcore' command.
Generate a core file from the inferior process. */ | - implements the 'gcore' command.
Generate a core file from the inferior process. | [
"-",
"implements",
"the",
"'",
"gcore",
"'",
"command",
".",
"Generate",
"a",
"core",
"file",
"from",
"the",
"inferior",
"process",
"."
] | static void
gcore_command (char *args, int from_tty)
{
struct cleanup *old_chain;
char *corefilename, corefilename_buffer[40];
bfd *obfd;
if (!target_has_execution)
noprocess ();
if (args && *args)
corefilename = args;
else
{
xsnprintf (corefilename_buffer, sizeof (corefilename_buffer),
"core.%d", PIDGET (inferior_ptid));
corefilename = corefilename_buffer;
}
if (info_verbose)
fprintf_filtered (gdb_stdout,
"Opening corefile '%s' for output.\n", corefilename);
obfd = create_gcore_bfd (corefilename);
old_chain = make_cleanup (do_bfd_delete_cleanup, obfd);
write_gcore_file (obfd);
fprintf_filtered (gdb_stdout, "Saved corefile %s\n", corefilename);
discard_cleanups (old_chain);
gdb_bfd_unref (obfd);
} | [
"static",
"void",
"gcore_command",
"(",
"char",
"*",
"args",
",",
"int",
"from_tty",
")",
"{",
"struct",
"cleanup",
"*",
"old_chain",
";",
"char",
"*",
"corefilename",
",",
"corefilename_buffer",
"[",
"40",
"]",
";",
"bfd",
"*",
"obfd",
";",
"if",
"(",
"!",
"target_has_execution",
")",
"noprocess",
"(",
")",
";",
"if",
"(",
"args",
"&&",
"*",
"args",
")",
"corefilename",
"=",
"args",
";",
"else",
"{",
"xsnprintf",
"(",
"corefilename_buffer",
",",
"sizeof",
"(",
"corefilename_buffer",
")",
",",
"\"",
"\"",
",",
"PIDGET",
"(",
"inferior_ptid",
")",
")",
";",
"corefilename",
"=",
"corefilename_buffer",
";",
"}",
"if",
"(",
"info_verbose",
")",
"fprintf_filtered",
"(",
"gdb_stdout",
",",
"\"",
"\\n",
"\"",
",",
"corefilename",
")",
";",
"obfd",
"=",
"create_gcore_bfd",
"(",
"corefilename",
")",
";",
"old_chain",
"=",
"make_cleanup",
"(",
"do_bfd_delete_cleanup",
",",
"obfd",
")",
";",
"write_gcore_file",
"(",
"obfd",
")",
";",
"fprintf_filtered",
"(",
"gdb_stdout",
",",
"\"",
"\\n",
"\"",
",",
"corefilename",
")",
";",
"discard_cleanups",
"(",
"old_chain",
")",
";",
"gdb_bfd_unref",
"(",
"obfd",
")",
";",
"}"
] | gcore_command -- implements the 'gcore' command. | [
"gcore_command",
"--",
"implements",
"the",
"'",
"gcore",
"'",
"command",
"."
] | [
"/* No use generating a corefile without a target process. */",
"/* Default corefile name is \"core.PID\". */",
"/* Open the output file. */",
"/* Need a cleanup that will close and delete the file. */",
"/* Call worker function. */",
"/* Succeeded. */"
] | [
{
"param": "args",
"type": "char"
},
{
"param": "from_tty",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "args",
"type": "char",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "from_tty",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
24732e90586d0cb0449e92abeabf23c27b0c84f2 | atrens/DragonFlyBSD-src | contrib/gdb-7/gdb/gcore.c | [
"BSD-3-Clause"
] | C | derive_stack_segment | int | static int
derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
{
struct frame_info *fi, *tmp_fi;
gdb_assert (bottom);
gdb_assert (top);
/* Can't succeed without stack and registers. */
if (!target_has_stack || !target_has_registers)
return 0;
/* Can't succeed without current frame. */
fi = get_current_frame ();
if (fi == NULL)
return 0;
/* Save frame pointer of TOS frame. */
*top = get_frame_base (fi);
/* If current stack pointer is more "inner", use that instead. */
if (gdbarch_inner_than (get_frame_arch (fi), get_frame_sp (fi), *top))
*top = get_frame_sp (fi);
/* Find prev-most frame. */
while ((tmp_fi = get_prev_frame (fi)) != NULL)
fi = tmp_fi;
/* Save frame pointer of prev-most frame. */
*bottom = get_frame_base (fi);
/* Now canonicalize their order, so that BOTTOM is a lower address
(as opposed to a lower stack frame). */
if (*bottom > *top)
{
bfd_vma tmp_vma;
tmp_vma = *top;
*top = *bottom;
*bottom = tmp_vma;
}
return 1;
} | /* Derive a reasonable stack segment by unwinding the target stack,
and store its limits in *BOTTOM and *TOP. Return non-zero if
successful. */ | Derive a reasonable stack segment by unwinding the target stack,
and store its limits in *BOTTOM and *TOP. Return non-zero if
successful. | [
"Derive",
"a",
"reasonable",
"stack",
"segment",
"by",
"unwinding",
"the",
"target",
"stack",
"and",
"store",
"its",
"limits",
"in",
"*",
"BOTTOM",
"and",
"*",
"TOP",
".",
"Return",
"non",
"-",
"zero",
"if",
"successful",
"."
] | static int
derive_stack_segment (bfd_vma *bottom, bfd_vma *top)
{
struct frame_info *fi, *tmp_fi;
gdb_assert (bottom);
gdb_assert (top);
if (!target_has_stack || !target_has_registers)
return 0;
fi = get_current_frame ();
if (fi == NULL)
return 0;
*top = get_frame_base (fi);
if (gdbarch_inner_than (get_frame_arch (fi), get_frame_sp (fi), *top))
*top = get_frame_sp (fi);
while ((tmp_fi = get_prev_frame (fi)) != NULL)
fi = tmp_fi;
*bottom = get_frame_base (fi);
if (*bottom > *top)
{
bfd_vma tmp_vma;
tmp_vma = *top;
*top = *bottom;
*bottom = tmp_vma;
}
return 1;
} | [
"static",
"int",
"derive_stack_segment",
"(",
"bfd_vma",
"*",
"bottom",
",",
"bfd_vma",
"*",
"top",
")",
"{",
"struct",
"frame_info",
"*",
"fi",
",",
"*",
"tmp_fi",
";",
"gdb_assert",
"(",
"bottom",
")",
";",
"gdb_assert",
"(",
"top",
")",
";",
"if",
"(",
"!",
"target_has_stack",
"||",
"!",
"target_has_registers",
")",
"return",
"0",
";",
"fi",
"=",
"get_current_frame",
"(",
")",
";",
"if",
"(",
"fi",
"==",
"NULL",
")",
"return",
"0",
";",
"*",
"top",
"=",
"get_frame_base",
"(",
"fi",
")",
";",
"if",
"(",
"gdbarch_inner_than",
"(",
"get_frame_arch",
"(",
"fi",
")",
",",
"get_frame_sp",
"(",
"fi",
")",
",",
"*",
"top",
")",
")",
"*",
"top",
"=",
"get_frame_sp",
"(",
"fi",
")",
";",
"while",
"(",
"(",
"tmp_fi",
"=",
"get_prev_frame",
"(",
"fi",
")",
")",
"!=",
"NULL",
")",
"fi",
"=",
"tmp_fi",
";",
"*",
"bottom",
"=",
"get_frame_base",
"(",
"fi",
")",
";",
"if",
"(",
"*",
"bottom",
">",
"*",
"top",
")",
"{",
"bfd_vma",
"tmp_vma",
";",
"tmp_vma",
"=",
"*",
"top",
";",
"*",
"top",
"=",
"*",
"bottom",
";",
"*",
"bottom",
"=",
"tmp_vma",
";",
"}",
"return",
"1",
";",
"}"
] | Derive a reasonable stack segment by unwinding the target stack,
and store its limits in *BOTTOM and *TOP. | [
"Derive",
"a",
"reasonable",
"stack",
"segment",
"by",
"unwinding",
"the",
"target",
"stack",
"and",
"store",
"its",
"limits",
"in",
"*",
"BOTTOM",
"and",
"*",
"TOP",
"."
] | [
"/* Can't succeed without stack and registers. */",
"/* Can't succeed without current frame. */",
"/* Save frame pointer of TOS frame. */",
"/* If current stack pointer is more \"inner\", use that instead. */",
"/* Find prev-most frame. */",
"/* Save frame pointer of prev-most frame. */",
"/* Now canonicalize their order, so that BOTTOM is a lower address\n (as opposed to a lower stack frame). */"
] | [
{
"param": "bottom",
"type": "bfd_vma"
},
{
"param": "top",
"type": "bfd_vma"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "bottom",
"type": "bfd_vma",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "top",
"type": "bfd_vma",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
24732e90586d0cb0449e92abeabf23c27b0c84f2 | atrens/DragonFlyBSD-src | contrib/gdb-7/gdb/gcore.c | [
"BSD-3-Clause"
] | C | derive_heap_segment | int | static int
derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
{
bfd_vma top_of_data_memory = 0;
bfd_vma top_of_heap = 0;
bfd_size_type sec_size;
bfd_vma sec_vaddr;
asection *sec;
gdb_assert (bottom);
gdb_assert (top);
/* This function depends on being able to call a function in the
inferior. */
if (!target_has_execution)
return 0;
/* The following code assumes that the link map is arranged as
follows (low to high addresses):
---------------------------------
| text sections |
---------------------------------
| data sections (including bss) |
---------------------------------
| heap |
--------------------------------- */
for (sec = abfd->sections; sec; sec = sec->next)
{
if (bfd_get_section_flags (abfd, sec) & SEC_DATA
|| strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
{
sec_vaddr = bfd_get_section_vma (abfd, sec);
sec_size = bfd_get_section_size (sec);
if (sec_vaddr + sec_size > top_of_data_memory)
top_of_data_memory = sec_vaddr + sec_size;
}
}
top_of_heap = call_target_sbrk (0);
if (top_of_heap == (bfd_vma) 0)
return 0;
/* Return results. */
if (top_of_heap > top_of_data_memory)
{
*bottom = top_of_data_memory;
*top = top_of_heap;
return 1;
}
/* No additional heap space needs to be saved. */
return 0;
} | /* Derive a reasonable heap segment for ABFD by looking at sbrk and
the static data sections. Store its limits in *BOTTOM and *TOP.
Return non-zero if successful. */ | Derive a reasonable heap segment for ABFD by looking at sbrk and
the static data sections. Store its limits in *BOTTOM and *TOP.
Return non-zero if successful. | [
"Derive",
"a",
"reasonable",
"heap",
"segment",
"for",
"ABFD",
"by",
"looking",
"at",
"sbrk",
"and",
"the",
"static",
"data",
"sections",
".",
"Store",
"its",
"limits",
"in",
"*",
"BOTTOM",
"and",
"*",
"TOP",
".",
"Return",
"non",
"-",
"zero",
"if",
"successful",
"."
] | static int
derive_heap_segment (bfd *abfd, bfd_vma *bottom, bfd_vma *top)
{
bfd_vma top_of_data_memory = 0;
bfd_vma top_of_heap = 0;
bfd_size_type sec_size;
bfd_vma sec_vaddr;
asection *sec;
gdb_assert (bottom);
gdb_assert (top);
if (!target_has_execution)
return 0;
for (sec = abfd->sections; sec; sec = sec->next)
{
if (bfd_get_section_flags (abfd, sec) & SEC_DATA
|| strcmp (".bss", bfd_section_name (abfd, sec)) == 0)
{
sec_vaddr = bfd_get_section_vma (abfd, sec);
sec_size = bfd_get_section_size (sec);
if (sec_vaddr + sec_size > top_of_data_memory)
top_of_data_memory = sec_vaddr + sec_size;
}
}
top_of_heap = call_target_sbrk (0);
if (top_of_heap == (bfd_vma) 0)
return 0;
if (top_of_heap > top_of_data_memory)
{
*bottom = top_of_data_memory;
*top = top_of_heap;
return 1;
}
return 0;
} | [
"static",
"int",
"derive_heap_segment",
"(",
"bfd",
"*",
"abfd",
",",
"bfd_vma",
"*",
"bottom",
",",
"bfd_vma",
"*",
"top",
")",
"{",
"bfd_vma",
"top_of_data_memory",
"=",
"0",
";",
"bfd_vma",
"top_of_heap",
"=",
"0",
";",
"bfd_size_type",
"sec_size",
";",
"bfd_vma",
"sec_vaddr",
";",
"asection",
"*",
"sec",
";",
"gdb_assert",
"(",
"bottom",
")",
";",
"gdb_assert",
"(",
"top",
")",
";",
"if",
"(",
"!",
"target_has_execution",
")",
"return",
"0",
";",
"for",
"(",
"sec",
"=",
"abfd",
"->",
"sections",
";",
"sec",
";",
"sec",
"=",
"sec",
"->",
"next",
")",
"{",
"if",
"(",
"bfd_get_section_flags",
"(",
"abfd",
",",
"sec",
")",
"&",
"SEC_DATA",
"||",
"strcmp",
"(",
"\"",
"\"",
",",
"bfd_section_name",
"(",
"abfd",
",",
"sec",
")",
")",
"==",
"0",
")",
"{",
"sec_vaddr",
"=",
"bfd_get_section_vma",
"(",
"abfd",
",",
"sec",
")",
";",
"sec_size",
"=",
"bfd_get_section_size",
"(",
"sec",
")",
";",
"if",
"(",
"sec_vaddr",
"+",
"sec_size",
">",
"top_of_data_memory",
")",
"top_of_data_memory",
"=",
"sec_vaddr",
"+",
"sec_size",
";",
"}",
"}",
"top_of_heap",
"=",
"call_target_sbrk",
"(",
"0",
")",
";",
"if",
"(",
"top_of_heap",
"==",
"(",
"bfd_vma",
")",
"0",
")",
"return",
"0",
";",
"if",
"(",
"top_of_heap",
">",
"top_of_data_memory",
")",
"{",
"*",
"bottom",
"=",
"top_of_data_memory",
";",
"*",
"top",
"=",
"top_of_heap",
";",
"return",
"1",
";",
"}",
"return",
"0",
";",
"}"
] | Derive a reasonable heap segment for ABFD by looking at sbrk and
the static data sections. | [
"Derive",
"a",
"reasonable",
"heap",
"segment",
"for",
"ABFD",
"by",
"looking",
"at",
"sbrk",
"and",
"the",
"static",
"data",
"sections",
"."
] | [
"/* This function depends on being able to call a function in the\n inferior. */",
"/* The following code assumes that the link map is arranged as\n follows (low to high addresses):\n\n ---------------------------------\n | text sections |\n ---------------------------------\n | data sections (including bss) |\n ---------------------------------\n | heap |\n --------------------------------- */",
"/* Return results. */",
"/* No additional heap space needs to be saved. */"
] | [
{
"param": "abfd",
"type": "bfd"
},
{
"param": "bottom",
"type": "bfd_vma"
},
{
"param": "top",
"type": "bfd_vma"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "abfd",
"type": "bfd",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "bottom",
"type": "bfd_vma",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "top",
"type": "bfd_vma",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
8716b8dcae27b9d48b8654eccfcacba101ec362f | atrens/DragonFlyBSD-src | lib/libc/locale/setlocale.c | [
"BSD-3-Clause"
] | C | __detect_path_locale | int | int
__detect_path_locale(void)
{
if (_PathLocale == NULL) {
char *p = getenv("PATH_LOCALE");
if (p != NULL && !issetugid()) {
if (strlen(p) + 1/*"/"*/ + ENCODING_LEN +
1/*"/"*/ + CATEGORY_LEN >= PATH_MAX)
return (ENAMETOOLONG);
_PathLocale = strdup(p);
if (_PathLocale == NULL)
return (errno == 0 ? ENOMEM : errno);
} else
_PathLocale = _PATH_LOCALE;
}
return (0);
} | /*
* Detect locale storage location and store its value to _PathLocale variable
*/ | Detect locale storage location and store its value to _PathLocale variable | [
"Detect",
"locale",
"storage",
"location",
"and",
"store",
"its",
"value",
"to",
"_PathLocale",
"variable"
] | int
__detect_path_locale(void)
{
if (_PathLocale == NULL) {
char *p = getenv("PATH_LOCALE");
if (p != NULL && !issetugid()) {
if (strlen(p) + 1 + ENCODING_LEN +
1 + CATEGORY_LEN >= PATH_MAX)
return (ENAMETOOLONG);
_PathLocale = strdup(p);
if (_PathLocale == NULL)
return (errno == 0 ? ENOMEM : errno);
} else
_PathLocale = _PATH_LOCALE;
}
return (0);
} | [
"int",
"__detect_path_locale",
"(",
"void",
")",
"{",
"if",
"(",
"_PathLocale",
"==",
"NULL",
")",
"{",
"char",
"*",
"p",
"=",
"getenv",
"(",
"\"",
"\"",
")",
";",
"if",
"(",
"p",
"!=",
"NULL",
"&&",
"!",
"issetugid",
"(",
")",
")",
"{",
"if",
"(",
"strlen",
"(",
"p",
")",
"+",
"1",
"+",
"ENCODING_LEN",
"+",
"1",
"+",
"CATEGORY_LEN",
">=",
"PATH_MAX",
")",
"return",
"(",
"ENAMETOOLONG",
")",
";",
"_PathLocale",
"=",
"strdup",
"(",
"p",
")",
";",
"if",
"(",
"_PathLocale",
"==",
"NULL",
")",
"return",
"(",
"errno",
"==",
"0",
"?",
"ENOMEM",
":",
"errno",
")",
";",
"}",
"else",
"_PathLocale",
"=",
"_PATH_LOCALE",
";",
"}",
"return",
"(",
"0",
")",
";",
"}"
] | Detect locale storage location and store its value to _PathLocale variable | [
"Detect",
"locale",
"storage",
"location",
"and",
"store",
"its",
"value",
"to",
"_PathLocale",
"variable"
] | [
"/*\"/\"*/",
"/*\"/\"*/"
] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
e02e5288be69c5d92fa241f7a91154438a4d4472 | atrens/DragonFlyBSD-src | tools/tools/net80211/wlantxtime/wlantxtime.c | [
"BSD-3-Clause"
] | C | ieee80211_setup_ratetable | void | static void
ieee80211_setup_ratetable(struct ieee80211_rate_table *rt)
{
#define N(a) (sizeof(a)/sizeof(a[0]))
#define WLAN_CTRL_FRAME_SIZE \
(sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN)
int i;
for (i = 0; i < N(rt->rateCodeToIndex); i++)
rt->rateCodeToIndex[i] = (uint8_t) -1;
for (i = 0; i < rt->rateCount; i++) {
uint8_t code = rt->info[i].dot11Rate;
uint8_t cix = rt->info[i].ctlRateIndex;
uint8_t ctl_rate = rt->info[cix].dot11Rate;
rt->rateCodeToIndex[code] = i;
if (code & IEEE80211_RATE_BASIC) {
/*
* Map w/o basic rate bit too.
*/
code &= IEEE80211_RATE_VAL;
rt->rateCodeToIndex[code] = i;
}
/*
* XXX for 11g the control rate to use for 5.5 and 11 Mb/s
* depends on whether they are marked as basic rates;
* the static tables are setup with an 11b-compatible
* 2Mb/s rate which will work but is suboptimal
*
* NB: Control rate is always less than or equal to the
* current rate, so control rate's reverse lookup entry
* has been installed and following call is safe.
*/
rt->info[i].lpAckDuration = ieee80211_compute_duration(rt,
WLAN_CTRL_FRAME_SIZE, ctl_rate, 0);
rt->info[i].spAckDuration = ieee80211_compute_duration(rt,
WLAN_CTRL_FRAME_SIZE, ctl_rate, IEEE80211_F_SHPREAMBLE);
}
#undef WLAN_CTRL_FRAME_SIZE
#undef N
} | /*
* Setup a rate table's reverse lookup table and fill in
* ack durations. The reverse lookup tables are assumed
* to be initialized to zero (or at least the first entry).
* We use this as a key that indicates whether or not
* we've previously setup the reverse lookup table.
*
* XXX not reentrant, but shouldn't matter
*/ | Setup a rate table's reverse lookup table and fill in
ack durations. The reverse lookup tables are assumed
to be initialized to zero (or at least the first entry).
We use this as a key that indicates whether or not
we've previously setup the reverse lookup table.
XXX not reentrant, but shouldn't matter | [
"Setup",
"a",
"rate",
"table",
"'",
"s",
"reverse",
"lookup",
"table",
"and",
"fill",
"in",
"ack",
"durations",
".",
"The",
"reverse",
"lookup",
"tables",
"are",
"assumed",
"to",
"be",
"initialized",
"to",
"zero",
"(",
"or",
"at",
"least",
"the",
"first",
"entry",
")",
".",
"We",
"use",
"this",
"as",
"a",
"key",
"that",
"indicates",
"whether",
"or",
"not",
"we",
"'",
"ve",
"previously",
"setup",
"the",
"reverse",
"lookup",
"table",
".",
"XXX",
"not",
"reentrant",
"but",
"shouldn",
"'",
"t",
"matter"
] | static void
ieee80211_setup_ratetable(struct ieee80211_rate_table *rt)
{
#define N(a) (sizeof(a)/sizeof(a[0]))
#define WLAN_CTRL_FRAME_SIZE \
(sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN)
int i;
for (i = 0; i < N(rt->rateCodeToIndex); i++)
rt->rateCodeToIndex[i] = (uint8_t) -1;
for (i = 0; i < rt->rateCount; i++) {
uint8_t code = rt->info[i].dot11Rate;
uint8_t cix = rt->info[i].ctlRateIndex;
uint8_t ctl_rate = rt->info[cix].dot11Rate;
rt->rateCodeToIndex[code] = i;
if (code & IEEE80211_RATE_BASIC) {
code &= IEEE80211_RATE_VAL;
rt->rateCodeToIndex[code] = i;
}
rt->info[i].lpAckDuration = ieee80211_compute_duration(rt,
WLAN_CTRL_FRAME_SIZE, ctl_rate, 0);
rt->info[i].spAckDuration = ieee80211_compute_duration(rt,
WLAN_CTRL_FRAME_SIZE, ctl_rate, IEEE80211_F_SHPREAMBLE);
}
#undef WLAN_CTRL_FRAME_SIZE
#undef N
} | [
"static",
"void",
"ieee80211_setup_ratetable",
"(",
"struct",
"ieee80211_rate_table",
"*",
"rt",
")",
"{",
"#define",
"N",
"(",
"a",
")",
"\t(sizeof(a)/sizeof(a[0]))",
"\n",
"#define",
"WLAN_CTRL_FRAME_SIZE",
" \\\n\t(sizeof(struct ieee80211_frame_ack) + IEEE80211_CRC_LEN)",
"\n\n",
"int",
"i",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"N",
"(",
"rt",
"->",
"rateCodeToIndex",
")",
";",
"i",
"++",
")",
"rt",
"->",
"rateCodeToIndex",
"[",
"i",
"]",
"=",
"(",
"uint8_t",
")",
"-1",
";",
"for",
"(",
"i",
"=",
"0",
";",
"i",
"<",
"rt",
"->",
"rateCount",
";",
"i",
"++",
")",
"{",
"uint8_t",
"code",
"=",
"rt",
"->",
"info",
"[",
"i",
"]",
".",
"dot11Rate",
";",
"uint8_t",
"cix",
"=",
"rt",
"->",
"info",
"[",
"i",
"]",
".",
"ctlRateIndex",
";",
"uint8_t",
"ctl_rate",
"=",
"rt",
"->",
"info",
"[",
"cix",
"]",
".",
"dot11Rate",
";",
"rt",
"->",
"rateCodeToIndex",
"[",
"code",
"]",
"=",
"i",
";",
"if",
"(",
"code",
"&",
"IEEE80211_RATE_BASIC",
")",
"{",
"code",
"&=",
"IEEE80211_RATE_VAL",
";",
"rt",
"->",
"rateCodeToIndex",
"[",
"code",
"]",
"=",
"i",
";",
"}",
"rt",
"->",
"info",
"[",
"i",
"]",
".",
"lpAckDuration",
"=",
"ieee80211_compute_duration",
"(",
"rt",
",",
"WLAN_CTRL_FRAME_SIZE",
",",
"ctl_rate",
",",
"0",
")",
";",
"rt",
"->",
"info",
"[",
"i",
"]",
".",
"spAckDuration",
"=",
"ieee80211_compute_duration",
"(",
"rt",
",",
"WLAN_CTRL_FRAME_SIZE",
",",
"ctl_rate",
",",
"IEEE80211_F_SHPREAMBLE",
")",
";",
"}",
"#undef",
" WLAN_CTRL_FRAME_SIZE",
"\n",
"#undef",
" N",
"\n",
"}"
] | Setup a rate table's reverse lookup table and fill in
ack durations. | [
"Setup",
"a",
"rate",
"table",
"'",
"s",
"reverse",
"lookup",
"table",
"and",
"fill",
"in",
"ack",
"durations",
"."
] | [
"/*\n\t\t\t * Map w/o basic rate bit too.\n\t\t\t */",
"/*\n\t\t * XXX for 11g the control rate to use for 5.5 and 11 Mb/s\n\t\t * depends on whether they are marked as basic rates;\n\t\t * the static tables are setup with an 11b-compatible\n\t\t * 2Mb/s rate which will work but is suboptimal\n\t\t *\n\t\t * NB: Control rate is always less than or equal to the\n\t\t * current rate, so control rate's reverse lookup entry\n\t\t * has been installed and following call is safe.\n\t\t */"
] | [
{
"param": "rt",
"type": "struct ieee80211_rate_table"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "rt",
"type": "struct ieee80211_rate_table",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
e02e5288be69c5d92fa241f7a91154438a4d4472 | atrens/DragonFlyBSD-src | tools/tools/net80211/wlantxtime/wlantxtime.c | [
"BSD-3-Clause"
] | C | ieee80211_compute_duration | uint16_t | uint16_t
ieee80211_compute_duration(const struct ieee80211_rate_table *rt,
uint32_t frameLen, uint16_t rate, int isShortPreamble)
{
uint8_t rix = rt->rateCodeToIndex[rate];
uint32_t bitsPerSymbol, numBits, numSymbols, phyTime, txTime;
uint32_t kbps;
KASSERT(rix != (uint8_t)-1, ("rate %d has no info", rate));
kbps = rt->info[rix].rateKbps;
if (kbps == 0) /* XXX bandaid for channel changes */
return 0;
switch (rt->info[rix].phy) {
case IEEE80211_T_CCK:
phyTime = CCK_PREAMBLE_BITS + CCK_PLCP_BITS;
if (isShortPreamble && rt->info[rix].shortPreamble)
phyTime >>= 1;
numBits = frameLen << 3;
txTime = CCK_SIFS_TIME + phyTime
+ ((numBits * 1000)/kbps);
break;
case IEEE80211_T_OFDM:
bitsPerSymbol = (kbps * OFDM_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("full rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_SIFS_TIME
+ OFDM_PREAMBLE_TIME
+ (numSymbols * OFDM_SYMBOL_TIME);
break;
case IEEE80211_T_OFDM_HALF:
bitsPerSymbol = (kbps * OFDM_HALF_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("1/4 rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_HALF_SIFS_TIME
+ OFDM_HALF_PREAMBLE_TIME
+ (numSymbols * OFDM_HALF_SYMBOL_TIME);
break;
case IEEE80211_T_OFDM_QUARTER:
bitsPerSymbol = (kbps * OFDM_QUARTER_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("1/2 rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_QUARTER_SIFS_TIME
+ OFDM_QUARTER_PREAMBLE_TIME
+ (numSymbols * OFDM_QUARTER_SYMBOL_TIME);
break;
case IEEE80211_T_TURBO:
/* we still save OFDM rates in kbps - so double them */
bitsPerSymbol = ((kbps << 1) * TURBO_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("turbo bps"));
numBits = TURBO_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = TURBO_SIFS_TIME + TURBO_PREAMBLE_TIME
+ (numSymbols * TURBO_SYMBOL_TIME);
break;
default:
panic("%s: unknown phy %u (rate %u)\n", __func__,
rt->info[rix].phy, rate);
break;
}
return txTime;
} | /*
* Compute the time to transmit a frame of length frameLen bytes
* using the specified rate, phy, and short preamble setting.
* SIFS is included.
*/ | Compute the time to transmit a frame of length frameLen bytes
using the specified rate, phy, and short preamble setting.
SIFS is included. | [
"Compute",
"the",
"time",
"to",
"transmit",
"a",
"frame",
"of",
"length",
"frameLen",
"bytes",
"using",
"the",
"specified",
"rate",
"phy",
"and",
"short",
"preamble",
"setting",
".",
"SIFS",
"is",
"included",
"."
] | uint16_t
ieee80211_compute_duration(const struct ieee80211_rate_table *rt,
uint32_t frameLen, uint16_t rate, int isShortPreamble)
{
uint8_t rix = rt->rateCodeToIndex[rate];
uint32_t bitsPerSymbol, numBits, numSymbols, phyTime, txTime;
uint32_t kbps;
KASSERT(rix != (uint8_t)-1, ("rate %d has no info", rate));
kbps = rt->info[rix].rateKbps;
if (kbps == 0)
return 0;
switch (rt->info[rix].phy) {
case IEEE80211_T_CCK:
phyTime = CCK_PREAMBLE_BITS + CCK_PLCP_BITS;
if (isShortPreamble && rt->info[rix].shortPreamble)
phyTime >>= 1;
numBits = frameLen << 3;
txTime = CCK_SIFS_TIME + phyTime
+ ((numBits * 1000)/kbps);
break;
case IEEE80211_T_OFDM:
bitsPerSymbol = (kbps * OFDM_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("full rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_SIFS_TIME
+ OFDM_PREAMBLE_TIME
+ (numSymbols * OFDM_SYMBOL_TIME);
break;
case IEEE80211_T_OFDM_HALF:
bitsPerSymbol = (kbps * OFDM_HALF_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("1/4 rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_HALF_SIFS_TIME
+ OFDM_HALF_PREAMBLE_TIME
+ (numSymbols * OFDM_HALF_SYMBOL_TIME);
break;
case IEEE80211_T_OFDM_QUARTER:
bitsPerSymbol = (kbps * OFDM_QUARTER_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("1/2 rate bps"));
numBits = OFDM_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = OFDM_QUARTER_SIFS_TIME
+ OFDM_QUARTER_PREAMBLE_TIME
+ (numSymbols * OFDM_QUARTER_SYMBOL_TIME);
break;
case IEEE80211_T_TURBO:
bitsPerSymbol = ((kbps << 1) * TURBO_SYMBOL_TIME) / 1000;
KASSERT(bitsPerSymbol != 0, ("turbo bps"));
numBits = TURBO_PLCP_BITS + (frameLen << 3);
numSymbols = howmany(numBits, bitsPerSymbol);
txTime = TURBO_SIFS_TIME + TURBO_PREAMBLE_TIME
+ (numSymbols * TURBO_SYMBOL_TIME);
break;
default:
panic("%s: unknown phy %u (rate %u)\n", __func__,
rt->info[rix].phy, rate);
break;
}
return txTime;
} | [
"uint16_t",
"ieee80211_compute_duration",
"(",
"const",
"struct",
"ieee80211_rate_table",
"*",
"rt",
",",
"uint32_t",
"frameLen",
",",
"uint16_t",
"rate",
",",
"int",
"isShortPreamble",
")",
"{",
"uint8_t",
"rix",
"=",
"rt",
"->",
"rateCodeToIndex",
"[",
"rate",
"]",
";",
"uint32_t",
"bitsPerSymbol",
",",
"numBits",
",",
"numSymbols",
",",
"phyTime",
",",
"txTime",
";",
"uint32_t",
"kbps",
";",
"KASSERT",
"(",
"rix",
"!=",
"(",
"uint8_t",
")",
"-1",
",",
"(",
"\"",
"\"",
",",
"rate",
")",
")",
";",
"kbps",
"=",
"rt",
"->",
"info",
"[",
"rix",
"]",
".",
"rateKbps",
";",
"if",
"(",
"kbps",
"==",
"0",
")",
"return",
"0",
";",
"switch",
"(",
"rt",
"->",
"info",
"[",
"rix",
"]",
".",
"phy",
")",
"{",
"case",
"IEEE80211_T_CCK",
":",
"phyTime",
"=",
"CCK_PREAMBLE_BITS",
"+",
"CCK_PLCP_BITS",
";",
"if",
"(",
"isShortPreamble",
"&&",
"rt",
"->",
"info",
"[",
"rix",
"]",
".",
"shortPreamble",
")",
"phyTime",
">>=",
"1",
";",
"numBits",
"=",
"frameLen",
"<<",
"3",
";",
"txTime",
"=",
"CCK_SIFS_TIME",
"+",
"phyTime",
"+",
"(",
"(",
"numBits",
"*",
"1000",
")",
"/",
"kbps",
")",
";",
"break",
";",
"case",
"IEEE80211_T_OFDM",
":",
"bitsPerSymbol",
"=",
"(",
"kbps",
"*",
"OFDM_SYMBOL_TIME",
")",
"/",
"1000",
";",
"KASSERT",
"(",
"bitsPerSymbol",
"!=",
"0",
",",
"(",
"\"",
"\"",
")",
")",
";",
"numBits",
"=",
"OFDM_PLCP_BITS",
"+",
"(",
"frameLen",
"<<",
"3",
")",
";",
"numSymbols",
"=",
"howmany",
"(",
"numBits",
",",
"bitsPerSymbol",
")",
";",
"txTime",
"=",
"OFDM_SIFS_TIME",
"+",
"OFDM_PREAMBLE_TIME",
"+",
"(",
"numSymbols",
"*",
"OFDM_SYMBOL_TIME",
")",
";",
"break",
";",
"case",
"IEEE80211_T_OFDM_HALF",
":",
"bitsPerSymbol",
"=",
"(",
"kbps",
"*",
"OFDM_HALF_SYMBOL_TIME",
")",
"/",
"1000",
";",
"KASSERT",
"(",
"bitsPerSymbol",
"!=",
"0",
",",
"(",
"\"",
"\"",
")",
")",
";",
"numBits",
"=",
"OFDM_PLCP_BITS",
"+",
"(",
"frameLen",
"<<",
"3",
")",
";",
"numSymbols",
"=",
"howmany",
"(",
"numBits",
",",
"bitsPerSymbol",
")",
";",
"txTime",
"=",
"OFDM_HALF_SIFS_TIME",
"+",
"OFDM_HALF_PREAMBLE_TIME",
"+",
"(",
"numSymbols",
"*",
"OFDM_HALF_SYMBOL_TIME",
")",
";",
"break",
";",
"case",
"IEEE80211_T_OFDM_QUARTER",
":",
"bitsPerSymbol",
"=",
"(",
"kbps",
"*",
"OFDM_QUARTER_SYMBOL_TIME",
")",
"/",
"1000",
";",
"KASSERT",
"(",
"bitsPerSymbol",
"!=",
"0",
",",
"(",
"\"",
"\"",
")",
")",
";",
"numBits",
"=",
"OFDM_PLCP_BITS",
"+",
"(",
"frameLen",
"<<",
"3",
")",
";",
"numSymbols",
"=",
"howmany",
"(",
"numBits",
",",
"bitsPerSymbol",
")",
";",
"txTime",
"=",
"OFDM_QUARTER_SIFS_TIME",
"+",
"OFDM_QUARTER_PREAMBLE_TIME",
"+",
"(",
"numSymbols",
"*",
"OFDM_QUARTER_SYMBOL_TIME",
")",
";",
"break",
";",
"case",
"IEEE80211_T_TURBO",
":",
"bitsPerSymbol",
"=",
"(",
"(",
"kbps",
"<<",
"1",
")",
"*",
"TURBO_SYMBOL_TIME",
")",
"/",
"1000",
";",
"KASSERT",
"(",
"bitsPerSymbol",
"!=",
"0",
",",
"(",
"\"",
"\"",
")",
")",
";",
"numBits",
"=",
"TURBO_PLCP_BITS",
"+",
"(",
"frameLen",
"<<",
"3",
")",
";",
"numSymbols",
"=",
"howmany",
"(",
"numBits",
",",
"bitsPerSymbol",
")",
";",
"txTime",
"=",
"TURBO_SIFS_TIME",
"+",
"TURBO_PREAMBLE_TIME",
"+",
"(",
"numSymbols",
"*",
"TURBO_SYMBOL_TIME",
")",
";",
"break",
";",
"default",
":",
"panic",
"(",
"\"",
"\\n",
"\"",
",",
"__func__",
",",
"rt",
"->",
"info",
"[",
"rix",
"]",
".",
"phy",
",",
"rate",
")",
";",
"break",
";",
"}",
"return",
"txTime",
";",
"}"
] | Compute the time to transmit a frame of length frameLen bytes
using the specified rate, phy, and short preamble setting. | [
"Compute",
"the",
"time",
"to",
"transmit",
"a",
"frame",
"of",
"length",
"frameLen",
"bytes",
"using",
"the",
"specified",
"rate",
"phy",
"and",
"short",
"preamble",
"setting",
"."
] | [
"/* XXX bandaid for channel changes */",
"/* we still save OFDM rates in kbps - so double them */"
] | [
{
"param": "rt",
"type": "struct ieee80211_rate_table"
},
{
"param": "frameLen",
"type": "uint32_t"
},
{
"param": "rate",
"type": "uint16_t"
},
{
"param": "isShortPreamble",
"type": "int"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "rt",
"type": "struct ieee80211_rate_table",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "frameLen",
"type": "uint32_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "rate",
"type": "uint16_t",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
},
{
"identifier": "isShortPreamble",
"type": "int",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
14e8203adec69bd7a6a347e22e586f5273457413 | atrens/DragonFlyBSD-src | usr.bin/m4/manual_tokenizer.c | [
"BSD-3-Clause"
] | C | yy_get_previous_state | yy_state_type | static yy_state_type yy_get_previous_state (void)
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 35 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
}
return yy_current_state;
} | /* yy_get_previous_state - get the state just before the EOB char was reached */ | get the state just before the EOB char was reached | [
"get",
"the",
"state",
"just",
"before",
"the",
"EOB",
"char",
"was",
"reached"
] | static yy_state_type yy_get_previous_state (void)
{
register yy_state_type yy_current_state;
register char *yy_cp;
yy_current_state = (yy_start);
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
{
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
if ( yy_accept[yy_current_state] )
{
(yy_last_accepting_state) = yy_current_state;
(yy_last_accepting_cpos) = yy_cp;
}
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
{
yy_current_state = (int) yy_def[yy_current_state];
if ( yy_current_state >= 35 )
yy_c = yy_meta[(unsigned int) yy_c];
}
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
}
return yy_current_state;
} | [
"static",
"yy_state_type",
"yy_get_previous_state",
"(",
"void",
")",
"{",
"register",
"yy_state_type",
"yy_current_state",
";",
"register",
"char",
"*",
"yy_cp",
";",
"yy_current_state",
"=",
"(",
"yy_start",
")",
";",
"for",
"(",
"yy_cp",
"=",
"(",
"yytext_ptr",
")",
"+",
"YY_MORE_ADJ",
";",
"yy_cp",
"<",
"(",
"yy_c_buf_p",
")",
";",
"++",
"yy_cp",
")",
"{",
"register",
"YY_CHAR",
"yy_c",
"=",
"(",
"*",
"yy_cp",
"?",
"yy_ec",
"[",
"YY_SC_TO_UI",
"(",
"*",
"yy_cp",
")",
"]",
":",
"1",
")",
";",
"if",
"(",
"yy_accept",
"[",
"yy_current_state",
"]",
")",
"{",
"(",
"yy_last_accepting_state",
")",
"=",
"yy_current_state",
";",
"(",
"yy_last_accepting_cpos",
")",
"=",
"yy_cp",
";",
"}",
"while",
"(",
"yy_chk",
"[",
"yy_base",
"[",
"yy_current_state",
"]",
"+",
"yy_c",
"]",
"!=",
"yy_current_state",
")",
"{",
"yy_current_state",
"=",
"(",
"int",
")",
"yy_def",
"[",
"yy_current_state",
"]",
";",
"if",
"(",
"yy_current_state",
">=",
"35",
")",
"yy_c",
"=",
"yy_meta",
"[",
"(",
"unsigned",
"int",
")",
"yy_c",
"]",
";",
"}",
"yy_current_state",
"=",
"yy_nxt",
"[",
"yy_base",
"[",
"yy_current_state",
"]",
"+",
"(",
"unsigned",
"int",
")",
"yy_c",
"]",
";",
"}",
"return",
"yy_current_state",
";",
"}"
] | yy_get_previous_state - get the state just before the EOB char was reached | [
"yy_get_previous_state",
"-",
"get",
"the",
"state",
"just",
"before",
"the",
"EOB",
"char",
"was",
"reached"
] | [] | [] | {
"returns": [],
"raises": [],
"params": [],
"outlier_params": [],
"others": []
} |
14e8203adec69bd7a6a347e22e586f5273457413 | atrens/DragonFlyBSD-src | usr.bin/m4/manual_tokenizer.c | [
"BSD-3-Clause"
] | C | yy_flush_buffer | void | void yy_flush_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
b->yy_n_chars = 0;
/* We always need two end-of-buffer characters. The first causes
* a transition to the end-of-buffer state. The second causes
* a jam in that state.
*/
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
yy_load_buffer_state( );
} | /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
*
*/ | Discard all buffered characters. On the next scan, YY_INPUT will be called.
@param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER. | [
"Discard",
"all",
"buffered",
"characters",
".",
"On",
"the",
"next",
"scan",
"YY_INPUT",
"will",
"be",
"called",
".",
"@param",
"b",
"the",
"buffer",
"state",
"to",
"be",
"flushed",
"usually",
"@c",
"YY_CURRENT_BUFFER",
"."
] | void yy_flush_buffer (YY_BUFFER_STATE b )
{
if ( ! b )
return;
b->yy_n_chars = 0;
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer_status = YY_BUFFER_NEW;
if ( b == YY_CURRENT_BUFFER )
yy_load_buffer_state( );
} | [
"void",
"yy_flush_buffer",
"(",
"YY_BUFFER_STATE",
"b",
")",
"{",
"if",
"(",
"!",
"b",
")",
"return",
";",
"b",
"->",
"yy_n_chars",
"=",
"0",
";",
"b",
"->",
"yy_ch_buf",
"[",
"0",
"]",
"=",
"YY_END_OF_BUFFER_CHAR",
";",
"b",
"->",
"yy_ch_buf",
"[",
"1",
"]",
"=",
"YY_END_OF_BUFFER_CHAR",
";",
"b",
"->",
"yy_buf_pos",
"=",
"&",
"b",
"->",
"yy_ch_buf",
"[",
"0",
"]",
";",
"b",
"->",
"yy_at_bol",
"=",
"1",
";",
"b",
"->",
"yy_buffer_status",
"=",
"YY_BUFFER_NEW",
";",
"if",
"(",
"b",
"==",
"YY_CURRENT_BUFFER",
")",
"yy_load_buffer_state",
"(",
")",
";",
"}"
] | Discard all buffered characters. | [
"Discard",
"all",
"buffered",
"characters",
"."
] | [
"/* We always need two end-of-buffer characters. The first causes\n\t * a transition to the end-of-buffer state. The second causes\n\t * a jam in that state.\n\t */"
] | [
{
"param": "b",
"type": "YY_BUFFER_STATE"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "b",
"type": "YY_BUFFER_STATE",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
14e8203adec69bd7a6a347e22e586f5273457413 | atrens/DragonFlyBSD-src | usr.bin/m4/manual_tokenizer.c | [
"BSD-3-Clause"
] | C | yypush_buffer_state | void | void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
/* This block is copied from yy_switch_to_buffer. */
if ( YY_CURRENT_BUFFER )
{
/* Flush out information for old buffer. */
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
/* Only push if top exists. Otherwise, replace top. */
if (YY_CURRENT_BUFFER)
(yy_buffer_stack_top)++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;
/* copied from yy_switch_to_buffer. */
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
} | /** Pushes the new state onto the stack. The new state becomes
* the current state. This function will allocate the stack
* if necessary.
* @param new_buffer The new state.
*
*/ | Pushes the new state onto the stack. The new state becomes
the current state. This function will allocate the stack
if necessary.
@param new_buffer The new state. | [
"Pushes",
"the",
"new",
"state",
"onto",
"the",
"stack",
".",
"The",
"new",
"state",
"becomes",
"the",
"current",
"state",
".",
"This",
"function",
"will",
"allocate",
"the",
"stack",
"if",
"necessary",
".",
"@param",
"new_buffer",
"The",
"new",
"state",
"."
] | void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
{
if (new_buffer == NULL)
return;
yyensure_buffer_stack();
if ( YY_CURRENT_BUFFER )
{
*(yy_c_buf_p) = (yy_hold_char);
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
}
if (YY_CURRENT_BUFFER)
(yy_buffer_stack_top)++;
YY_CURRENT_BUFFER_LVALUE = new_buffer;
yy_load_buffer_state( );
(yy_did_buffer_switch_on_eof) = 1;
} | [
"void",
"yypush_buffer_state",
"(",
"YY_BUFFER_STATE",
"new_buffer",
")",
"{",
"if",
"(",
"new_buffer",
"==",
"NULL",
")",
"return",
";",
"yyensure_buffer_stack",
"(",
")",
";",
"if",
"(",
"YY_CURRENT_BUFFER",
")",
"{",
"*",
"(",
"yy_c_buf_p",
")",
"=",
"(",
"yy_hold_char",
")",
";",
"YY_CURRENT_BUFFER_LVALUE",
"->",
"yy_buf_pos",
"=",
"(",
"yy_c_buf_p",
")",
";",
"YY_CURRENT_BUFFER_LVALUE",
"->",
"yy_n_chars",
"=",
"(",
"yy_n_chars",
")",
";",
"}",
"if",
"(",
"YY_CURRENT_BUFFER",
")",
"(",
"yy_buffer_stack_top",
")",
"++",
";",
"YY_CURRENT_BUFFER_LVALUE",
"=",
"new_buffer",
";",
"yy_load_buffer_state",
"(",
")",
";",
"(",
"yy_did_buffer_switch_on_eof",
")",
"=",
"1",
";",
"}"
] | Pushes the new state onto the stack. | [
"Pushes",
"the",
"new",
"state",
"onto",
"the",
"stack",
"."
] | [
"/* This block is copied from yy_switch_to_buffer. */",
"/* Flush out information for old buffer. */",
"/* Only push if top exists. Otherwise, replace top. */",
"/* copied from yy_switch_to_buffer. */"
] | [
{
"param": "new_buffer",
"type": "YY_BUFFER_STATE"
}
] | {
"returns": [],
"raises": [],
"params": [
{
"identifier": "new_buffer",
"type": "YY_BUFFER_STATE",
"docstring": null,
"docstring_tokens": [],
"default": null,
"is_optional": null
}
],
"outlier_params": [],
"others": []
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.