Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "virtual", "const", "InstrItineraryData", "*", "getInstrItineraryData", "(", ")", "const", "{", "return", "&", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "X86" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isIntDivCheap", "(", "EVT", "VT", ",", "AttributeList", "Attr", ")", "const", "{", "bool", "OptSize", "=", "Attr", ".", "hasFnAttr", "(", "Attribute", "::", "MinSize", ")", ";", "return", "OptSize", "&&", "!", "VT", ".", "isVector", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "integer", "divide", "is", "usually", "cheaper", "than", "a", "sequence", "of", "several", "shifts", ",", "adds", ",", "and", "multiplies", "for", "this", "target", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "is_costly_group", "(", "rtx", "*", "group_insns", ",", "rtx", "next_insn", ")", "{", "int", "i", ";", "int", "issue_rate", "=", "rs6000_issue_rate", "(", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "issue_rate", ";", "i", "++", ")", "{", "sd_iterator_def", "sd_it", ";", "dep_t", "dep", ";", "rtx", "insn", "=", "group_insns", "[", "i", "]", ";", "if", "(", "!", "insn", ")", "continue", ";", "FOR_EACH_DEP", "(", "insn", ",", "SD_LIST_RES_FORW", ",", "sd_it", ",", "dep", ")", "{", "rtx", "next", "=", "DEP_CON", "(", "dep", ")", ";", "if", "(", "next", "==", "next_insn", "&&", "rs6000_is_costly_dependence", "(", "dep", ",", "dep_cost", "(", "dep", ")", ",", "0", ")", ")", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "recommended", "to", "keep", "NEXT_INSN", "``", "far", "''", "(", "in", "a", "separate", "dispatch", "group", ")", "from", "the", "insns", "in", "GROUP_INSNS", ".", "Return", "false", "otherwise", "." ]

[ "powerpcspe", "0", "0" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addIRPasses", "(", ")", "{", "addPass", "(", "createAtomicExpandPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addIRPasses", "(", ")", ";", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createInterleavedAccessPass", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "common", "target", "configurable", "passes", "that", "perform", "LLVM", "IR", "to", "IR", "transforms", "following", "machine", "independent", "optimization", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "BitVector", "P2RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "PTRA", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "PTRB", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "OUTA", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "OUTB", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "DIRA", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "DIRB", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "QX", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "QY", ")", ";", "Reserved", ".", "set", "(", "P2", "::", "R15", ")", ";", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "P2", "P2", "P2::PTRA", "P2::PTRB", "P2::OUTA", "P2::OUTB", "P2::DIRA", "P2::DIRB", "P2::QX", "P2::QY", "P2::R15" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "getMemOperandWithOffsetWidth", "(", "const", "MachineInstr", "&", "LdSt", ",", "const", "MachineOperand", "*", "&", "BaseOp", ",", "int64_t", "&", "Offset", ",", "bool", "&", "OffsetIsScalable", ",", "unsigned", "&", "Width", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "assert", "(", "LdSt", ".", "mayLoadOrStore", "(", ")", "&&", "\"Expected a memory operation.\"", ")", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", "{", "if", "(", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", ")", "||", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "}", "else", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "4", ")", "{", "if", "(", "!", "LdSt", ".", "getOperand", "(", "1", ")", ".", "isReg", "(", ")", "||", "(", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "!", "LdSt", ".", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", ")", "||", "!", "LdSt", ".", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "}", "else", "return", "false", ";", "TypeSize", "Scale", "(", "0U", ",", "false", ")", ";", "int64_t", "Dummy1", ",", "Dummy2", ";", "if", "(", "!", "getMemOpInfo", "(", "LdSt", ".", "getOpcode", "(", ")", ",", "Scale", ",", "Width", ",", "Dummy1", ",", "Dummy2", ")", ")", "return", "false", ";", "if", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "3", ")", "{", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "1", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "*", "Scale", ".", "getKnownMinSize", "(", ")", ";", "}", "else", "{", "assert", "(", "LdSt", ".", "getNumExplicitOperands", "(", ")", "==", "4", "&&", "\"invalid number of operands\"", ")", ";", "BaseOp", "=", "&", "LdSt", ".", "getOperand", "(", "2", ")", ";", "Offset", "=", "LdSt", ".", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "*", "Scale", ".", "getKnownMinSize", "(", ")", ";", "}", "OffsetIsScalable", "=", "Scale", ".", "isScalable", "(", ")", ";", "if", "(", "!", "BaseOp", "->", "isReg", "(", ")", "&&", "!", "BaseOp", "->", "isFI", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "get", "the", "base", "operand", ",", "byte", "offset", "of", "an", "instruction", "and", "the", "memory", "width", "." ]

[ "AArch64", "AArch64", "\"Expected a memory operation.\"", "3", "1", "1", "2", "4", "1", "2", "2", "3", "0U", "3", "1", "2", "4", "\"invalid number of operands\"", "2", "3" ]

[]

[ "<s>", "static", "bool", "ix86_vectorize_vec_perm_const_ok", "(", "machine_mode", "vmode", ",", "const", "unsigned", "char", "*", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "unsigned", "int", "i", ",", "nelt", ",", "which", ";", "bool", "ret", ";", "d", ".", "vmode", "=", "vmode", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "true", ";", "switch", "(", "d", ".", "vmode", ")", "{", "case", "V16SFmode", ":", "case", "V16SImode", ":", "case", "V8DImode", ":", "case", "V8DFmode", ":", "if", "(", "TARGET_AVX512F", ")", "return", "true", ";", "break", ";", "case", "V32HImode", ":", "if", "(", "TARGET_AVX512BW", ")", "return", "true", ";", "break", ";", "case", "V64QImode", ":", "if", "(", "TARGET_AVX512BW", ")", "return", "true", ";", "break", ";", "case", "V8SImode", ":", "case", "V8SFmode", ":", "case", "V4DFmode", ":", "case", "V4DImode", ":", "if", "(", "TARGET_AVX512VL", ")", "return", "true", ";", "break", ";", "case", "V16HImode", ":", "if", "(", "TARGET_AVX2", ")", "return", "true", ";", "break", ";", "case", "V32QImode", ":", "if", "(", "TARGET_AVX2", ")", "return", "true", ";", "break", ";", "case", "V4SImode", ":", "case", "V4SFmode", ":", "case", "V8HImode", ":", "case", "V16QImode", ":", "if", "(", "TARGET_XOP", ")", "return", "true", ";", "if", "(", "TARGET_SSSE3", ")", "return", "true", ";", "break", ";", "case", "V2DImode", ":", "case", "V2DFmode", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "memcpy", "(", "d", ".", "perm", ",", "sel", ",", "nelt", ")", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "unsigned", "char", "e", "=", "d", ".", "perm", "[", "i", "]", ";", "gcc_assert", "(", "e", "<", "2", "*", "nelt", ")", ";", "which", "|=", "(", "e", "<", "nelt", "?", "1", ":", "2", ")", ";", "}", "if", "(", "which", "==", "2", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "-=", "nelt", ";", "d", ".", "one_operand_p", "=", "(", "which", "!=", "3", ")", ";", "if", "(", "d", ".", "one_operand_p", "&&", "(", "d", ".", "vmode", "==", "V4SFmode", "||", "d", ".", "vmode", "==", "V4SImode", ")", ")", "return", "true", ";", "d", ".", "target", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "1", ")", ";", "d", ".", "op1", "=", "d", ".", "op0", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "2", ")", ";", "if", "(", "!", "d", ".", "one_operand_p", ")", "d", ".", "op1", "=", "gen_raw_REG", "(", "d", ".", "vmode", ",", "LAST_VIRTUAL_REGISTER", "+", "3", ")", ";", "start_sequence", "(", ")", ";", "ret", "=", "ix86_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "end_sequence", "(", ")", ";", "return", "ret", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.vec_perm_const_ok", "." ]

[ "i386", "0", "2", "1", "2", "2", "0", "3", "1", "2", "3" ]

[]

[ "<s>", "bool", "isSubregFoldable", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Check", "whether", "the", "target", "can", "fold", "a", "load", "that", "feeds", "a", "subreg", "operand", "(", "or", "a", "subreg", "operand", "that", "feeds", "a", "store", ")", "." ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "frv_alloc_temp_reg", "(", "frv_tmp_reg_t", "*", "info", ",", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "int", "mark_as_used", ",", "int", "no_abort", ")", "{", "int", "regno", "=", "info", "->", "next_reg", "[", "(", "int", ")", "class", "]", ";", "int", "orig_regno", "=", "regno", ";", "HARD_REG_SET", "*", "reg_in_class", "=", "&", "reg_class_contents", "[", "(", "int", ")", "class", "]", ";", "int", "i", ",", "nr", ";", "for", "(", ";", ";", ")", "{", "if", "(", "TEST_HARD_REG_BIT", "(", "*", "reg_in_class", ",", "regno", ")", "&&", "TEST_HARD_REG_BIT", "(", "info", "->", "regs", ",", "regno", ")", ")", "break", ";", "if", "(", "++", "regno", ">=", "FIRST_PSEUDO_REGISTER", ")", "regno", "=", "0", ";", "if", "(", "regno", "==", "orig_regno", ")", "{", "gcc_assert", "(", "no_abort", ")", ";", "return", "NULL_RTX", ";", "}", "}", "nr", "=", "HARD_REGNO_NREGS", "(", "regno", ",", "mode", ")", ";", "info", "->", "next_reg", "[", "(", "int", ")", "class", "]", "=", "regno", "+", "nr", ";", "if", "(", "mark_as_used", ")", "for", "(", "i", "=", "0", ";", "i", "<", "nr", ";", "i", "++", ")", "CLEAR_HARD_REG_BIT", "(", "info", "->", "regs", ",", "regno", "+", "i", ")", ";", "return", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "}", "</s>" ]

[ "Return", "the", "next", "available", "temporary", "register", "in", "a", "given", "class", "." ]

[ "frv", "0", "0" ]

[]

[ "<s>", "static", "const", "uint16_t", "*", "lookup", "(", "unsigned", "opcode", ",", "unsigned", "domain", ")", "{", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "array_lengthof", "(", "ReplaceableInstrs", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "if", "(", "ReplaceableInstrs", "[", "i", "]", "[", "domain", "-", "1", "]", "==", "opcode", ")", "return", "ReplaceableInstrs", "[", "i", "]", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "This", "method", "finds", "the", "value", "with", "the", "given", "Name", "in", "the", "the", "symbol", "table", "." ]

[ "X86", "0", "1" ]

[]

[ "<s>", "static", "void", "build_sv_index64", "(", "function_builder", "&", "b", ",", "const", "char", "*", "signature", ",", "const", "function_group_info", "&", "group", ")", "{", "build_32_64", "(", "b", ",", "signature", ",", "group", ",", "MODE_none", ",", "MODE_s64index", ")", ";", "build_32_64", "(", "b", ",", "signature", ",", "group", ",", "MODE_none", ",", "MODE_u64index", ")", ";", "}", "</s>" ]

[ "Like", "build_sv_index", ",", "but", "only", "handle", "64-bit", "types", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "microblaze_asm_output_ident", "(", "const", "char", "*", "string", ")", "{", "const", "char", "*", "section_asm_op", ";", "int", "size", ";", "char", "*", "buf", ";", "if", "(", "symtab", "->", "state", "!=", "PARSING", ")", "return", ";", "size", "=", "strlen", "(", "string", ")", "+", "1", ";", "if", "(", "size", "<=", "microblaze_section_threshold", ")", "section_asm_op", "=", "SDATA2_SECTION_ASM_OP", ";", "else", "section_asm_op", "=", "READONLY_DATA_SECTION_ASM_OP", ";", "buf", "=", "ACONCAT", "(", "(", "\"\\t.pushsection\"", ",", "section_asm_op", ",", "\"\\n\\t.ascii \\\"\"", ",", "string", ",", "\"\\\\0\\\"\\n\"", ",", "\"\\t.popsection\\n\"", ",", "NULL", ")", ")", ";", "symtab", "->", "finalize_toplevel_asm", "(", "build_string", "(", "strlen", "(", "buf", ")", ",", "buf", ")", ")", ";", "}", "</s>" ]

[ "Queue", "an", ".ident", "string", "in", "the", "queue", "of", "top-level", "asm", "statements", ".", "If", "the", "string", "size", "is", "below", "the", "threshold", ",", "put", "it", "into", ".sdata2", ".", "If", "the", "front-end", "is", "done", ",", "we", "must", "be", "being", "called", "from", "toplev.cc", ".", "In", "that", "case", ",", "do", "nothing", "." ]

[ "microblaze", "1", "\"\\t.pushsection\"", "\"\\n\\t.ascii \\\"\"", "\"\\\\0\\\"\\n\"", "\"\\t.popsection\\n\"" ]

[]

[ "<s>", "static", "int", "get_element_number", "(", "tree", "vec_type", ",", "tree", "arg", ")", "{", "unsigned", "HOST_WIDE_INT", "elt", ",", "max", "=", "TYPE_VECTOR_SUBPARTS", "(", "vec_type", ")", "-", "1", ";", "if", "(", "!", "tree_fits_uhwi_p", "(", "arg", ")", "||", "(", "elt", "=", "tree_to_uhwi", "(", "arg", ")", ",", "elt", ">", "max", ")", ")", "{", "error", "(", "\"selector must be an integer constant in the range [0, %wi]\"", ",", "max", ")", ";", "return", "0", ";", "}", "return", "elt", ";", "}", "</s>" ]

[ "Return", "the", "integer", "constant", "in", "ARG", ".", "Constrain", "it", "to", "be", "in", "the", "range", "of", "the", "subparts", "of", "VEC_TYPE", ";", "issue", "an", "error", "if", "not", "." ]

[ "rs6000", "1", "\"selector must be an integer constant in the range [0, %wi]\"", "0" ]

[]

[ "<s>", "const", "M680x0Subtarget", "*", "getSubtargetImpl", "(", ")", "const", "{", "return", "&", "Subtarget", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "M680x0", "M680x0" ]

[]

[ "<s>", "unsigned", "RISCVTargetLowering", "::", "ComputeNumSignBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "DemandedElts", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "case", "RISCVISD", "::", "DIVW", ":", "case", "RISCVISD", "::", "DIVUW", ":", "case", "RISCVISD", "::", "REMUW", ":", "case", "RISCVISD", "::", "ROLW", ":", "case", "RISCVISD", "::", "RORW", ":", "case", "RISCVISD", "::", "GREVIW", ":", "case", "RISCVISD", "::", "GORCIW", ":", "case", "RISCVISD", "::", "FSLW", ":", "case", "RISCVISD", "::", "FSRW", ":", "return", "33", ";", "case", "RISCVISD", "::", "VMV_X_S", ":", "return", "Subtarget", ".", "getXLen", "(", ")", "-", "Op", ".", "getOperand", "(", "0", ")", ".", "getScalarValueSizeInBits", "(", ")", "+", "1", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Determine", "the", "number", "of", "bits", "in", "the", "operation", "that", "are", "sign", "bits", "." ]

[ "RISCV", "RISCV", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "RISCVISD::DIVW", "RISCVISD::DIVUW", "RISCVISD::REMUW", "RISCVISD::ROLW", "RISCVISD::RORW", "RISCVISD::GREVIW", "RISCVISD::GORCIW", "RISCVISD::FSLW", "RISCVISD::FSRW", "33", "RISCVISD::VMV_X_S", "0", "1", "1" ]

[]

[ "<s>", "void", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "Blackfin", "128" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "areMemAccessesTriviallyDisjoint", "(", "const", "MachineInstr", "&", "MIa", ",", "const", "MachineInstr", "&", "MIb", ",", "AliasAnalysis", "*", "AA", ")", "const", "{", "if", "(", "MIa", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIb", ".", "hasUnmodeledSideEffects", "(", ")", "||", "MIa", ".", "hasOrderedMemoryRef", "(", ")", "||", "MIb", ".", "hasOrderedMemoryRef", "(", ")", ")", "return", "false", ";", "if", "(", "MIa", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIa", ")", "&&", "MIb", ".", "mayLoad", "(", ")", "&&", "!", "isMemOp", "(", "MIb", ")", ")", "return", "true", ";", "unsigned", "BasePosA", ",", "OffsetPosA", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIa", ",", "BasePosA", ",", "OffsetPosA", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseA", "=", "MIa", ".", "getOperand", "(", "BasePosA", ")", ";", "unsigned", "BaseRegA", "=", "BaseA", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubA", "=", "BaseA", ".", "getSubReg", "(", ")", ";", "unsigned", "BasePosB", ",", "OffsetPosB", ";", "if", "(", "!", "getBaseAndOffsetPosition", "(", "MIb", ",", "BasePosB", ",", "OffsetPosB", ")", ")", "return", "false", ";", "const", "MachineOperand", "&", "BaseB", "=", "MIb", ".", "getOperand", "(", "BasePosB", ")", ";", "unsigned", "BaseRegB", "=", "BaseB", ".", "getReg", "(", ")", ";", "unsigned", "BaseSubB", "=", "BaseB", ".", "getSubReg", "(", ")", ";", "if", "(", "BaseRegA", "!=", "BaseRegB", "||", "BaseSubA", "!=", "BaseSubB", ")", "return", "false", ";", "unsigned", "SizeA", "=", "getMemAccessSize", "(", "MIa", ")", ";", "unsigned", "SizeB", "=", "getMemAccessSize", "(", "MIb", ")", ";", "const", "MachineOperand", "&", "OffA", "=", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ";", "const", "MachineOperand", "&", "OffB", "=", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ";", "if", "(", "!", "MIa", ".", "getOperand", "(", "OffsetPosA", ")", ".", "isImm", "(", ")", "||", "!", "MIb", ".", "getOperand", "(", "OffsetPosB", ")", ".", "isImm", "(", ")", ")", "return", "false", ";", "int", "OffsetA", "=", "isPostIncrement", "(", "MIa", ")", "?", "0", ":", "OffA", ".", "getImm", "(", ")", ";", "int", "OffsetB", "=", "isPostIncrement", "(", "MIb", ")", "?", "0", ":", "OffB", ".", "getImm", "(", ")", ";", "if", "(", "OffsetA", ">", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetA", "-", "(", "int64_t", ")", "OffsetB", ")", ";", "return", "SizeB", "<=", "OffDiff", ";", "}", "if", "(", "OffsetA", "<", "OffsetB", ")", "{", "uint64_t", "OffDiff", "=", "(", "uint64_t", ")", "(", "(", "int64_t", ")", "OffsetB", "-", "(", "int64_t", ")", "OffsetA", ")", ";", "return", "SizeA", "<=", "OffDiff", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Sometimes", ",", "it", "is", "possible", "for", "the", "target", "to", "tell", ",", "even", "without", "aliasing", "information", ",", "that", "two", "MIs", "access", "different", "memory", "addresses", "." ]

[ "Hexagon", "Hexagon", "0", "0" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "verifyInstruction", "(", "const", "MachineInstr", "&", "MI", ",", "StringRef", "&", "ErrInfo", ")", "const", "{", "const", "MCInstrInfo", "*", "MCII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "MCInstrDesc", "const", "&", "Desc", "=", "MCII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ";", "for", "(", "auto", "&", "OI", ":", "enumerate", "(", "Desc", ".", "operands", "(", ")", ")", ")", "{", "unsigned", "OpType", "=", "OI", ".", "value", "(", ")", ".", "OperandType", ";", "if", "(", "OpType", ">=", "RISCVOp", "::", "OPERAND_FIRST_RISCV_IMM", "&&", "OpType", "<=", "RISCVOp", "::", "OPERAND_LAST_RISCV_IMM", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OI", ".", "index", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "{", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "bool", "Ok", ";", "switch", "(", "OpType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected operand type\"", ")", ";", "case", "RISCVOp", "::", "OPERAND_UIMM1", ":", "Ok", "=", "isUInt", "<", "1", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM4", ":", "Ok", "=", "isUInt", "<", "4", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM5", ":", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM12", ":", "Ok", "=", "isUInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM12", ":", "Ok", "=", "isInt", "<", "12", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM13_LSB0", ":", "Ok", "=", "isShiftedInt", "<", "12", ",", "1", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMM20", ":", "Ok", "=", "isUInt", "<", "20", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_SIMM21_LSB0", ":", "Ok", "=", "isShiftedInt", "<", "20", ",", "1", ">", "(", "Imm", ")", ";", "break", ";", "case", "RISCVOp", "::", "OPERAND_UIMMLOG2XLEN", ":", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isArch64Bit", "(", ")", ")", "Ok", "=", "isUInt", "<", "6", ">", "(", "Imm", ")", ";", "else", "Ok", "=", "isUInt", "<", "5", ">", "(", "Imm", ")", ";", "break", ";", "}", "if", "(", "!", "Ok", ")", "{", "ErrInfo", "=", "\"Invalid immediate\"", ";", "return", "false", ";", "}", "}", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Perform", "target-specific", "instruction", "verification", "." ]

[ "RISCV", "RISCV", "RISCVOp::OPERAND_FIRST_RISCV_IMM", "RISCVOp::OPERAND_LAST_RISCV_IMM", "\"Unexpected operand type\"", "RISCVOp::OPERAND_UIMM1", "1", "RISCVOp::OPERAND_UIMM4", "4", "RISCVOp::OPERAND_UIMM5", "5", "RISCVOp::OPERAND_UIMM12", "12", "RISCVOp::OPERAND_SIMM12", "12", "RISCVOp::OPERAND_SIMM13_LSB0", "12", "1", "RISCVOp::OPERAND_UIMM20", "20", "RISCVOp::OPERAND_SIMM21_LSB0", "20", "1", "RISCVOp::OPERAND_UIMMLOG2XLEN", "6", "5", "\"Invalid immediate\"" ]

[]

[ "<s>", "static", "void", "thumb_pushpop", "(", "FILE", "*", "f", ",", "unsigned", "long", "mask", ",", "int", "push", ",", "int", "*", "cfa_offset", ",", "unsigned", "long", "real_regs", ")", "{", "int", "regno", ";", "int", "lo_mask", "=", "mask", "&", "0xFF", ";", "int", "pushed_words", "=", "0", ";", "gcc_assert", "(", "mask", ")", ";", "if", "(", "lo_mask", "==", "0", "&&", "!", "push", "&&", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", ")", "{", "thumb_exit", "(", "f", ",", "-", "1", ")", ";", "return", ";", "}", "if", "(", "ARM_EABI_UNWIND_TABLES", "&&", "push", ")", "{", "fprintf", "(", "f", ",", "\"\\t.save\\t{\"", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "15", ";", "regno", "++", ")", "{", "if", "(", "real_regs", "&", "(", "1", "<<", "regno", ")", ")", "{", "if", "(", "real_regs", "&", "(", "(", "1", "<<", "regno", ")", "-", "1", ")", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "regno", ")", ";", "}", "}", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "}", "fprintf", "(", "f", ",", "\"\\t%s\\t{\"", ",", "push", "?", "\"push\"", ":", "\"pop\"", ")", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "LAST_LO_REGNUM", ";", "regno", "++", ",", "lo_mask", ">>=", "1", ")", "{", "if", "(", "lo_mask", "&", "1", ")", "{", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "regno", ")", ";", "if", "(", "(", "lo_mask", "&", "~", "1", ")", "!=", "0", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "pushed_words", "++", ";", "}", "}", "if", "(", "push", "&&", "(", "mask", "&", "(", "1", "<<", "LR_REGNUM", ")", ")", ")", "{", "if", "(", "mask", "&", "0xFF", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "LR_REGNUM", ")", ";", "pushed_words", "++", ";", "}", "else", "if", "(", "!", "push", "&&", "(", "mask", "&", "(", "1", "<<", "PC_REGNUM", ")", ")", ")", "{", "if", "(", "TARGET_INTERWORK", "||", "TARGET_BACKTRACE", "||", "current_function_calls_eh_return", ")", "{", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "thumb_exit", "(", "f", ",", "-", "1", ")", ";", "return", ";", "}", "else", "{", "if", "(", "mask", "&", "0xFF", ")", "fprintf", "(", "f", ",", "\", \"", ")", ";", "asm_fprintf", "(", "f", ",", "\"%r\"", ",", "PC_REGNUM", ")", ";", "}", "}", "fprintf", "(", "f", ",", "\"}\\n\"", ")", ";", "if", "(", "push", "&&", "pushed_words", "&&", "dwarf2out_do_frame", "(", ")", ")", "{", "char", "*", "l", "=", "dwarf2out_cfi_label", "(", ")", ";", "int", "pushed_mask", "=", "real_regs", ";", "*", "cfa_offset", "+=", "pushed_words", "*", "4", ";", "dwarf2out_def_cfa", "(", "l", ",", "SP_REGNUM", ",", "*", "cfa_offset", ")", ";", "pushed_words", "=", "0", ";", "pushed_mask", "=", "real_regs", ";", "for", "(", "regno", "=", "0", ";", "regno", "<=", "14", ";", "regno", "++", ",", "pushed_mask", ">>=", "1", ")", "{", "if", "(", "pushed_mask", "&", "1", ")", "dwarf2out_reg_save", "(", "l", ",", "regno", ",", "4", "*", "pushed_words", "++", "-", "*", "cfa_offset", ")", ";", "}", "}", "}", "</s>" ]

[ "Emit", "code", "to", "push", "or", "pop", "registers", "to", "or", "from", "the", "stack", ".", "F", "is", "the", "assembly", "file", ".", "MASK", "is", "the", "registers", "to", "push", "or", "pop", ".", "PUSH", "is", "nonzero", "if", "we", "should", "push", ",", "and", "zero", "if", "we", "should", "pop", ".", "For", "debugging", "output", ",", "if", "pushing", ",", "adjust", "CFA_OFFSET", "by", "the", "amount", "of", "space", "added", "to", "the", "stack", ".", "REAL_REGS", "should", "have", "the", "same", "number", "of", "bits", "set", "as", "MASK", ",", "and", "will", "be", "used", "instead", "(", "in", "the", "same", "order", ")", "to", "describe", "which", "registers", "were", "saved", "-", "this", "is", "used", "to", "mark", "the", "save", "slots", "when", "we", "push", "high", "registers", "after", "moving", "them", "to", "low", "registers", "." ]

[ "arm", "0xFF", "0", "0", "1", "1", "\"\\t.save\\t{\"", "0", "15", "1", "1", "1", "\", \"", "\"%r\"", "\"}\\n\"", "\"\\t%s\\t{\"", "\"push\"", "\"pop\"", "0", "1", "1", "\"%r\"", "1", "0", "\", \"", "1", "0xFF", "\", \"", "\"%r\"", "1", "\"}\\n\"", "1", "0xFF", "\", \"", "\"%r\"", "\"}\\n\"", "4", "0", "0", "14", "1", "1", "4" ]

[]

[ "<s>", "bool", "XCoreRegisterInfo", "::", "needsFrameMoves", "(", "const", "MachineFunction", "&", "MF", ")", "{", "return", "MF", ".", "getMMI", "(", ")", ".", "hasDebugInfo", "(", ")", "||", "MF", ".", "getFunction", "(", ")", "->", "needsUnwindTableEntry", "(", ")", ";", "}", "</s>" ]

[ "Return", "whether", "to", "emit", "frame", "moves", "." ]

[ "XCore", "XCore" ]

[]

[ "<s>", "static", "bool", "aarch64_pass_by_reference_1", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "const", "function_arg_info", "&", "arg", ")", "{", "HOST_WIDE_INT", "size", ";", "machine_mode", "dummymode", ";", "int", "nregs", ";", "if", "(", "arg", ".", "mode", "==", "BLKmode", "&&", "arg", ".", "type", ")", "size", "=", "int_size_in_bytes", "(", "arg", ".", "type", ")", ";", "else", "size", "=", "GET_MODE_SIZE", "(", "arg", ".", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "size", "=", "int_size_in_bytes", "(", "arg", ".", "type", ")", ";", "if", "(", "size", "<", "0", ")", "return", "true", ";", "if", "(", "aarch64_vfp_is_call_or_return_candidate", "(", "arg", ".", "mode", ",", "arg", ".", "type", ",", "&", "dummymode", ",", "&", "nregs", ",", "NULL", ",", "!", "pcum", "||", "pcum", "->", "silent_p", ")", ")", "return", "false", ";", "return", "size", ">", "2", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Subroutine", "of", "aarch64_pass_by_reference", "for", "arguments", "that", "are", "not", "passed", "in", "SVE", "registers", "." ]

[ "aarch64", "0", "2" ]

[]

[ "<s>", "bool", "processBlock", "(", "MachineBasicBlock", "&", "MBB", ")", "{", "bool", "Changed", "=", "false", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "if", "(", "!", "MI", ".", "isFullCopy", "(", ")", ")", "continue", ";", "MachineOperand", "&", "DstMO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "MachineOperand", "&", "SrcMO", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "if", "(", "IsVSReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "!", "IsVSReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "{", "Changed", "=", "true", ";", "const", "TargetRegisterClass", "*", "SrcRC", "=", "&", "PPC", "::", "VSLRCRegClass", ";", "assert", "(", "(", "IsF8Reg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSSReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSFReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "&&", "\"Unknown source for a VSX copy\"", ")", ";", "unsigned", "NewVReg", "=", "MRI", ".", "createVirtualRegister", "(", "SrcRC", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "SUBREG_TO_REG", ")", ",", "NewVReg", ")", ".", "addImm", "(", "1", ")", ".", "add", "(", "SrcMO", ")", ".", "addImm", "(", "PPC", "::", "sub_64", ")", ";", "SrcMO", ".", "setReg", "(", "NewVReg", ")", ";", "}", "else", "if", "(", "!", "IsVSReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "&&", "IsVSReg", "(", "SrcMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "{", "Changed", "=", "true", ";", "const", "TargetRegisterClass", "*", "DstRC", "=", "&", "PPC", "::", "VSLRCRegClass", ";", "assert", "(", "(", "IsF8Reg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSFReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", "||", "IsVSSReg", "(", "DstMO", ".", "getReg", "(", ")", ",", "MRI", ")", ")", "&&", "\"Unknown destination for a VSX copy\"", ")", ";", "unsigned", "NewVReg", "=", "MRI", ".", "createVirtualRegister", "(", "DstRC", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "MI", ".", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "NewVReg", ")", ".", "add", "(", "SrcMO", ")", ";", "SrcMO", ".", "setReg", "(", "NewVReg", ")", ";", "SrcMO", ".", "setSubReg", "(", "PPC", "::", "sub_64", ")", ";", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "processBlock", "-", "If", "there", "are", "any", "predecessors", "whose", "control", "can", "be", "threaded", "through", "to", "a", "successor", ",", "transform", "them", "now", "." ]

[ "PowerPC", "0", "1", "PPC::VSLRCRegClass", "\"Unknown source for a VSX copy\"", "1", "PPC::sub_64", "PPC::VSLRCRegClass", "\"Unknown destination for a VSX copy\"", "PPC::sub_64" ]

[]

[ "<s>", "static", "rtx", "rs6000_longcall_ref", "(", "rtx", "call_ref", ",", "rtx", "arg", ")", "{", "const", "char", "*", "call_name", "=", "XSTR", "(", "call_ref", ",", "0", ")", ";", "if", "(", "*", "call_name", "==", "'.'", ")", "{", "while", "(", "*", "call_name", "==", "'.'", ")", "call_name", "++", ";", "tree", "node", "=", "get_identifier", "(", "call_name", ")", ";", "call_ref", "=", "gen_rtx_SYMBOL_REF", "(", "VOIDmode", ",", "IDENTIFIER_POINTER", "(", "node", ")", ")", ";", "}", "if", "(", "TARGET_PLTSEQ", ")", "{", "rtx", "base", "=", "const0_rtx", ";", "int", "regno", "=", "12", ";", "if", "(", "rs6000_pcrel_p", "(", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "u", "=", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "base", ",", "call_ref", ",", "arg", ")", ",", "UNSPECV_PLT_PCREL", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "u", ")", ")", ";", "return", "reg", ";", "}", "if", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "TOC_REGISTER", ")", ";", "else", "{", "if", "(", "flag_pic", ")", "base", "=", "gen_rtx_REG", "(", "Pmode", ",", "RS6000_PIC_OFFSET_TABLE_REGNUM", ")", ";", "regno", "=", "11", ";", "}", "rtx", "reg", "=", "gen_rtx_REG", "(", "Pmode", ",", "regno", ")", ";", "rtx", "hi", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "base", ",", "call_ref", ",", "arg", ")", ",", "UNSPEC_PLT16_HA", ")", ";", "rtx", "lo", "=", "gen_rtx_UNSPEC_VOLATILE", "(", "Pmode", ",", "gen_rtvec", "(", "3", ",", "reg", ",", "call_ref", ",", "arg", ")", ",", "UNSPECV_PLT16_LO", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "hi", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "lo", ")", ")", ";", "return", "reg", ";", "}", "return", "force_reg", "(", "Pmode", ",", "call_ref", ")", ";", "}", "</s>" ]

[ "Return", "a", "reference", "suitable", "for", "calling", "a", "function", "with", "the", "longcall", "attribute", "." ]

[ "rs6000", "0", "12", "3", "11", "3", "3" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "unsigned", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "unsigned", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "MachineBasicBlock", "::", "iterator", "LastFrameDestroy", "=", "MBBI", ";", "std", "::", "advance", "(", "LastFrameDestroy", ",", "-", "MFI", ".", "getCalleeSavedInfo", "(", ")", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "StackSize", "+", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"" ]

[]

[ "<s>", "int", "s390_const_ok_for_constraint_p", "(", "HOST_WIDE_INT", "value", ",", "int", "c", ",", "const", "char", "*", "str", ")", "{", "enum", "machine_mode", "mode", ",", "part_mode", ";", "int", "def", ";", "int", "part", ",", "part_goal", ";", "gcc_assert", "(", "c", "==", "str", "[", "0", "]", ")", ";", "switch", "(", "str", "[", "0", "]", ")", "{", "case", "'I'", ":", "return", "(", "unsigned", "int", ")", "value", "<", "256", ";", "case", "'J'", ":", "return", "(", "unsigned", "int", ")", "value", "<", "4096", ";", "case", "'K'", ":", "return", "value", ">=", "-", "32768", "&&", "value", "<", "32768", ";", "case", "'L'", ":", "return", "(", "TARGET_LONG_DISPLACEMENT", "?", "(", "value", ">=", "-", "524288", "&&", "value", "<=", "524287", ")", ":", "(", "value", ">=", "0", "&&", "value", "<=", "4095", ")", ")", ";", "case", "'M'", ":", "return", "value", "==", "2147483647", ";", "case", "'N'", ":", "if", "(", "str", "[", "1", "]", "==", "'x'", ")", "part_goal", "=", "-", "1", ";", "else", "part_goal", "=", "str", "[", "1", "]", "-", "'0'", ";", "switch", "(", "str", "[", "2", "]", ")", "{", "case", "'Q'", ":", "part_mode", "=", "QImode", ";", "break", ";", "case", "'H'", ":", "part_mode", "=", "HImode", ";", "break", ";", "case", "'S'", ":", "part_mode", "=", "SImode", ";", "break", ";", "default", ":", "return", "0", ";", "}", "switch", "(", "str", "[", "3", "]", ")", "{", "case", "'H'", ":", "mode", "=", "HImode", ";", "break", ";", "case", "'S'", ":", "mode", "=", "SImode", ";", "break", ";", "case", "'D'", ":", "mode", "=", "DImode", ";", "break", ";", "default", ":", "return", "0", ";", "}", "switch", "(", "str", "[", "4", "]", ")", "{", "case", "'0'", ":", "def", "=", "0", ";", "break", ";", "case", "'F'", ":", "def", "=", "-", "1", ";", "break", ";", "default", ":", "return", "0", ";", "}", "if", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "GET_MODE_SIZE", "(", "part_mode", ")", ")", "return", "0", ";", "part", "=", "s390_single_part", "(", "GEN_INT", "(", "value", ")", ",", "mode", ",", "part_mode", ",", "def", ")", ";", "if", "(", "part", "<", "0", ")", "return", "0", ";", "if", "(", "part_goal", "!=", "-", "1", "&&", "part_goal", "!=", "part", ")", "return", "0", ";", "break", ";", "case", "'O'", ":", "if", "(", "!", "TARGET_EXTIMM", ")", "return", "0", ";", "switch", "(", "str", "[", "1", "]", ")", "{", "case", "'s'", ":", "return", "trunc_int_for_mode", "(", "value", ",", "SImode", ")", "==", "value", ";", "case", "'p'", ":", "return", "value", "==", "0", "||", "s390_single_part", "(", "GEN_INT", "(", "value", ")", ",", "DImode", ",", "SImode", ",", "0", ")", "==", "1", ";", "case", "'n'", ":", "return", "value", "==", "-", "1", "||", "s390_single_part", "(", "GEN_INT", "(", "value", ")", ",", "DImode", ",", "SImode", ",", "-", "1", ")", "==", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "break", ";", "case", "'P'", ":", "return", "legitimate_reload_constant_p", "(", "GEN_INT", "(", "value", ")", ")", ";", "default", ":", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Return", "true", "if", "VALUE", "matches", "the", "constraint", "STR", "." ]

[ "s390", "0", "0", "256", "4096", "32768", "32768", "524288", "524287", "0", "4095", "2147483647", "1", "1", "1", "2", "0", "3", "0", "4", "0", "1", "0", "0", "0", "0", "1", "0", "0", "1", "0", "0", "1", "1", "1", "1", "0", "1" ]

[]

[ "<s>", "ARMBaseTargetMachine", "::", "ARMBaseTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Reloc", "::", "Model", "RM", ",", "CodeModel", "::", "Model", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "isLittle", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "CPU", ",", "Options", ",", "isLittle", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "RM", ",", "CM", ",", "OL", ")", ",", "TargetABI", "(", "computeTargetABI", "(", "TT", ",", "CPU", ",", "Options", ")", ")", ",", "TLOF", "(", "createTLOF", "(", "getTargetTriple", "(", ")", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "isLittle", ")", ",", "isLittle", "(", "isLittle", ")", "{", "if", "(", "Options", ".", "FloatABIType", "==", "FloatABI", "::", "Default", ")", "this", "->", "Options", ".", "FloatABIType", "=", "Subtarget", ".", "isTargetHardFloat", "(", ")", "?", "FloatABI", "::", "Hard", ":", "FloatABI", "::", "Soft", ";", "}", "</s>" ]

[ "Create", "an", "ARM", "architecture", "model", "." ]

[ "ARM", "ARM", "ARM" ]

[]

[ "<s>", "static", "tree", "arc_handle_interrupt_attribute", "(", "tree", "*", ",", "tree", "name", ",", "tree", "args", ",", "int", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "args", ")", ";", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "if", "(", "TREE_CODE", "(", "value", ")", "!=", "STRING_CST", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink1\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink2\"", ")", "&&", "!", "TARGET_V2", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "else", "if", "(", "TARGET_V2", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"ilink\"", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not \\\"ilink\\\"\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "an", "``", "interrupt", "''", "attribute", ";", "arguments", "as", "in", "struct", "attribute_spec.handler", "." ]

[ "arc", "\"argument of %qE attribute is not a string constant\"", "\"ilink1\"", "\"ilink2\"", "\"argument of %qE attribute is not \\\"ilink1\\\" or \\\"ilink2\\\"\"", "\"ilink\"", "\"argument of %qE attribute is not \\\"ilink\\\"\"" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "X86" ]

[]

[ "<s>", "static", "NewSense", "Def", "(", "unsigned", "PR", ",", "bool", "True", ",", "bool", "Float", ")", "{", "NewSense", "NS", "=", "{", "PR", ",", "Float", ",", "false", ",", "True", "}", ";", "return", "NS", ";", "}", "</s>" ]

[ "Pointer", "to", "the", "VPDef", "that", "defines", "this", "VPValue", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "bool", "aarch64_some_values_include_pst_objects_p", "(", "const_tree", "type", ")", "{", "if", "(", "TYPE_SIZE", "(", "type", ")", "&&", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", ")", "return", "false", ";", "if", "(", "aarch64_sve", "::", "builtin_type_p", "(", "type", ")", ")", "return", "true", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", "return", "aarch64_some_values_include_pst_objects_p", "(", "TREE_TYPE", "(", "type", ")", ")", ";", "if", "(", "RECORD_OR_UNION_TYPE_P", "(", "type", ")", ")", "for", "(", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "if", "(", "TREE_CODE", "(", "field", ")", "==", "FIELD_DECL", "&&", "aarch64_some_values_include_pst_objects_p", "(", "TREE_TYPE", "(", "field", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "at", "least", "one", "possible", "value", "of", "type", "TYPE", "includes", "at", "least", "one", "object", "of", "Pure", "Scalable", "Type", ",", "in", "the", "sense", "of", "the", "AAPCS64", ".", "This", "is", "a", "relatively", "expensive", "test", "for", "some", "types", ",", "so", "it", "should", "generally", "be", "made", "as", "late", "as", "possible", "." ]

[ "aarch64", "aarch64_sve::builtin_type_p" ]

[]

[ "<s>", "static", "void", "ix86_setup_incoming_varargs", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "enum", "machine_mode", "mode", ",", "tree", "type", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "next_cum", ";", "rtx", "save_area", "=", "NULL_RTX", ",", "mem", ";", "rtx", "label", ";", "rtx", "label_ref", ";", "rtx", "tmp_reg", ";", "rtx", "nsse_reg", ";", "int", "set", ";", "tree", "fntype", ";", "int", "stdarg_p", ";", "int", "i", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", ";", "if", "(", "!", "cfun", "->", "va_list_gpr_size", "&&", "!", "cfun", "->", "va_list_fpr_size", ")", "return", ";", "ix86_save_varrargs_registers", "=", "1", ";", "cfun", "->", "stack_alignment_needed", "=", "128", ";", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "stdarg_p", "=", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", "!=", "0", "&&", "(", "TREE_VALUE", "(", "tree_last", "(", "TYPE_ARG_TYPES", "(", "fntype", ")", ")", ")", "!=", "void_type_node", ")", ")", ";", "next_cum", "=", "*", "cum", ";", "if", "(", "stdarg_p", ")", "function_arg_advance", "(", "&", "next_cum", ",", "mode", ",", "type", ",", "1", ")", ";", "if", "(", "!", "no_rtl", ")", "save_area", "=", "frame_pointer_rtx", ";", "set", "=", "get_varargs_alias_set", "(", ")", ";", "for", "(", "i", "=", "next_cum", ".", "regno", ";", "i", "<", "ix86_regparm", "&&", "i", "<", "next_cum", ".", "regno", "+", "cfun", "->", "va_list_gpr_size", "/", "UNITS_PER_WORD", ";", "i", "++", ")", "{", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "save_area", ",", "i", "*", "UNITS_PER_WORD", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "Pmode", ",", "x86_64_int_parameter_registers", "[", "i", "]", ")", ")", ";", "}", "if", "(", "next_cum", ".", "sse_nregs", "&&", "cfun", "->", "va_list_fpr_size", ")", "{", "label", "=", "gen_label_rtx", "(", ")", ";", "label_ref", "=", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ";", "tmp_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "nsse_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_zero_extendqidi2", "(", "nsse_reg", ",", "gen_rtx_REG", "(", "QImode", ",", "0", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp_reg", ",", "gen_rtx_MULT", "(", "Pmode", ",", "nsse_reg", ",", "GEN_INT", "(", "4", ")", ")", ")", ")", ";", "if", "(", "next_cum", ".", "sse_regno", ")", "emit_move_insn", "(", "nsse_reg", ",", "gen_rtx_CONST", "(", "DImode", ",", "gen_rtx_PLUS", "(", "DImode", ",", "label_ref", ",", "GEN_INT", "(", "next_cum", ".", "sse_regno", "*", "4", ")", ")", ")", ")", ";", "else", "emit_move_insn", "(", "nsse_reg", ",", "label_ref", ")", ";", "emit_insn", "(", "gen_subdi3", "(", "nsse_reg", ",", "nsse_reg", ",", "tmp_reg", ")", ")", ";", "tmp_reg", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "tmp_reg", ",", "plus_constant", "(", "save_area", ",", "8", "*", "REGPARM_MAX", "+", "127", ")", ")", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "BLKmode", ",", "plus_constant", "(", "tmp_reg", ",", "-", "127", ")", ")", ";", "MEM_NOTRAP_P", "(", "mem", ")", "=", "1", ";", "set_mem_alias_set", "(", "mem", ",", "set", ")", ";", "set_mem_align", "(", "mem", ",", "BITS_PER_WORD", ")", ";", "emit_insn", "(", "gen_sse_prologue_save", "(", "mem", ",", "nsse_reg", ",", "GEN_INT", "(", "next_cum", ".", "sse_regno", ")", ",", "label", ")", ")", ";", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_SETUP_INCOMING_VARARGS", "." ]

[ "i386", "1", "128", "0", "1", "1", "0", "4", "4", "8", "127", "127", "1" ]

[]

[ "<s>", "void", "LanaiTargetObjectFile", "::", "Initialize", "(", "MCContext", "&", "Ctx", ",", "const", "TargetMachine", "&", "TM", ")", "{", "TargetLoweringObjectFileELF", "::", "Initialize", "(", "Ctx", ",", "TM", ")", ";", "InitializeELF", "(", "TM", ".", "Options", ".", "UseInitArray", ")", ";", "SmallDataSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sdata\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "SmallBSSSection", "=", "getContext", "(", ")", ".", "getELFSection", "(", "\".sbss\"", ",", "ELF", "::", "SHT_NOBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "called", "before", "any", "actual", "lowering", "is", "done", "." ]

[ "Lanai", "Lanai", "\".sdata\"", "\".sbss\"" ]

[]

[ "<s>", "MCSection", "*", "X86WindowsTargetObjectFile", "::", "getSectionForConstant", "(", "SectionKind", "Kind", ",", "const", "Constant", "*", "C", ")", "const", "{", "if", "(", "Kind", ".", "isReadOnly", "(", ")", ")", "{", "if", "(", "C", ")", "{", "Type", "*", "Ty", "=", "C", "->", "getType", "(", ")", ";", "SmallString", "<", "32", ">", "COMDATSymName", ";", "if", "(", "Ty", "->", "isFloatTy", "(", ")", "||", "Ty", "->", "isDoubleTy", "(", ")", ")", "{", "COMDATSymName", "=", "\"__real@\"", ";", "COMDATSymName", "+=", "scalarConstantToHexString", "(", "C", ")", ";", "}", "else", "if", "(", "const", "auto", "*", "VTy", "=", "dyn_cast", "<", "VectorType", ">", "(", "Ty", ")", ")", "{", "uint64_t", "NumBits", "=", "VTy", "->", "getBitWidth", "(", ")", ";", "if", "(", "NumBits", "==", "128", "||", "NumBits", "==", "256", ")", "{", "COMDATSymName", "=", "NumBits", "==", "128", "?", "\"__xmm@\"", ":", "\"__ymm@\"", ";", "for", "(", "int", "I", "=", "VTy", "->", "getNumElements", "(", ")", "-", "1", ",", "E", "=", "-", "1", ";", "I", "!=", "E", ";", "--", "I", ")", "COMDATSymName", "+=", "scalarConstantToHexString", "(", "C", "->", "getAggregateElement", "(", "I", ")", ")", ";", "}", "}", "if", "(", "!", "COMDATSymName", ".", "empty", "(", ")", ")", "{", "unsigned", "Characteristics", "=", "COFF", "::", "IMAGE_SCN_CNT_INITIALIZED_DATA", "|", "COFF", "::", "IMAGE_SCN_MEM_READ", "|", "COFF", "::", "IMAGE_SCN_LNK_COMDAT", ";", "return", "getContext", "(", ")", ".", "getCOFFSection", "(", "\".rdata\"", ",", "Characteristics", ",", "Kind", ",", "COMDATSymName", ",", "COFF", "::", "IMAGE_COMDAT_SELECT_ANY", ")", ";", "}", "}", "}", "return", "TargetLoweringObjectFile", "::", "getSectionForConstant", "(", "Kind", ",", "C", ")", ";", "}", "</s>" ]

[ "Given", "a", "constant", "with", "the", "SectionKind", ",", "return", "a", "section", "that", "it", "should", "be", "placed", "in", "." ]

[ "X86", "X86", "32", "\"__real@\"", "128", "256", "128", "\"__xmm@\"", "\"__ymm@\"", "1", "1", "\".rdata\"" ]

[]

[ "<s>", "bool", "CJGInstrInfo", "::", "analyzeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "&", "TBB", ",", "MachineBasicBlock", "*", "&", "FBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "Cond", ",", "bool", "AllowModify", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugValue", "(", ")", ")", "continue", ";", "if", "(", "!", "isUnpredicatedTerminator", "(", "*", "I", ")", ")", "break", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "return", "true", ";", "if", "(", "I", "->", "getOpcode", "(", ")", "==", "CJG", "::", "JMP", ")", "{", "if", "(", "!", "AllowModify", ")", "{", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "while", "(", "std", "::", "next", "(", "I", ")", "!=", "MBB", ".", "end", "(", ")", ")", "std", "::", "next", "(", "I", ")", "->", "eraseFromParent", "(", ")", ";", "Cond", ".", "clear", "(", ")", ";", "FBB", "=", "nullptr", ";", "if", "(", "MBB", ".", "isLayoutSuccessor", "(", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", ")", "{", "TBB", "=", "nullptr", ";", "I", "->", "eraseFromParent", "(", ")", ";", "I", "=", "MBB", ".", "end", "(", ")", ";", "continue", ";", "}", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "continue", ";", "}", "assert", "(", "I", "->", "getOpcode", "(", ")", "==", "CJG", "::", "JCC", "&&", "\"Invalid conditional branch\"", ")", ";", "CJGCC", "::", "CondCodes", "BranchCode", "=", "static_cast", "<", "CJGCC", "::", "CondCodes", ">", "(", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "BranchCode", "==", "CJGCC", "::", "COND_INVALID", ")", "return", "true", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "FBB", "=", "TBB", ";", "TBB", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ";", "Cond", ".", "push_back", "(", "MachineOperand", "::", "CreateImm", "(", "BranchCode", ")", ")", ";", "continue", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "1", ")", ";", "assert", "(", "TBB", ")", ";", "if", "(", "TBB", "!=", "I", "->", "getOperand", "(", "0", ")", ".", "getMBB", "(", ")", ")", "return", "true", ";", "CJGCC", "::", "CondCodes", "OldBranchCode", "=", "(", "CJGCC", "::", "CondCodes", ")", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ";", "if", "(", "OldBranchCode", "==", "BranchCode", ")", "continue", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeBranch", "-", "Analyze", "the", "branching", "code", "at", "the", "end", "of", "MBB", ",", "returning", "true", "if", "it", "can", "not", "be", "understood", "(", "e.g", "." ]

[ "CJG", "CJG", "CJG::JMP", "0", "0", "0", "CJG::JCC", "\"Invalid conditional branch\"", "CJGCC::CondCodes", "CJGCC::CondCodes", "1", "CJGCC::COND_INVALID", "0", "1", "0", "CJGCC::CondCodes", "CJGCC::CondCodes", "0" ]

[]

[ "<s>", "static", "inline", "int", "addsubcosts", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "REG", "||", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "SUBREG", ")", "return", "1", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "CONST_OK_FOR_ADD", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "1", ";", "if", "(", "TARGET_SHMEDIA", ")", "switch", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "{", "case", "CONST", ":", "case", "LABEL_REF", ":", "case", "SYMBOL_REF", ":", "return", "TARGET_SHMEDIA64", "?", "5", ":", "3", ";", "case", "CONST_INT", ":", "if", "(", "CONST_OK_FOR_I16", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "2", ";", "else", "if", "(", "CONST_OK_FOR_I16", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">>", "16", ")", ")", "return", "3", ";", "else", "if", "(", "CONST_OK_FOR_I16", "(", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ">>", "16", ")", ">>", "16", ")", ")", "return", "4", ";", "default", ":", "return", "5", ";", "}", "return", "3", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "an", "addition", "or", "a", "subtraction", "." ]

[ "sh", "1", "1", "1", "1", "1", "1", "1", "5", "3", "1", "2", "1", "16", "3", "1", "16", "16", "4", "5", "3" ]

[]

[ "<s>", "bool", "NVPTXTargetLowering", "::", "isLegalAddressingMode", "(", "const", "DataLayout", "&", "DL", ",", "const", "AddrMode", "&", "AM", ",", "Type", "*", "Ty", ",", "unsigned", "AS", ",", "Instruction", "*", "I", ")", "const", "{", "if", "(", "AM", ".", "BaseGV", ")", "{", "return", "!", "AM", ".", "BaseOffs", "&&", "!", "AM", ".", "HasBaseReg", "&&", "!", "AM", ".", "Scale", ";", "}", "switch", "(", "AM", ".", "Scale", ")", "{", "case", "0", ":", "break", ";", "case", "1", ":", "if", "(", "AM", ".", "HasBaseReg", ")", "return", "false", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "isLegalAddressingMode", "-", "Return", "true", "if", "the", "addressing", "mode", "represented", "by", "AM", "is", "legal", "for", "this", "target", ",", "for", "a", "load/store", "of", "the", "specified", "type", "." ]

[ "NVPTX", "NVPTX", "0", "1" ]

[]

[ "<s>", "unsigned", "int", "remove", "(", "void", ")", "{", "unsigned", "int", "cnt", "=", "Removables", ".", "size", "(", ")", ";", "for", "(", "std", "::", "set", "<", "MachineInstr", "*", ">", "::", "iterator", "I", "=", "Removables", ".", "begin", "(", ")", ",", "E", "=", "Removables", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" \"", "<<", "*", "*", "I", ")", ";", "(", "*", "I", ")", "->", "eraseFromParent", "(", ")", ";", "}", "Removables", ".", "clear", "(", ")", ";", "return", "cnt", ";", "}", "</s>" ]

[ "remove", "-", "Remove", "the", "specified", "key/value", "pair", "from", "the", "map", ",", "but", "do", "not", "erase", "it", "." ]

[ "Patmos", "\" \"" ]

[]

[ "<s>", "static", "bool", "aarch64_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "if", "(", "regno", "==", "R0_REGNUM", "||", "regno", "==", "R1_REGNUM", ")", "return", "true", ";", "if", "(", "regno", ">=", "V0_REGNUM", "&&", "regno", "<", "V0_REGNUM", "+", "HA_MAX_NUM_FLDS", ")", "return", "TARGET_FLOAT", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "TARGET_FUNCTION_VALUE_REGNO_P", ".", "Return", "true", "if", "REGNO", "is", "the", "number", "of", "a", "hard", "register", "in", "which", "the", "values", "of", "called", "function", "may", "come", "back", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "isTarget64BitLP64", "(", ")", "const", "{", "return", "In64BitMode", "&&", "(", "!", "TargetTriple", ".", "isX32", "(", ")", "&&", "!", "TargetTriple", ".", "isOSNaCl", "(", ")", ")", ";", "}", "</s>" ]

[ "Is", "this", "x86_64", "with", "the", "LP64", "programming", "model", "(", "standard", "AMD64", ",", "no", "x32", ")", "?" ]

[ "X86" ]

[]

[ "<s>", "bool", "empty", "(", ")", "const", "{", "return", "!", "Bits", ".", "any", "(", ")", ";", "}", "</s>" ]

[ "Determine", "whether", "this", "version", "information", "is", "empty", "(", "e.g.", ",", "all", "version", "components", "are", "zero", ")", "." ]

[ "Hexagon" ]

[]

[ "<s>", "rtx", "unicosmk_add_call_info_word", "(", "rtx", "x", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Add", "a", "call", "information", "word", "(", "CIW", ")", "to", "the", "list", "of", "the", "current", "function", "'s", "CIWs", "and", "return", "its", "index", ".", "X", "is", "a", "CONST_INT", "or", "CONST_DOUBLE", "representing", "the", "CIW", "." ]

[ "alpha" ]

[]

[ "<s>", "static", "rtx", "rl78_lo16", "(", "rtx", "addr", ")", "{", "rtx", "r", ";", "if", "(", "GET_CODE", "(", "addr", ")", "==", "SYMBOL_REF", "||", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "{", "r", "=", "gen_rtx_ZERO_EXTRACT", "(", "HImode", ",", "addr", ",", "GEN_INT", "(", "16", ")", ",", "GEN_INT", "(", "0", ")", ")", ";", "r", "=", "gen_rtx_CONST", "(", "HImode", ",", "r", ")", ";", "}", "else", "r", "=", "rl78_subreg", "(", "HImode", ",", "addr", ",", "SImode", ",", "0", ")", ";", "r", "=", "gen_es_addr", "(", "r", ")", ";", "cfun", "->", "machine", "->", "uses_es", "=", "true", ";", "return", "r", ";", "}", "</s>" ]

[ "Return", "a", "suitable", "RTX", "for", "the", "low", "half", "of", "a", "__far", "address", "." ]

[ "rl78", "16", "0", "0" ]

[]

[ "<s>", "bool", "arm_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "if", "(", "TARGET_NEON", "&&", "(", "mode", "==", "V2SFmode", "||", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", "||", "mode", "==", "V4HFmode", "||", "mode", "==", "V16QImode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V2DImode", "||", "mode", "==", "V8HFmode", "||", "mode", "==", "V4BFmode", "||", "mode", "==", "V8BFmode", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_NEON", "||", "TARGET_IWMMXT", ")", "&&", "(", "(", "mode", "==", "V2SImode", ")", "||", "(", "mode", "==", "V4HImode", ")", "||", "(", "mode", "==", "V8QImode", ")", ")", ")", "return", "true", ";", "if", "(", "TARGET_INT_SIMD", "&&", "(", "mode", "==", "V4UQQmode", "||", "mode", "==", "V4QQmode", "||", "mode", "==", "V2UHQmode", "||", "mode", "==", "V2HQmode", "||", "mode", "==", "V2UHAmode", "||", "mode", "==", "V2HAmode", ")", ")", "return", "true", ";", "if", "(", "TARGET_HAVE_MVE", "&&", "(", "mode", "==", "V2DImode", "||", "mode", "==", "V4SImode", "||", "mode", "==", "V8HImode", "||", "mode", "==", "V16QImode", "||", "mode", "==", "V16BImode", "||", "mode", "==", "V8BImode", "||", "mode", "==", "V4BImode", ")", ")", "return", "true", ";", "if", "(", "TARGET_HAVE_MVE_FLOAT", "&&", "(", "mode", "==", "V2DFmode", "||", "mode", "==", "V4SFmode", "||", "mode", "==", "V8HFmode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Implements", "target", "hook", "vector_mode_supported_p", "." ]

[ "arm" ]

[]

[ "<s>", "static", "const", "char", "*", "sparc_mangle_type", "(", "const_tree", "type", ")", "{", "if", "(", "TARGET_ARCH32", "&&", "TYPE_MAIN_VARIANT", "(", "type", ")", "==", "long_double_type_node", "&&", "TARGET_LONG_DOUBLE_128", ")", "return", "\"g\"", ";", "return", "NULL", ";", "}", "</s>" ]

[ "Implement", "TARGET_MANGLE_TYPE", "." ]

[ "sparc", "\"g\"" ]

[]

[ "<s>", "bool", "AArch64BranchRelaxation", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "if", "(", "!", "BranchRelaxation", ")", "return", "false", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"***** AArch64BranchRelaxation *****\\n\"", ")", ";", "TII", "=", "(", "const", "AArch64InstrInfo", "*", ")", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MF", "->", "RenumberBlocks", "(", ")", ";", "scanFunction", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks before relaxation\\n\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "bool", "MadeChange", "=", "false", ";", "while", "(", "relaxBranchInstructions", "(", ")", ")", "MadeChange", "=", "true", ";", "verify", "(", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\" Basic blocks after relaxation\\n\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "'\\n'", ";", "dumpBBs", "(", ")", ")", ";", "BlockInfo", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AArch64", "AArch64", "\"***** AArch64BranchRelaxation *****\\n\"", "AArch64", "\" Basic blocks before relaxation\\n\"", "\" Basic blocks after relaxation\\n\"" ]

[]

[ "<s>", "int", "neon_immediate_valid_for_shift", "(", "rtx", "op", ",", "machine_mode", "mode", ",", "rtx", "*", "modconst", ",", "int", "*", "elementwidth", ",", "bool", "isleftshift", ")", "{", "unsigned", "int", "innersize", "=", "GET_MODE_UNIT_SIZE", "(", "mode", ")", ";", "unsigned", "int", "n_elts", "=", "CONST_VECTOR_NUNITS", "(", "op", ")", ",", "i", ";", "unsigned", "HOST_WIDE_INT", "last_elt", "=", "0", ";", "unsigned", "HOST_WIDE_INT", "maxshift", ";", "for", "(", "i", "=", "0", ";", "i", "<", "n_elts", ";", "i", "++", ")", "{", "rtx", "el", "=", "CONST_VECTOR_ELT", "(", "op", ",", "i", ")", ";", "unsigned", "HOST_WIDE_INT", "elpart", ";", "if", "(", "CONST_INT_P", "(", "el", ")", ")", "elpart", "=", "INTVAL", "(", "el", ")", ";", "else", "if", "(", "CONST_DOUBLE_P", "(", "el", ")", ")", "return", "0", ";", "else", "gcc_unreachable", "(", ")", ";", "if", "(", "i", "!=", "0", "&&", "elpart", "!=", "last_elt", ")", "return", "0", ";", "last_elt", "=", "elpart", ";", "}", "maxshift", "=", "innersize", "*", "8", ";", "if", "(", "isleftshift", ")", "{", "if", "(", "last_elt", ">=", "maxshift", ")", "return", "0", ";", "}", "else", "{", "if", "(", "last_elt", "==", "0", "||", "last_elt", ">", "maxshift", ")", "return", "0", ";", "}", "if", "(", "elementwidth", ")", "*", "elementwidth", "=", "innersize", "*", "8", ";", "if", "(", "modconst", ")", "*", "modconst", "=", "CONST_VECTOR_ELT", "(", "op", ",", "0", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "rtx", "OP", "is", "legal", "for", "use", "in", "a", "VSHR", "or", "VSHL", "instruction", ".", "If", "the", "immediate", "is", "valid", ",", "write", "a", "constant", "suitable", "for", "using", "as", "an", "operand", "to", "VSHR/VSHL", "to", "*", "MODCONST", "and", "the", "corresponding", "element", "width", "to", "*", "ELEMENTWIDTH", ".", "ISLEFTSHIFT", "is", "for", "determine", "left", "or", "right", "shift", ",", "because", "they", "have", "different", "limitations", "." ]

[ "arm", "0", "0", "0", "0", "0", "8", "0", "0", "0", "8", "0", "1" ]

[]

[ "<s>", "bool", "SparcFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addGlobalInstructionSelect", "(", ")", "{", "addPass", "(", "new", "InstructionSelect", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "(", "global", ")", "instruction", "selector", "pass", ",", "which", "converts", "possibly", "generic", "instructions", "to", "fully", "target-specific", "instructions", ",", "thereby", "constraining", "all", "generic", "virtual", "registers", "to", "register", "classes", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "setRoot", "(", "CostLeaf", "*", "val", ")", "{", "Root", "=", "val", ";", "}", "</s>" ]

[ "Set", "the", "current", "root", "tag", "of", "the", "SelectionDAG", "." ]

[ "TPC" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "override", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "ST", "->", "hasHardClauses", "(", ")", ")", "return", "false", ";", "const", "SIInstrInfo", "*", "SII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "const", "TargetRegisterInfo", "*", "TRI", "=", "ST", "->", "getRegisterInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "ClauseInfo", "CI", ";", "for", "(", "auto", "&", "MI", ":", "MBB", ")", "{", "HardClauseType", "Type", "=", "getHardClauseType", "(", "MI", ")", ";", "int64_t", "Dummy1", ";", "bool", "Dummy2", ";", "unsigned", "Dummy3", ";", "SmallVector", "<", "const", "MachineOperand", "*", ",", "4", ">", "BaseOps", ";", "if", "(", "Type", "<=", "LAST_REAL_HARDCLAUSE_TYPE", ")", "{", "if", "(", "!", "SII", "->", "getMemOperandsWithOffsetWidth", "(", "MI", ",", "BaseOps", ",", "Dummy1", ",", "Dummy2", ",", "Dummy3", ",", "TRI", ")", ")", "{", "Type", "=", "HARDCLAUSE_ILLEGAL", ";", "}", "}", "if", "(", "CI", ".", "Length", "==", "64", "||", "(", "CI", ".", "Length", "&&", "Type", "!=", "HARDCLAUSE_INTERNAL", "&&", "(", "Type", "!=", "CI", ".", "Type", "||", "!", "SII", "->", "shouldClusterMemOps", "(", "CI", ".", "BaseOps", ",", "BaseOps", ",", "2", ",", "2", ")", ")", ")", ")", "{", "Changed", "|=", "emitClause", "(", "CI", ",", "SII", ")", ";", "CI", "=", "ClauseInfo", "(", ")", ";", "}", "if", "(", "CI", ".", "Length", ")", "{", "++", "CI", ".", "Length", ";", "if", "(", "Type", "!=", "HARDCLAUSE_INTERNAL", ")", "{", "CI", ".", "Last", "=", "&", "MI", ";", "CI", ".", "BaseOps", "=", "std", "::", "move", "(", "BaseOps", ")", ";", "}", "}", "else", "if", "(", "Type", "<=", "LAST_REAL_HARDCLAUSE_TYPE", ")", "{", "CI", "=", "ClauseInfo", "{", "Type", ",", "&", "MI", ",", "&", "MI", ",", "1", ",", "std", "::", "move", "(", "BaseOps", ")", "}", ";", "}", "}", "if", "(", "CI", ".", "Length", ")", "Changed", "|=", "emitClause", "(", "CI", ",", "SII", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AMDGPU", "SI", "SI", "4", "SI", "64", "SI", "2", "2", "SI", "1", "SI" ]

[]

[ "<s>", "TargetPassConfig", "*", "XCoreTargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "XCorePassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "XCore", "XCore", "XCore" ]

[]

[ "<s>", "const", "uint32_t", "*", "TOYRegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", ")", "const", "{", "return", "CC_Save_RegMask", ";", "}", "</s>" ]

[ "Return", "a", "mask", "of", "call-preserved", "registers", "for", "the", "given", "calling", "convention", "on", "the", "current", "function", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "void", "arm_options_perform_arch_sanity_checks", "(", "void", ")", "{", "if", "(", "TARGET_INTERWORK", ")", "arm_cpp_interwork", "=", "1", ";", "if", "(", "arm_arch5t", ")", "target_flags", "&=", "~", "MASK_INTERWORK", ";", "if", "(", "TARGET_IWMMXT", "&&", "!", "ARM_DOUBLEWORD_ALIGN", ")", "error", "(", "\"iwmmxt requires an AAPCS compatible ABI for proper operation\"", ")", ";", "if", "(", "TARGET_IWMMXT_ABI", "&&", "!", "TARGET_IWMMXT", ")", "error", "(", "\"iwmmxt abi requires an iwmmxt capable cpu\"", ")", ";", "if", "(", "TARGET_INTERWORK", "&&", "!", "TARGET_BPABI", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_thumb", ")", ")", "{", "warning", "(", "0", ",", "\"target CPU does not support interworking\"", ")", ";", "target_flags", "&=", "~", "MASK_INTERWORK", ";", "}", "if", "(", "TARGET_SOFT_FLOAT", ")", "arm_fpu_attr", "=", "FPU_NONE", ";", "else", "arm_fpu_attr", "=", "FPU_VFP", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "if", "(", "TARGET_CALLER_INTERWORKING", ")", "error", "(", "\"AAPCS does not support %<-mcaller-super-interworking%>\"", ")", ";", "else", "if", "(", "TARGET_CALLEE_INTERWORKING", ")", "error", "(", "\"AAPCS does not support %<-mcallee-super-interworking%>\"", ")", ";", "}", "if", "(", "!", "arm_arch4", "&&", "arm_fp16_format", "!=", "ARM_FP16_FORMAT_NONE", ")", "sorry", "(", "\"__fp16 and no ldrh\"", ")", ";", "if", "(", "use_cmse", "&&", "!", "arm_arch_cmse", ")", "error", "(", "\"target CPU does not support ARMv8-M Security Extensions\"", ")", ";", "if", "(", "use_cmse", "&&", "TARGET_HARD_FLOAT", "&&", "LAST_VFP_REGNUM", ">", "LAST_LO_VFP_REGNUM", ")", "error", "(", "\"ARMv8-M Security Extensions incompatible with selected FPU\"", ")", ";", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "if", "(", "arm_abi", "==", "ARM_ABI_IWMMXT", ")", "arm_pcs_default", "=", "ARM_PCS_AAPCS_IWMMXT", ";", "else", "if", "(", "TARGET_HARD_FLOAT_ABI", ")", "{", "arm_pcs_default", "=", "ARM_PCS_AAPCS_VFP", ";", "if", "(", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_vfpv2", ")", "&&", "!", "bitmap_bit_p", "(", "arm_active_target", ".", "isa", ",", "isa_bit_mve", ")", ")", "error", "(", "\"%<-mfloat-abi=hard%>: selected architecture lacks an FPU\"", ")", ";", "}", "else", "arm_pcs_default", "=", "ARM_PCS_AAPCS", ";", "}", "else", "{", "if", "(", "arm_float_abi", "==", "ARM_FLOAT_ABI_HARD", ")", "sorry", "(", "\"%<-mfloat-abi=hard%> and VFP\"", ")", ";", "if", "(", "arm_abi", "==", "ARM_ABI_APCS", ")", "arm_pcs_default", "=", "ARM_PCS_APCS", ";", "else", "arm_pcs_default", "=", "ARM_PCS_ATPCS", ";", "}", "}", "</s>" ]

[ "Perform", "some", "validation", "between", "the", "desired", "architecture", "and", "the", "rest", "of", "the", "options", "." ]

[ "arm", "1", "\"iwmmxt requires an AAPCS compatible ABI for proper operation\"", "\"iwmmxt abi requires an iwmmxt capable cpu\"", "0", "\"target CPU does not support interworking\"", "\"AAPCS does not support %<-mcaller-super-interworking%>\"", "\"AAPCS does not support %<-mcallee-super-interworking%>\"", "\"__fp16 and no ldrh\"", "\"target CPU does not support ARMv8-M Security Extensions\"", "\"ARMv8-M Security Extensions incompatible with selected FPU\"", "\"%<-mfloat-abi=hard%>: selected architecture lacks an FPU\"", "\"%<-mfloat-abi=hard%> and VFP\"" ]

[]

[ "<s>", "bool", "nios2_emit_move_sequence", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "to", "=", "operands", "[", "0", "]", ";", "rtx", "from", "=", "operands", "[", "1", "]", ";", "if", "(", "!", "register_operand", "(", "to", ",", "mode", ")", "&&", "!", "reg_or_0_operand", "(", "from", ",", "mode", ")", ")", "{", "gcc_assert", "(", "can_create_pseudo_p", "(", ")", ")", ";", "from", "=", "copy_to_mode_reg", "(", "mode", ",", "from", ")", ";", "}", "if", "(", "CONSTANT_P", "(", "from", ")", ")", "{", "if", "(", "CONST_INT_P", "(", "from", ")", ")", "{", "if", "(", "!", "SMALL_INT", "(", "INTVAL", "(", "from", ")", ")", "&&", "!", "SMALL_INT_UNSIGNED", "(", "INTVAL", "(", "from", ")", ")", "&&", "!", "UPPER16_INT", "(", "INTVAL", "(", "from", ")", ")", ")", "{", "HOST_WIDE_INT", "high", "=", "(", "INTVAL", "(", "from", ")", "+", "0x8000", ")", "&", "~", "0xffff", ";", "HOST_WIDE_INT", "low", "=", "INTVAL", "(", "from", ")", "&", "0xffff", ";", "emit_move_insn", "(", "to", ",", "gen_int_mode", "(", "high", ",", "SImode", ")", ")", ";", "emit_insn", "(", "gen_add2_insn", "(", "to", ",", "gen_int_mode", "(", "low", ",", "HImode", ")", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "from", ")", ")", ";", "return", "true", ";", "}", "}", "else", "if", "(", "gprel_constant_p", "(", "from", ")", "||", "r0rel_constant_p", "(", "from", ")", ")", ";", "else", "if", "(", "nios2_large_constant_p", "(", "from", ")", ")", "{", "if", "(", "!", "nios2_large_constant_allowed", "(", ")", "||", "nios2_large_unspec_reloc_p", "(", "from", ")", ")", "{", "rtx", "lo", "=", "nios2_split_large_constant", "(", "from", ",", "to", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "lo", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "operands", "[", "1", "]", ")", ")", ";", "return", "true", ";", "}", "}", "else", "{", "from", "=", "nios2_legitimize_constant_address", "(", "from", ")", ";", "if", "(", "CONSTANT_P", "(", "from", ")", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "gen_rtx_HIGH", "(", "Pmode", ",", "copy_rtx", "(", "from", ")", ")", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "to", ",", "gen_rtx_LO_SUM", "(", "Pmode", ",", "to", ",", "from", ")", ")", ")", ";", "set_unique_reg_note", "(", "get_last_insn", "(", ")", ",", "REG_EQUAL", ",", "copy_rtx", "(", "operands", "[", "1", "]", ")", ")", ";", "return", "true", ";", "}", "}", "}", "operands", "[", "0", "]", "=", "to", ";", "operands", "[", "1", "]", "=", "from", ";", "return", "false", ";", "}", "</s>" ]

[ "Main", "expander", "function", "for", "RTL", "moves", "." ]

[ "nios2", "0", "1", "0x8000", "0xffff", "0xffff", "1", "1", "0", "1" ]

[]

[ "<s>", "TargetPassConfig", "*", "X86TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "X86PassConfig", "*", "PC", "=", "new", "X86PassConfig", "(", "this", ",", "PM", ")", ";", "if", "(", "X86EarlyIfConv", "&&", "Subtarget", ".", "hasCMov", "(", ")", ")", "PC", "->", "enablePass", "(", "&", "EarlyIfConverterID", ")", ";", "return", "PC", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "bool", "ARMAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'a'", ":", "if", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isReg", "(", ")", ")", "{", "O", "<<", "\"[\"", "<<", "getRegisterName", "(", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "getReg", "(", ")", ")", "<<", "\"]\"", ";", "return", "false", ";", "}", "case", "'c'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isImm", "(", ")", ")", "return", "true", ";", "printNoHashImmediate", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'P'", ":", "case", "'q'", ":", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'Q'", ":", "if", "(", "TM", ".", "getTargetData", "(", ")", "->", "isLittleEndian", "(", ")", ")", "break", ";", "case", "'R'", ":", "if", "(", "TM", ".", "getTargetData", "(", ")", "->", "isBigEndian", "(", ")", ")", "break", ";", "case", "'H'", ":", "if", "(", "!", "MI", "->", "getOperand", "(", "OpNum", ")", ".", "isReg", "(", ")", "||", "OpNum", "+", "1", "==", "MI", "->", "getNumOperands", "(", ")", "||", "!", "MI", "->", "getOperand", "(", "OpNum", "+", "1", ")", ".", "isReg", "(", ")", ")", "return", "true", ";", "++", "OpNum", ";", "}", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "PrintAsmOperand", "-", "Print", "out", "an", "operand", "for", "an", "inline", "asm", "expression", "." ]

[ "ARM", "ARM", "0", "1", "0", "0", "\"[\"", "\"]\"", "1", "1" ]

[]

[ "<s>", "static", "void", "csky_conditional_register_usage", "(", "void", ")", "{", "if", "(", "TARGET_MINI_REGISTERS", ")", "{", "int", "i", ";", "for", "(", "i", "=", "(", "CSKY_LAST_MINI_REGNUM", "+", "1", ")", ";", "i", "<", "32", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "else", "if", "(", "CSKY_TARGET_ARCH", "(", "CK802", ")", "||", "CSKY_TARGET_ARCH", "(", "CK803", ")", "||", "!", "TARGET_HIGH_REGISTERS", ")", "{", "int", "i", ";", "for", "(", "i", "=", "CSKY_FIRST_HIGH_REGNUM", ";", "i", "<=", "CSKY_LAST_HIGH_REGNUM", ";", "i", "++", ")", "{", "fixed_regs", "[", "i", "]", "=", "1", ";", "call_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "if", "(", "CSKY_TARGET_ARCH", "(", "CK801", ")", "||", "CSKY_TARGET_ARCH", "(", "CK802", ")", ")", "{", "fixed_regs", "[", "CSKY_LR_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "CSKY_LR_REGNUM", "]", "=", "1", ";", "call_really_used_regs", "[", "CSKY_LR_REGNUM", "]", "=", "0", ";", "}", "if", "(", "!", "TARGET_DSP", ")", "{", "fixed_regs", "[", "CSKY_HI_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "CSKY_HI_REGNUM", "]", "=", "1", ";", "call_really_used_regs", "[", "CSKY_HI_REGNUM", "]", "=", "1", ";", "fixed_regs", "[", "CSKY_LO_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "CSKY_LO_REGNUM", "]", "=", "1", ";", "call_really_used_regs", "[", "CSKY_LO_REGNUM", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "int", "regno", ";", "for", "(", "regno", "=", "CSKY_FIRST_VFP_REGNUM", ";", "regno", "<=", "CSKY_LAST_VFP_REGNUM", ";", "regno", "++", ")", "{", "fixed_regs", "[", "regno", "]", "=", "1", ";", "call_used_regs", "[", "regno", "]", "=", "1", ";", "call_really_used_regs", "[", "regno", "]", "=", "1", ";", "}", "}", "if", "(", "flag_pic", ")", "{", "fixed_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "call_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "call_really_used_regs", "[", "PIC_OFFSET_TABLE_REGNUM", "]", "=", "0", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_CONDITIONAL_REGISTER_USAGE", ".", "Conditionally", "modify", "five", "variables", "fixed_regs", ",", "call_used_regs", ",", "global_regs", ",", "reg_names", ",", "and", "reg_class_contents", ",", "to", "take", "into", "account", "any", "dependence", "of", "these", "register", "sets", "on", "target", "flags", ".", "CK801", "has", "registers", "r0-r8", "and", "r13-r15", ".", "CK802", "and", "CK803", "have", "registers", "r0-r15", "(", "the", "``", "low", "''", "registers", ")", ".", "Other", "cpus", "use", "registers", "r0-r31", "with", "-mhigh-registers", ",", "otherwise", "also", "only", "r0-r15", ".", "CK801", "only", "has", "16-bit", "instructions", ",", "most", "of", "which", "can", "only", "reference", "r0-r7", "(", "the", "``", "mini", "''", "registers", ")", ".", "So", "we", "mark", "regs", "outside", "that", "range", "as", "fixed", ".", "-msmart", "can", "be", "used", "on", "other", "arch", "variants", "to", "force", "the", "same", "behavior", "because", "it", "results", "in", "smaller", "code", "size", ".", "TODO", ":", "investigate", "whether", "it", "'s", "beneficial", "to", "use", "r8-r13", "as", "a", "spill", "class", "when", "TARGET_MINI_REGISTERS", "instead", "of", "making", "them", "unusable", "by", "the", "register", "allocator", "." ]

[ "csky", "1", "32", "1", "1", "1", "1", "1", "1", "1", "1", "0", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "rtx", "arm_stack_protect_tls_canary_mem", "(", "bool", "reload", ")", "{", "rtx", "tp", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "reload", ")", "emit_insn", "(", "gen_reload_tp_hard", "(", "tp", ")", ")", ";", "else", "emit_insn", "(", "gen_load_tp_hard", "(", "tp", ")", ")", ";", "rtx", "reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "offset", "=", "GEN_INT", "(", "arm_stack_protector_guard_offset", ")", ";", "emit_set_insn", "(", "reg", ",", "gen_rtx_PLUS", "(", "SImode", ",", "tp", ",", "offset", ")", ")", ";", "return", "gen_rtx_MEM", "(", "SImode", ",", "reg", ")", ";", "}", "</s>" ]

[ "Generate", "insns", "that", "produce", "the", "address", "of", "the", "stack", "canary" ]

[ "arm" ]

[]

[ "<s>", "void", "XCoreRegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "assert", "(", "SPAdj", "==", "0", "&&", "\"Unexpected\"", ")", ";", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineOperand", "&", "FrameOp", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "int", "FrameIndex", "=", "FrameOp", ".", "getIndex", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "XCoreInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "XCoreInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getTarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "int", "StackSize", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"\\nFunction : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"<--------->\\n\"", ")", ";", "DEBUG", "(", "MI", ".", "print", "(", "errs", "(", ")", ")", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameIndex : \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"FrameOffset : \"", "<<", "Offset", "<<", "\"\\n\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"StackSize : \"", "<<", "StackSize", "<<", "\"\\n\"", ")", ";", "Offset", "+=", "StackSize", ";", "unsigned", "FrameReg", "=", "getFrameRegister", "(", "MF", ")", ";", "if", "(", "MI", ".", "isDebugValue", "(", ")", ")", "{", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "FrameReg", ",", "false", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "0", ")", ";", "assert", "(", "Offset", "%", "4", "==", "0", "&&", "\"Misaligned stack offset\"", ")", ";", "DEBUG", "(", "errs", "(", ")", "<<", "\"Offset : \"", "<<", "Offset", "<<", "\"\\n\"", "<<", "\"<--------->\\n\"", ")", ";", "Offset", "/=", "4", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "assert", "(", "XCore", "::", "GRRegsRegClass", ".", "contains", "(", "Reg", ")", "&&", "\"Unexpected register operand\"", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "if", "(", "isImmUs", "(", "Offset", ")", ")", "InsertFPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ")", ";", "else", "InsertFPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "FrameReg", ",", "Offset", ",", "RS", ")", ";", "}", "else", "{", "if", "(", "isImmU16", "(", "Offset", ")", ")", "InsertSPImmInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ")", ";", "else", "InsertSPConstInst", "(", "II", ",", "TII", ",", "Reg", ",", "Offset", ",", "RS", ")", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MBB", ".", "erase", "(", "II", ")", ";", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "XCore", "XCore", "0", "\"Unexpected\"", "XCore", "XCore", "\"\\nFunction : \"", "\"\\n\"", "\"<--------->\\n\"", "\"FrameIndex : \"", "\"\\n\"", "\"FrameOffset : \"", "\"\\n\"", "\"StackSize : \"", "\"\\n\"", "1", "1", "1", "0", "4", "0", "\"Misaligned stack offset\"", "\"Offset : \"", "\"\\n\"", "\"<--------->\\n\"", "4", "0", "XCore::GRRegsRegClass", "\"Unexpected register operand\"" ]

[]

[ "<s>", "void", "TOYInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TOY", "::", "STORErr", ")", ")", ".", "addReg", "(", "SrcReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addReg", "(", "TOY", "::", "ZERO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "TOY", "TOY", "TOY::STORErr", "TOY::ZERO" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FI", "!=", "FE", ";", "++", "FI", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ")", ";", "return", "Changed", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "IA64" ]

[]

[ "<s>", "std", "::", "pair", "<", "unsigned", ",", "const", "TargetRegisterClass", "*", ">", "ARMTargetLowering", "::", "getRegForInlineAsmConstraint", "(", "const", "std", "::", "string", "&", "Constraint", ",", "MVT", "VT", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'l'", ":", "case", "'r'", ":", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "GPRRegisterClass", ")", ";", "case", "'w'", ":", "if", "(", "VT", "==", "MVT", "::", "f32", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "SPRRegisterClass", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f64", ")", "return", "std", "::", "make_pair", "(", "0U", ",", "ARM", "::", "DPRRegisterClass", ")", ";", "break", ";", "}", "}", "return", "TargetLowering", "::", "getRegForInlineAsmConstraint", "(", "Constraint", ",", "VT", ")", ";", "}", "</s>" ]

[ "Given", "a", "physical", "register", "constraint", "(", "e.g", "." ]

[ "ARM", "ARM", "1", "0", "0U", "ARM::GPRRegisterClass", "MVT::f32", "0U", "ARM::SPRRegisterClass", "MVT::f64", "0U", "ARM::DPRRegisterClass" ]

[]

[ "<s>", "bool", "WebAssemblyPassConfig", "::", "addInstSelector", "(", ")", "{", "(", "void", ")", "TargetPassConfig", "::", "addInstSelector", "(", ")", ";", "addPass", "(", "createWebAssemblyISelDag", "(", "getWebAssemblyTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "addPass", "(", "createWebAssemblyArgumentMove", "(", ")", ")", ";", "addPass", "(", "createWebAssemblySetP2AlignOperands", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "static", "bool", "classof", "(", "const", "VEMCExpr", "*", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Methods", "for", "support", "type", "inquiry", "through", "isa", ",", "cast", ",", "and", "dyn_cast", ":" ]

[ "VE", "VE" ]

[]

[ "<s>", "unsigned", "HexagonTTIImpl", "::", "getNumberOfRegisters", "(", "bool", "Vector", ")", "const", "{", "if", "(", "Vector", ")", "return", "useHVX", "(", ")", "?", "32", ":", "0", ";", "return", "32", ";", "}", "</s>" ]

[ "�", "?", "Vector", "TTI", "begin", "�", "?" ]

[ "Hexagon", "Hexagon", "32", "0", "32" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "getPartialRegUpdateClearance", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "OpNum", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "OpNum", "!=", "0", "||", "!", "hasPartialRegUpdate", "(", "MI", ".", "getOpcode", "(", ")", ",", "Subtarget", ")", ")", "return", "0", ";", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "Reg", ".", "isVirtual", "(", ")", ")", "{", "if", "(", "MO", ".", "readsReg", "(", ")", "||", "MI", ".", "readsVirtualRegister", "(", "Reg", ")", ")", "return", "0", ";", "}", "else", "{", "if", "(", "MI", ".", "readsRegister", "(", "Reg", ",", "TRI", ")", ")", "return", "0", ";", "}", "return", "PartialRegUpdateClearance", ";", "}", "</s>" ]

[ "Inform", "the", "BreakFalseDeps", "pass", "how", "many", "idle", "instructions", "we", "would", "like", "before", "a", "partial", "register", "update", "." ]

[ "X86", "X86", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "SDValue", "WebAssemblyTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "if", "(", "!", "CallingConvSupported", "(", "CallConv", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly doesn't support non-C calling conventions\"", ")", ";", "MachineFunction", "&", "MF", "=", "DAG", ".", "getMachineFunction", "(", ")", ";", "auto", "*", "MFI", "=", "MF", ".", "getInfo", "<", "WebAssemblyFunctionInfo", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "addLiveIn", "(", "WebAssembly", "::", "ARGUMENTS", ")", ";", "for", "(", "const", "ISD", "::", "InputArg", "&", "In", ":", "Ins", ")", "{", "if", "(", "In", ".", "Flags", ".", "isInAlloca", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented inalloca arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isNest", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented nest arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegs", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs arguments\"", ")", ";", "if", "(", "In", ".", "Flags", ".", "isInConsecutiveRegsLast", "(", ")", ")", "fail", "(", "DL", ",", "DAG", ",", "\"WebAssembly hasn't implemented cons regs last arguments\"", ")", ";", "InVals", ".", "push_back", "(", "In", ".", "Used", "?", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "In", ".", "VT", ",", "DAG", ".", "getTargetConstant", "(", "InVals", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ":", "DAG", ".", "getUNDEF", "(", "In", ".", "VT", ")", ")", ";", "MFI", "->", "addParam", "(", "In", ".", "VT", ")", ";", "}", "if", "(", "IsVarArg", ")", "{", "MVT", "PtrVT", "=", "getPointerTy", "(", "MF", ".", "getDataLayout", "(", ")", ")", ";", "unsigned", "VarargVreg", "=", "MF", ".", "getRegInfo", "(", ")", ".", "createVirtualRegister", "(", "getRegClassFor", "(", "PtrVT", ")", ")", ";", "MFI", "->", "setVarargBufferVreg", "(", "VarargVreg", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VarargVreg", ",", "DAG", ".", "getNode", "(", "WebAssemblyISD", "::", "ARGUMENT", ",", "DL", ",", "PtrVT", ",", "DAG", ".", "getTargetConstant", "(", "Ins", ".", "size", "(", ")", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ")", ";", "MFI", "->", "addParam", "(", "PtrVT", ")", ";", "}", "SmallVector", "<", "MVT", ",", "4", ">", "Params", ";", "SmallVector", "<", "MVT", ",", "4", ">", "Results", ";", "ComputeSignatureVTs", "(", "*", "MF", ".", "getFunction", "(", ")", ",", "DAG", ".", "getTarget", "(", ")", ",", "Params", ",", "Results", ")", ";", "for", "(", "MVT", "VT", ":", "Results", ")", "MFI", "->", "addResult", "(", "VT", ")", ";", "return", "Chain", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "WebAssembly", "WebAssembly", "ISD::InputArg", "\"WebAssembly doesn't support non-C calling conventions\"", "WebAssembly", "WebAssembly::ARGUMENTS", "ISD::InputArg", "\"WebAssembly hasn't implemented inalloca arguments\"", "\"WebAssembly hasn't implemented nest arguments\"", "\"WebAssembly hasn't implemented cons regs arguments\"", "\"WebAssembly hasn't implemented cons regs last arguments\"", "WebAssemblyISD::ARGUMENT", "MVT::i32", "WebAssemblyISD::ARGUMENT", "MVT::i32", "4", "4" ]

[]

[ "<s>", "static", "void", "mips_reorg", "(", "void", ")", "{", "if", "(", "TARGET_MIPS16", ")", "mips16_lay_out_constants", "(", ")", ";", "else", "if", "(", "TARGET_EXPLICIT_RELOCS", ")", "{", "if", "(", "mips_flag_delayed_branch", ")", "dbr_schedule", "(", "get_insns", "(", ")", ",", "dump_file", ")", ";", "mips_avoid_hazards", "(", ")", ";", "if", "(", "TUNE_MIPS4130", "&&", "TARGET_VR4130_ALIGN", ")", "vr4130_align_insns", "(", ")", ";", "}", "}", "</s>" ]

[ "Implement", "TARGET_MACHINE_DEPENDENT_REORG", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "detect_l2_cache", "(", "struct", "cache_desc", "*", "level2", ")", "{", "unsigned", "eax", ",", "ebx", ",", "ecx", ",", "edx", ";", "unsigned", "assoc", ";", "__cpuid", "(", "0x80000006", ",", "eax", ",", "ebx", ",", "ecx", ",", "edx", ")", ";", "level2", "->", "sizekb", "=", "(", "ecx", ">>", "16", ")", "&", "0xffff", ";", "level2", "->", "line", "=", "ecx", "&", "0xff", ";", "assoc", "=", "(", "ecx", ">>", "12", ")", "&", "0xf", ";", "if", "(", "assoc", "==", "6", ")", "assoc", "=", "8", ";", "else", "if", "(", "assoc", "==", "8", ")", "assoc", "=", "16", ";", "else", "if", "(", "assoc", ">=", "0xa", "&&", "assoc", "<=", "0xc", ")", "assoc", "=", "32", "+", "(", "assoc", "-", "0xa", ")", "*", "16", ";", "else", "if", "(", "assoc", ">=", "0xd", "&&", "assoc", "<=", "0xe", ")", "assoc", "=", "96", "+", "(", "assoc", "-", "0xd", ")", "*", "32", ";", "level2", "->", "assoc", "=", "assoc", ";", "}", "</s>" ]

[ "Detect", "L2", "cache", "parameters", "using", "CPUID", "extended", "function", "0x80000006", "." ]

[ "i386", "0x80000006", "16", "0xffff", "0xff", "12", "0xf", "6", "8", "8", "16", "0xa", "0xc", "32", "0xa", "16", "0xd", "0xe", "96", "0xd", "32" ]

[]

[ "<s>", "SDValue", "MSP430TargetLowering", "::", "LowerCall", "(", "SDValue", "Chain", ",", "SDValue", "Callee", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "bool", "doesNotRet", ",", "bool", "&", "isTailCall", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "isTailCall", "=", "false", ";", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "Fast", ":", "case", "CallingConv", "::", "C", ":", "return", "LowerCCCCallTo", "(", "Chain", ",", "Callee", ",", "CallConv", ",", "isVarArg", ",", "isTailCall", ",", "Outs", ",", "OutVals", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "case", "CallingConv", "::", "MSP430_INTR", ":", "report_fatal_error", "(", "\"ISRs cannot be called directly\"", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "calls", "into", "the", "specified", "DAG", "." ]

[ "MSP430", "MSP430", "ISD::OutputArg", "ISD::InputArg", "\"Unsupported calling convention\"", "MSP430", "\"ISRs cannot be called directly\"" ]

[]

[ "<s>", "static", "unsigned", "int", "mips_autovectorize_vector_sizes", "(", "void", ")", "{", "return", "ISA_HAS_MSA", "?", "16", ":", "0", ";", "}", "</s>" ]

[ "Implement", "TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES", "." ]

[ "mips", "16", "0" ]

[]

[ "<s>", "static", "unsigned", "getScalarSizeInBits", "(", "Type", "*", "Ty", ")", "{", "unsigned", "Size", "=", "(", "Ty", "->", "isPtrOrPtrVectorTy", "(", ")", "?", "64U", ":", "Ty", "->", "getScalarSizeInBits", "(", ")", ")", ";", "assert", "(", "Size", ">", "0", "&&", "\"Element must have non-zero size.\"", ")", ";", "return", "Size", ";", "}", "</s>" ]

[ "If", "this", "is", "a", "vector", "type", ",", "return", "the", "getPrimitiveSizeInBits", "value", "for", "the", "element", "type", "." ]

[ "SystemZ", "64U", "0", "\"Element must have non-zero size.\"" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "override", "{", "AArch64FI", "=", "F", ".", "getInfo", "<", "AArch64FunctionInfo", ">", "(", ")", ";", "STI", "=", "static_cast", "<", "const", "AArch64Subtarget", "*", ">", "(", "&", "F", ".", "getSubtarget", "(", ")", ")", ";", "return", "AsmPrinter", "::", "runOnMachineFunction", "(", "F", ")", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "MSP430TargetLowering", "::", "isZExtFree", "(", "EVT", "VT1", ",", "EVT", "VT2", ")", "const", "{", "return", "false", "&&", "VT1", "==", "MVT", "::", "i8", "&&", "VT2", "==", "MVT", "::", "i16", ";", "}", "</s>" ]

[ "Return", "true", "if", "zero-extending", "the", "specific", "node", "Val", "to", "type", "VT2", "is", "free", "(", "either", "because", "it", "'s", "implicitly", "zero-extended", "such", "as", "ARM", "ldrb", "/", "ldrh", "or", "because", "it", "'s", "folded", "such", "as", "X86", "zero-extending", "loads", ")", "." ]

[ "MSP430", "MSP430", "MVT::i8", "MVT::i16" ]

[]

[ "<s>", "unsigned", "int", "compute_a_shift_length", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "rtx", "*", "operands", ")", "{", "rtx", "shift", "=", "operands", "[", "3", "]", ";", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "shift", ")", ";", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "shift", ")", ";", "enum", "shift_type", "shift_type", ";", "enum", "shift_mode", "shift_mode", ";", "struct", "shift_info", "info", ";", "unsigned", "int", "wlength", "=", "0", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "shift_mode", "=", "QIshift", ";", "break", ";", "case", "HImode", ":", "shift_mode", "=", "HIshift", ";", "break", ";", "case", "SImode", ":", "shift_mode", "=", "SIshift", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "code", ")", "{", "case", "ASHIFTRT", ":", "shift_type", "=", "SHIFT_ASHIFTRT", ";", "break", ";", "case", "LSHIFTRT", ":", "shift_type", "=", "SHIFT_LSHIFTRT", ";", "break", ";", "case", "ASHIFT", ":", "shift_type", "=", "SHIFT_ASHIFT", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "!=", "CONST_INT", ")", "{", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "1", ",", "&", "info", ")", ";", "return", "(", "4", "+", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", ")", "*", "2", ";", "}", "else", "{", "int", "n", "=", "INTVAL", "(", "operands", "[", "2", "]", ")", ";", "if", "(", "n", "<", "0", ")", "n", "=", "0", ";", "else", "if", "(", "(", "unsigned", "int", ")", "n", ">", "GET_MODE_BITSIZE", "(", "mode", ")", ")", "n", "=", "GET_MODE_BITSIZE", "(", "mode", ")", ";", "get_shift_alg", "(", "shift_type", ",", "shift_mode", ",", "n", ",", "&", "info", ")", ";", "switch", "(", "info", ".", "alg", ")", "{", "case", "SHIFT_SPECIAL", ":", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "special", ")", ";", "if", "(", "strstr", "(", "info", ".", "special", ",", "\"xor.l\"", ")", "!=", "NULL", ")", "wlength", "++", ";", "case", "SHIFT_INLINE", ":", "n", "=", "info", ".", "remainder", ";", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift2", ")", "*", "(", "n", "/", "2", ")", ";", "n", "=", "n", "%", "2", ";", "}", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", "*", "n", ";", "return", "2", "*", "wlength", ";", "case", "SHIFT_ROT_AND", ":", "{", "int", "m", "=", "GET_MODE_BITSIZE", "(", "mode", ")", "-", "n", ";", "gcc_assert", "(", "info", ".", "shift1", ")", ";", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift2", ")", "*", "(", "m", "/", "2", ")", ";", "m", "=", "m", "%", "2", ";", "}", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", "*", "m", ";", "switch", "(", "mode", ")", "{", "case", "QImode", ":", "wlength", "+=", "1", ";", "break", ";", "case", "HImode", ":", "wlength", "+=", "2", ";", "break", ";", "case", "SImode", ":", "gcc_assert", "(", "!", "TARGET_H8300", ")", ";", "wlength", "+=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "2", "*", "wlength", ";", "}", "case", "SHIFT_LOOP", ":", "if", "(", "info", ".", "shift2", "!=", "NULL", ")", "{", "wlength", "+=", "3", "+", "h8300_asm_insn_count", "(", "info", ".", "shift2", ")", ";", "if", "(", "n", "%", "2", ")", "wlength", "+=", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", ";", "}", "else", "{", "wlength", "+=", "3", "+", "h8300_asm_insn_count", "(", "info", ".", "shift1", ")", ";", "}", "return", "2", "*", "wlength", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Compute", "the", "length", "of", "a", "shift", "insn", "." ]

[ "h8300", "3", "0", "2", "1", "4", "2", "2", "0", "0", "\"xor.l\"", "2", "2", "2", "2", "2", "1", "2", "3", "2", "3", "2", "3", "2" ]

[]

[ "<s>", "void", "Reset", "(", ")", "{", "Ops", ".", "clear", "(", ")", ";", "OpBegins", ".", "clear", "(", ")", ";", "OpBegins", ".", "push_back", "(", "0", ")", ";", "HasPersonality", "=", "0", ";", "}", "</s>" ]

[ "Reset", "the", "unwind", "opcode", "assembler", "." ]

[ "ARM", "0", "0" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetPostRAHazardRecognizer", "(", "const", "InstrItineraryData", "*", "II", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "TM", ".", "getSubtarget", "<", "PPCSubtarget", ">", "(", ")", ".", "getDarwinDirective", "(", ")", ";", "if", "(", "Directive", "!=", "PPC", "::", "DIR_440", "&&", "Directive", "!=", "PPC", "::", "DIR_A2", "&&", "Directive", "!=", "PPC", "::", "DIR_E500mc", "&&", "Directive", "!=", "PPC", "::", "DIR_E5500", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "TM", ".", "getInstrInfo", "(", ")", ";", "assert", "(", "TII", "&&", "\"No InstrInfo?\"", ")", ";", "return", "new", "PPCHazardRecognizer970", "(", "*", "TII", ")", ";", "}", "return", "new", "PPCScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "by", "non-scheduling", "passes", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "\"No InstrInfo?\"", "PPC", "PPC" ]

[]

[ "<s>", "static", "void", "s390_regs_ever_clobbered", "(", "char", "regs_ever_clobbered", "[", "]", ")", "{", "basic_block", "cur_bb", ";", "rtx_insn", "*", "cur_insn", ";", "unsigned", "int", "i", ";", "memset", "(", "regs_ever_clobbered", ",", "0", ",", "32", ")", ";", "if", "(", "!", "crtl", "->", "is_leaf", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "regs_ever_clobbered", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", ";", "}", "if", "(", "crtl", "->", "calls_eh_return", "||", "cfun", "->", "machine", "->", "has_landing_pad_p", ")", "for", "(", "i", "=", "0", ";", "EH_RETURN_DATA_REGNO", "(", "i", ")", "!=", "INVALID_REGNUM", ";", "i", "++", ")", "if", "(", "crtl", "->", "calls_eh_return", "||", "(", "cfun", "->", "machine", "->", "has_landing_pad_p", "&&", "df_regs_ever_live_p", "(", "EH_RETURN_DATA_REGNO", "(", "i", ")", ")", ")", ")", "regs_ever_clobbered", "[", "EH_RETURN_DATA_REGNO", "(", "i", ")", "]", "=", "1", ";", "if", "(", "crtl", "->", "saves_all_registers", ")", "for", "(", "i", "=", "0", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "!", "call_used_regs", "[", "i", "]", ")", "regs_ever_clobbered", "[", "i", "]", "=", "1", ";", "FOR_EACH_BB_FN", "(", "cur_bb", ",", "cfun", ")", "{", "FOR_BB_INSNS", "(", "cur_bb", ",", "cur_insn", ")", "{", "rtx", "pat", ";", "if", "(", "!", "INSN_P", "(", "cur_insn", ")", ")", "continue", ";", "pat", "=", "PATTERN", "(", "cur_insn", ")", ";", "if", "(", "epilogue_completed", "&&", "RTX_FRAME_RELATED_P", "(", "cur_insn", ")", ")", "{", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GENERAL_REG_P", "(", "SET_DEST", "(", "pat", ")", ")", ")", "{", "if", "(", "GET_MODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "DImode", "&&", "FP_REG_P", "(", "SET_SRC", "(", "pat", ")", ")", ")", "continue", ";", "if", "(", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "MEM", ")", "continue", ";", "}", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "load_multiple_operation", "(", "pat", ",", "VOIDmode", ")", ")", "continue", ";", "}", "note_stores", "(", "cur_insn", ",", "s390_reg_clobbered_rtx", ",", "regs_ever_clobbered", ")", ";", "}", "}", "}", "</s>" ]

[ "Walks", "through", "all", "basic", "blocks", "of", "the", "current", "function", "looking", "for", "clobbered", "hard", "regs", "using", "s390_reg_clobbered_rtx", ".", "The", "fields", "of", "the", "passed", "integer", "array", "REGS_EVER_CLOBBERED", "are", "set", "to", "one", "for", "each", "of", "those", "regs", "." ]

[ "s390", "0", "32", "0", "32", "0", "1", "0", "32", "1" ]

[]

[ "<s>", "bool", "nds32_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "!", "targetm", ".", "have_tls", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "contains", "a", "thread-local", "symbol", "." ]

[ "nds32", "0", "0", "0" ]

[]

[ "<s>", "bool", "ARMCallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ",", "FunctionLoweringInfo", "&", "FLI", ")", "const", "{", "auto", "&", "TLI", "=", "*", "getTLI", "<", "ARMTargetLowering", ">", "(", ")", ";", "auto", "Subtarget", "=", "TLI", ".", "getSubtarget", "(", ")", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "auto", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "const", "auto", "&", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "!", "isSupportedType", "(", "DL", ",", "TLI", ",", "Arg", ".", "getType", "(", ")", ")", ")", "return", "false", ";", "if", "(", "Arg", ".", "hasPassPointeeByValueCopyAttr", "(", ")", ")", "return", "false", ";", "}", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ";", "OutgoingValueAssigner", "ArgAssigner", "(", "AssignFn", ")", ";", "FormalArgHandler", "ArgHandler", "(", "MIRBuilder", ",", "MIRBuilder", ".", "getMF", "(", ")", ".", "getRegInfo", "(", ")", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgInfos", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "ArgInfo", "OrigArgInfo", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArgInfo", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "splitToValueTypes", "(", "OrigArgInfo", ",", "SplitArgInfos", ",", "DL", ",", "F", ".", "getCallingConv", "(", ")", ")", ";", "Idx", "++", ";", "}", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "if", "(", "!", "determineAndHandleAssignments", "(", "ArgHandler", ",", "ArgAssigner", ",", "SplitArgInfos", ",", "MIRBuilder", ",", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

[ "ARM", "ARM", "ARM", "8", "0" ]

[]

[ "<s>", "void", "Mips16FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "Mips16InstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "Mips16InstrInfo", "*", ">", "(", "STI", ".", "getInstrInfo", "(", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "dl", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", ".", "adjustsStack", "(", ")", ")", "return", ";", "MachineModuleInfo", "&", "MMI", "=", "MF", ".", "getMMI", "(", ")", ";", "const", "MCRegisterInfo", "*", "MRI", "=", "MMI", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", ".", "makeFrame", "(", "Mips", "::", "SP", ",", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "cfiDefCfaOffset", "(", "nullptr", ",", "StackSize", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "{", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", "=", "MFI", ".", "getCalleeSavedInfo", "(", ")", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "CSI", ")", "{", "int64_t", "Offset", "=", "MFI", ".", "getObjectOffset", "(", "I", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "unsigned", "DReg", "=", "MRI", "->", "getDwarfRegNum", "(", "Reg", ",", "true", ")", ";", "unsigned", "CFIIndex", "=", "MF", ".", "addFrameInst", "(", "MCCFIInstruction", "::", "createOffset", "(", "nullptr", ",", "DReg", ",", "Offset", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "TargetOpcode", "::", "CFI_INSTRUCTION", ")", ")", ".", "addCFIIndex", "(", "CFIIndex", ")", ";", "}", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Mips", "::", "MoveR3216", ")", ",", "Mips", "::", "S0", ")", ".", "addReg", "(", "Mips", "::", "SP", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "Mips", "Mips", "Mips", "Mips", "0", "Mips::SP", "Mips::MoveR3216", "Mips::S0", "Mips::SP" ]

[]

[ "<s>", "bool", "enableSubRegLiveness", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Enable", "tracking", "of", "subregister", "liveness", "in", "register", "allocator", "." ]

[ "MOS" ]

[]

[ "<s>", "void", "xstormy16_output_addr_vec", "(", "FILE", "*", "file", ",", "rtx", "label", "ATTRIBUTE_UNUSED", ",", "rtx", "table", ")", "{", "int", "vlen", ",", "idx", ";", "current_function_section", "(", "current_function_decl", ")", ";", "vlen", "=", "XVECLEN", "(", "table", ",", "0", ")", ";", "for", "(", "idx", "=", "0", ";", "idx", "<", "vlen", ";", "idx", "++", ")", "{", "fputs", "(", "\"\\tjmpf \"", ",", "file", ")", ";", "output_asm_label", "(", "XEXP", "(", "XVECEXP", "(", "table", ",", "0", ",", "idx", ")", ",", "0", ")", ")", ";", "fputc", "(", "'\\n'", ",", "file", ")", ";", "}", "}", "</s>" ]

[ "Output", "an", "ADDR_VEC", ".", "It", "is", "output", "as", "a", "sequence", "of", "'jmpf", "'", "instructions", ",", "without", "label", "or", "alignment", "or", "any", "other", "special", "constructs", ".", "We", "know", "that", "the", "previous", "instruction", "will", "be", "the", "`", "tablejump_pcrel", "'", "output", "above", ".", "TODO", ":", "it", "might", "be", "nice", "to", "output", "'br", "'", "instructions", "if", "they", "could", "all", "reach", "." ]

[ "stormy16", "0", "0", "\"\\tjmpf \"", "0", "0" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Alignment", "=", "std", "::", "max", "<", "uint32_t", ">", "(", "RC", "->", "getSize", "(", ")", ",", "16", ")", ";", "bool", "isAligned", "=", "(", "MF", ".", "getTarget", "(", ")", ".", "getSubtargetImpl", "(", ")", "->", "getFrameLowering", "(", ")", "->", "getStackAlignment", "(", ")", ">=", "Alignment", ")", "||", "RI", ".", "canRealignStack", "(", "MF", ")", ";", "unsigned", "Opc", "=", "getLoadRegOpcode", "(", "DestReg", ",", "RC", ",", "isAligned", ",", "Subtarget", ")", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DestReg", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "X86", "X86", "16" ]

[]

[ "<s>", "static", "void", "aarch64_analyze_loop_vinfo", "(", "loop_vec_info", "loop_vinfo", ",", "aarch64_vector_costs", "*", "costs", ")", "{", "costs", "->", "is_loop", "=", "true", ";", "class", "loop", "*", "loop", "=", "LOOP_VINFO_LOOP", "(", "loop_vinfo", ")", ";", "auto", "scalar_niters", "=", "max_stmt_executions_int", "(", "loop", ")", ";", "if", "(", "scalar_niters", ">=", "0", ")", "{", "unsigned", "int", "vf", "=", "vect_vf_for_cost", "(", "loop_vinfo", ")", ";", "if", "(", "LOOP_VINFO_MASKS", "(", "loop_vinfo", ")", ".", "is_empty", "(", ")", ")", "costs", "->", "num_vector_iterations", "=", "scalar_niters", "/", "vf", ";", "else", "costs", "->", "num_vector_iterations", "=", "CEIL", "(", "scalar_niters", ",", "vf", ")", ";", "}", "if", "(", "costs", "==", "LOOP_VINFO_TARGET_COST_DATA", "(", "loop_vinfo", ")", ")", "costs", "->", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "loop_vinfo", "->", "vector_mode", ")", ";", "else", "costs", "->", "vec_flags", "=", "0", ";", "aarch64_record_potential_advsimd_unrolling", "(", "loop_vinfo", ",", "costs", ")", ";", "auto", "*", "issue_info", "=", "aarch64_tune_params", ".", "vec_costs", "->", "issue_info", ";", "if", "(", "issue_info", "&&", "issue_info", "->", "sve", "&&", "!", "LOOP_VINFO_MASKS", "(", "loop_vinfo", ")", ".", "is_empty", "(", ")", ")", "{", "unsigned", "int", "num_masks", "=", "0", ";", "rgroup_controls", "*", "rgm", ";", "unsigned", "int", "num_vectors_m1", ";", "FOR_EACH_VEC_ELT", "(", "LOOP_VINFO_MASKS", "(", "loop_vinfo", ")", ",", "num_vectors_m1", ",", "rgm", ")", "if", "(", "rgm", "->", "type", ")", "num_masks", "+=", "num_vectors_m1", "+", "1", ";", "costs", "->", "sve_ops", ".", "pred_ops", "+=", "num_masks", "*", "issue_info", "->", "sve", "->", "while_pred_ops", ";", "}", "}", "</s>" ]

[ "Do", "one-time", "initialization", "of", "COSTS", "given", "that", "we", "'re", "costing", "the", "loop", "vectorization", "described", "by", "LOOP_VINFO", "." ]

[ "aarch64", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "bool", "cris_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "*", "total", ")", "{", "switch", "(", "code", ")", "{", "case", "CONST_INT", ":", "{", "HOST_WIDE_INT", "val", "=", "INTVAL", "(", "x", ")", ";", "if", "(", "val", "==", "0", ")", "*", "total", "=", "0", ";", "else", "if", "(", "val", "<", "32", "&&", "val", ">=", "-", "32", ")", "*", "total", "=", "1", ";", "else", "if", "(", "val", "<=", "32767", "&&", "val", ">=", "-", "32768", ")", "*", "total", "=", "2", ";", "else", "*", "total", "=", "4", ";", "return", "true", ";", "}", "case", "LABEL_REF", ":", "*", "total", "=", "6", ";", "return", "true", ";", "case", "CONST", ":", "case", "SYMBOL_REF", ":", "*", "total", "=", "6", ";", "return", "true", ";", "case", "CONST_DOUBLE", ":", "if", "(", "x", "!=", "CONST0_RTX", "(", "GET_MODE", "(", "x", ")", "==", "VOIDmode", "?", "DImode", ":", "GET_MODE", "(", "x", ")", ")", ")", "*", "total", "=", "12", ";", "else", "*", "total", "=", "0", ";", "return", "true", ";", "case", "MULT", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", "||", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", ")", "{", "if", "(", "TARGET_HAS_MUL_INSNS", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "1", ")", "+", "COSTS_N_INSNS", "(", "1", ")", "/", "2", ";", "return", "true", ";", "}", "*", "total", "=", "COSTS_N_INSNS", "(", "132", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "UDIV", ":", "case", "MOD", ":", "case", "UMOD", ":", "case", "DIV", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "CONST_INT", "||", "exact_log2", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "<", "0", ")", ")", "{", "*", "total", "=", "COSTS_N_INSNS", "(", "260", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "AND", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "!=", "CONST_INT", "&&", "!", "CONST_OK_FOR_LETTER_P", "(", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ",", "'I'", ")", ")", "{", "*", "total", "=", "(", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "outer_code", ")", "+", "2", "+", "2", "*", "GET_MODE_NUNITS", "(", "GET_MODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ")", ";", "return", "true", ";", "}", "return", "false", ";", "case", "ZERO_EXTEND", ":", "case", "SIGN_EXTEND", ":", "*", "total", "=", "rtx_cost", "(", "XEXP", "(", "x", ",", "0", ")", ",", "outer_code", ")", ";", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Compute", "a", "(", "partial", ")", "cost", "for", "rtx", "X", ".", "Return", "true", "if", "the", "complete", "cost", "has", "been", "computed", ",", "and", "false", "if", "subexpressions", "should", "be", "scanned", ".", "In", "either", "case", ",", "*", "TOTAL", "contains", "the", "cost", "result", "." ]

[ "cris", "0", "0", "32", "32", "1", "32767", "32768", "2", "4", "6", "6", "12", "0", "1", "1", "0", "1", "1", "2", "132", "1", "1", "0", "260", "1", "0", "1", "0", "2", "2", "0", "0" ]

[]

[ "<s>", "static", "rtx", "frv_expand_int_void2arg", "(", "enum", "insn_code", "icode", ",", "tree", "arglist", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "&", "arglist", ")", ";", "op0", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op0", ")", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op1", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "two", "long", "operands", "and", "return", "void", "." ]

[ "frv", "1", "1" ]

[]

[ "<s>", "rtx", "alpha_use_linkage", "(", "rtx", "linkage", "ATTRIBUTE_UNUSED", ",", "tree", "cfundecl", "ATTRIBUTE_UNUSED", ",", "int", "lflag", "ATTRIBUTE_UNUSED", ",", "int", "rflag", "ATTRIBUTE_UNUSED", ")", "{", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Return", "a", "SYMBOL_REF", "representing", "the", "reference", "to", "the", ".linkage", "entry", "of", "function", "FUNC", "built", "for", "calls", "made", "from", "CFUNDECL", ".", "LFLAG", "is", "1", "if", "this", "is", "the", "reference", "to", "the", "linkage", "pointer", "value", ",", "0", "if", "this", "is", "the", "reference", "to", "the", "function", "entry", "value", ".", "RFLAG", "is", "1", "if", "this", "a", "reduced", "reference", "(", "code", "address", "only", ")", ",", "0", "if", "this", "is", "a", "full", "reference", "." ]

[ "alpha" ]

[]

[ "<s>", "bool", "MipsRegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MipsSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ";", "unsigned", "FP", "=", "Subtarget", ".", "isGP32bit", "(", ")", "?", "Mips", "::", "FP", ":", "Mips", "::", "FP_64", ";", "unsigned", "BP", "=", "Subtarget", ".", "isGP32bit", "(", ")", "?", "Mips", "::", "S7", ":", "Mips", "::", "S7_64", ";", "if", "(", "!", "Subtarget", ".", "hasStandardEncoding", "(", ")", ")", "return", "false", ";", "if", "(", "!", "MF", ".", "getRegInfo", "(", ")", ".", "canReserveReg", "(", "FP", ")", ")", "return", "false", ";", "if", "(", "Subtarget", ".", "getFrameLowering", "(", ")", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "return", "true", ";", "return", "MF", ".", "getRegInfo", "(", ")", ".", "canReserveReg", "(", "BP", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "Mips", "Mips", "Mips", "Mips", "Mips::FP", "Mips::FP_64", "Mips::S7", "Mips::S7_64" ]

[]

[ "<s>", "bool", "AMDGPUPromoteAlloca", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "!", "TM", ")", "return", "false", ";", "Mod", "=", "&", "M", ";", "return", "false", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "int", "mmix_opposite_regno", "(", "int", "regno", ",", "int", "incoming", ")", "{", "if", "(", "incoming", "&&", "regno", "==", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", ")", "return", "MMIX_RETURN_VALUE_REGNUM", ";", "if", "(", "!", "incoming", "&&", "regno", "==", "MMIX_RETURN_VALUE_REGNUM", ")", "return", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", ";", "if", "(", "!", "mmix_function_arg_regno_p", "(", "regno", ",", "incoming", ")", ")", "return", "regno", ";", "return", "regno", "-", "(", "incoming", "?", "MMIX_FIRST_INCOMING_ARG_REGNUM", "-", "MMIX_FIRST_ARG_REGNUM", ":", "MMIX_FIRST_ARG_REGNUM", "-", "MMIX_FIRST_INCOMING_ARG_REGNUM", ")", ";", "}", "</s>" ]

[ "INCOMING_REGNO", "and", "OUTGOING_REGNO", "worker", "function", ".", "Those", "two", "macros", "must", "only", "be", "applied", "to", "function", "argument", "registers", "and", "the", "function", "return", "value", "register", "for", "the", "opposite", "use", ".", "FIXME", ":", "for", "their", "current", "use", "in", "gcc", ",", "it", "'d", "be", "better", "with", "an", "explicit", "specific", "additional", "FUNCTION_INCOMING_ARG_REGNO_P", "a'la", "TARGET_FUNCTION_ARG", "/", "TARGET_FUNCTION_INCOMING_ARG", "instead", "of", "forcing", "the", "target", "to", "commit", "to", "a", "fixed", "mapping", "and", "for", "any", "unspecified", "register", "use", ".", "Particularly", "when", "thinking", "about", "the", "return-value", ",", "it", "is", "better", "to", "imagine", "INCOMING_REGNO", "and", "OUTGOING_REGNO", "as", "named", "CALLEE_TO_CALLER_REGNO", "and", "INNER_REGNO", "as", "named", "CALLER_TO_CALLEE_REGNO", "because", "the", "direction", ".", "The", "``", "incoming", "''", "and", "``", "outgoing", "''", "is", "from", "the", "perspective", "of", "the", "parameter-registers", ",", "but", "the", "same", "macro", "is", "(", "must", "be", ",", "lacking", "an", "alternative", "like", "suggested", "above", ")", "used", "to", "map", "the", "return-value-register", "from", "the", "same", "perspective", ".", "To", "make", "directions", "even", "more", "confusing", ",", "the", "macro", "MMIX_OUTGOING_RETURN_VALUE_REGNUM", "holds", "the", "number", "of", "the", "register", "in", "which", "to", "return", "a", "value", ",", "i.e", ".", "INCOMING_REGNO", "for", "the", "return-value-", "register", "as", "received", "from", "a", "called", "function", ";", "the", "return-value", "on", "the", "way", "out", "." ]

[ "mmix" ]

[]

[ "<s>", "static", "rtx_insn", "*", "frame_emit_store", "(", "int", "regno", ",", "rtx", "addr", ",", "HOST_WIDE_INT", "offset", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SImode", ",", "regno", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "V4SImode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "return", "emit_insn", "(", "gen_movv4si", "(", "mem", ",", "reg", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "store", "in", "the", "stack", "frame", "to", "save", "REGNO", "at", "address", "ADDR", ",", "and", "emit", "the", "corresponding", "REG_CFA_OFFSET", "note", "described", "by", "CFA", "and", "CFA_OFFSET", ".", "Return", "the", "emitted", "insn", "." ]

[ "spu" ]

[]

[ "<s>", "BitVector", "M68kRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "M68kFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "auto", "setBitVector", "=", "[", "&", "Reserved", ",", "this", "]", "(", "unsigned", "Reg", ")", "{", "for", "(", "MCRegAliasIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "for", "(", "MCSubRegIterator", "I", "(", "Reg", ",", "this", ",", "true", ")", ";", "I", ".", "isValid", "(", ")", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "}", ";", "for", "(", "size_t", "Reg", "=", "0", ",", "Total", "=", "getNumRegs", "(", ")", ";", "Reg", "!=", "Total", ";", "++", "Reg", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "M68kSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "setBitVector", "(", "Reg", ")", ";", "}", "setBitVector", "(", "M68k", "::", "PC", ")", ";", "setBitVector", "(", "M68k", "::", "SP", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "{", "setBitVector", "(", "FramePtr", ")", ";", "}", "if", "(", "hasBasePointer", "(", "MF", ")", ")", "{", "CallingConv", "::", "ID", "CC", "=", "MF", ".", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", ";", "const", "uint32_t", "*", "RegMask", "=", "getCallPreservedMask", "(", "MF", ",", "CC", ")", ";", "if", "(", "MachineOperand", "::", "clobbersPhysReg", "(", "RegMask", ",", "getBaseRegister", "(", ")", ")", ")", "report_fatal_error", "(", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"", ")", ";", "setBitVector", "(", "getBaseRegister", "(", ")", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "M68k", "M68k", "M68k", "0", "M68k", "M68k::PC", "M68k::SP", "\"Stack realignment in presence of dynamic allocas is \"", "\"not supported with\"", "\"this calling convention.\"" ]

[]

[ "<s>", "static", "bool", "i386_asm_output_addr_const_extra", "(", "FILE", "*", "file", ",", "rtx", "x", ")", "{", "rtx", "op", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "UNSPEC", ")", "return", "false", ";", "op", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOTOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "fputs", "(", "\"@gotoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_GOTTPOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "fputs", "(", "\"@gottpoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_TPOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "fputs", "(", "\"@tpoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_NTPOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "if", "(", "TARGET_64BIT", ")", "fputs", "(", "\"@tpoff\"", ",", "file", ")", ";", "else", "fputs", "(", "\"@ntpoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_DTPOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "fputs", "(", "\"@dtpoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_GOTNTPOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "if", "(", "TARGET_64BIT", ")", "fputs", "(", "ASSEMBLER_DIALECT", "==", "ASM_ATT", "?", "\"@gottpoff(%rip)\"", ":", "\"@gottpoff[rip]\"", ",", "file", ")", ";", "else", "fputs", "(", "\"@gotntpoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_INDNTPOFF", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "fputs", "(", "\"@indntpoff\"", ",", "file", ")", ";", "break", ";", "case", "UNSPEC_MACHOPIC_OFFSET", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "putc", "(", "'-'", ",", "file", ")", ";", "machopic_output_function_base_name", "(", "file", ")", ";", "break", ";", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Implementation", "of", "TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA", "." ]

[ "i386", "0", "0", "1", "\"@gotoff\"", "\"@gottpoff\"", "\"@tpoff\"", "\"@tpoff\"", "\"@ntpoff\"", "\"@dtpoff\"", "\"@gottpoff(%rip)\"", "\"@gottpoff[rip]\"", "\"@gotntpoff\"", "\"@indntpoff\"" ]

[]

[ "<s>", "unsigned", "int", "sparc_regmode_natural_size", "(", "machine_mode", "mode", ")", "{", "const", "enum", "mode_class", "cl", "=", "GET_MODE_CLASS", "(", "mode", ")", ";", "if", "(", "(", "cl", "==", "MODE_FLOAT", "||", "cl", "==", "MODE_VECTOR_INT", ")", "&&", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "return", "4", ";", "return", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "On", "the", "SPARC", ",", "any", "mode", "which", "naturally", "allocates", "into", "the", "single", "float", "registers", "should", "return", "4", "here", "." ]

[ "sparc", "4", "4" ]

[]

[ "<s>", "bool", "SystemZRegisterInfo", "::", "shouldCoalesce", "(", "MachineInstr", "*", "MI", ",", "const", "TargetRegisterClass", "*", "SrcRC", ",", "unsigned", "SubReg", ",", "const", "TargetRegisterClass", "*", "DstRC", ",", "unsigned", "DstSubReg", ",", "const", "TargetRegisterClass", "*", "NewRC", ",", "LiveIntervals", "&", "LIS", ")", "const", "{", "assert", "(", "MI", "->", "isCopy", "(", ")", "&&", "\"Only expecting COPY instructions\"", ")", ";", "if", "(", "!", "(", "NewRC", "->", "hasSuperClassEq", "(", "&", "SystemZ", "::", "GR128BitRegClass", ")", "&&", "(", "getRegSizeInBits", "(", "*", "SrcRC", ")", "<=", "64", "||", "getRegSizeInBits", "(", "*", "DstRC", ")", "<=", "64", ")", ")", ")", "return", "true", ";", "unsigned", "WideOpNo", "=", "(", "getRegSizeInBits", "(", "*", "SrcRC", ")", "==", "128", "?", "1", ":", "0", ")", ";", "unsigned", "GR128Reg", "=", "MI", "->", "getOperand", "(", "WideOpNo", ")", ".", "getReg", "(", ")", ";", "unsigned", "GRNarReg", "=", "MI", "->", "getOperand", "(", "(", "WideOpNo", "==", "1", ")", "?", "0", ":", "1", ")", ".", "getReg", "(", ")", ";", "LiveInterval", "&", "IntGR128", "=", "LIS", ".", "getInterval", "(", "GR128Reg", ")", ";", "LiveInterval", "&", "IntGRNar", "=", "LIS", ".", "getInterval", "(", "GRNarReg", ")", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", "->", "getParent", "(", ")", ";", "MachineInstr", "*", "FirstMI_GR128", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGR128", ".", "beginIndex", "(", ")", ")", ";", "MachineInstr", "*", "FirstMI_GRNar", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGRNar", ".", "beginIndex", "(", ")", ")", ";", "MachineInstr", "*", "LastMI_GR128", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGR128", ".", "endIndex", "(", ")", ")", ";", "MachineInstr", "*", "LastMI_GRNar", "=", "LIS", ".", "getInstructionFromIndex", "(", "IntGRNar", ".", "endIndex", "(", ")", ")", ";", "if", "(", "(", "!", "FirstMI_GR128", "||", "FirstMI_GR128", "->", "getParent", "(", ")", "!=", "MBB", ")", "||", "(", "!", "FirstMI_GRNar", "||", "FirstMI_GRNar", "->", "getParent", "(", ")", "!=", "MBB", ")", "||", "(", "!", "LastMI_GR128", "||", "LastMI_GR128", "->", "getParent", "(", ")", "!=", "MBB", ")", "||", "(", "!", "LastMI_GRNar", "||", "LastMI_GRNar", "->", "getParent", "(", ")", "!=", "MBB", ")", ")", "return", "false", ";", "MachineBasicBlock", "::", "iterator", "MII", "=", "nullptr", ",", "MEE", "=", "nullptr", ";", "if", "(", "WideOpNo", "==", "1", ")", "{", "MII", "=", "FirstMI_GR128", ";", "MEE", "=", "LastMI_GRNar", ";", "}", "else", "{", "MII", "=", "FirstMI_GRNar", ";", "MEE", "=", "LastMI_GR128", ";", "}", "BitVector", "PhysClobbered", "(", "getNumRegs", "(", ")", ")", ";", "MEE", "++", ";", "for", "(", ";", "MII", "!=", "MEE", ";", "++", "MII", ")", "{", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MII", "->", "operands", "(", ")", ")", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "isPhysicalRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "for", "(", "MCSuperRegIterator", "SI", "(", "MO", ".", "getReg", "(", ")", ",", "this", ",", "true", ")", ";", "SI", ".", "isValid", "(", ")", ";", "++", "SI", ")", "if", "(", "NewRC", "->", "contains", "(", "*", "SI", ")", ")", "{", "PhysClobbered", ".", "set", "(", "*", "SI", ")", ";", "break", ";", "}", "}", "}", "unsigned", "const", "DemandedFreeGR128", "=", "3", ";", "if", "(", "PhysClobbered", ".", "count", "(", ")", ">", "(", "NewRC", "->", "getNumRegs", "(", ")", "-", "DemandedFreeGR128", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Subtarget", "Hooks", "." ]

[ "SystemZ", "SystemZ", "\"Only expecting COPY instructions\"", "SystemZ::GR128BitRegClass", "64", "64", "128", "1", "0", "1", "0", "1", "1", "3" ]

[]

[ "<s>", "void", "init_cumulative_args", "(", "CUMULATIVE_ARGS", "*", "cum", ",", "tree", "fntype", ",", "rtx", "libname", "ATTRIBUTE_UNUSED", ")", "{", "static", "CUMULATIVE_ARGS", "zero_cum", ";", "*", "cum", "=", "zero_cum", ";", "cum", "->", "nregs", "=", "max_arg_registers", ";", "cum", "->", "arg_regs", "=", "arg_regs", ";", "cum", "->", "call_cookie", "=", "CALL_NORMAL", ";", "if", "(", "fntype", "&&", "lookup_attribute", "(", "\"shortcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "cum", "->", "call_cookie", "|=", "CALL_SHORT", ";", "else", "if", "(", "fntype", "&&", "lookup_attribute", "(", "\"longcall\"", ",", "TYPE_ATTRIBUTES", "(", "fntype", ")", ")", ")", "cum", "->", "call_cookie", "|=", "CALL_LONG", ";", "return", ";", "}", "</s>" ]

[ "Handle", "the", "INIT_CUMULATIVE_ARGS", "macro", ".", "Initialize", "a", "variable", "CUM", "of", "type", "CUMULATIVE_ARGS", "for", "a", "call", "to", "a", "function", "whose", "data", "type", "is", "FNTYPE", ".", "For", "a", "library", "call", ",", "FNTYPE", "is", "0", "." ]

[ "bfin", "\"shortcall\"", "\"longcall\"" ]

[]

[ "<s>", "virtual", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "setPreservesCFG", "(", ")", ";", "AU", ".", "addRequiredID", "(", "PHIEliminationID", ")", ";", "AU", ".", "addRequiredID", "(", "TwoAddressInstructionPassID", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "PTX" ]

[]

[ "<s>", "static", "char", "*", "aarch64_offload_options", "(", "void", ")", "{", "if", "(", "TARGET_ILP32", ")", "return", "xstrdup", "(", "\"-foffload-abi=ilp32\"", ")", ";", "else", "return", "xstrdup", "(", "\"-foffload-abi=lp64\"", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_OFFLOAD_OPTIONS", "hook", "." ]

[ "aarch64", "\"-foffload-abi=ilp32\"", "\"-foffload-abi=lp64\"" ]

[]