Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "X86CmovConverterPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "if", "(", "!", "EnableCmovConverter", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** \"", "<<", "getPassName", "(", ")", "<<", "\" : \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"**********\\n\"", ")", ";", "bool", "Changed", "=", "false", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "TargetSubtargetInfo", "&", "STI", "=", "MF", ".", "getSubtarget", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "TII", "=", "STI", ".", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "TSchedModel", ".", "init", "(", "&", "STI", ")", ";", "if", "(", "ForceMemOperand", ")", "{", "CmovGroups", "AllCmovGroups", ";", "SmallVector", "<", "MachineBasicBlock", "*", ",", "4", ">", "Blocks", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Blocks", ".", "push_back", "(", "&", "MBB", ")", ";", "if", "(", "collectCmovCandidates", "(", "Blocks", ",", "AllCmovGroups", ",", "true", ")", ")", "{", "for", "(", "auto", "&", "Group", ":", "AllCmovGroups", ")", "{", "if", "(", "!", "llvm", "::", "any_of", "(", "Group", ",", "[", "&", "]", "(", "MachineInstr", "*", "I", ")", "{", "return", "I", "->", "mayLoad", "(", ")", ";", "}", ")", ")", "continue", ";", "Changed", "=", "true", ";", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "}", "}", "SmallVector", "<", "MachineLoop", "*", ",", "4", ">", "Loops", "(", "MLI", ".", "begin", "(", ")", ",", "MLI", ".", "end", "(", ")", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "(", "int", ")", "Loops", ".", "size", "(", ")", ";", "++", "i", ")", "for", "(", "MachineLoop", "*", "Child", ":", "Loops", "[", "i", "]", "->", "getSubLoops", "(", ")", ")", "Loops", ".", "push_back", "(", "Child", ")", ";", "for", "(", "MachineLoop", "*", "CurrLoop", ":", "Loops", ")", "{", "if", "(", "!", "CurrLoop", "->", "getSubLoops", "(", ")", ".", "empty", "(", ")", ")", "continue", ";", "CmovGroups", "CmovInstGroups", ";", "if", "(", "!", "collectCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "if", "(", "!", "checkForProfitableCmovCandidates", "(", "CurrLoop", "->", "getBlocks", "(", ")", ",", "CmovInstGroups", ")", ")", "continue", ";", "Changed", "=", "true", ";", "for", "(", "auto", "&", "Group", ":", "CmovInstGroups", ")", "convertCmovInstsToBranches", "(", "Group", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "\"********** \"", "\" : \"", "\"**********\\n\"", "4", "4", "0" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintType", "SystemZTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'d'", ":", "case", "'f'", ":", "case", "'h'", ":", "case", "'r'", ":", "case", "'v'", ":", "return", "C_RegisterClass", ";", "case", "'Q'", ":", "case", "'R'", ":", "case", "'S'", ":", "case", "'T'", ":", "case", "'m'", ":", "return", "C_Memory", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "return", "C_Immediate", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "SystemZ", "SystemZ", "1", "0" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte stores to stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created store reg=\"", "<<", "printReg", "(", "SrcReg", ",", "TRI", ")", "<<", "\" to FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "ST_rs9", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte stores to stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created store reg=\"", "\" to FrameIndex=\"", "\"\\n\"", "ARC::ST_rs9", "0" ]

[]

[ "<s>", "SDNode", "*", "SITargetLowering", "::", "PostISelFolding", "(", "MachineSDNode", "*", "Node", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "Node", "=", "AdjustRegClass", "(", "Node", ",", "DAG", ")", ";", "if", "(", "TII", "->", "isMIMG", "(", "Node", "->", "getMachineOpcode", "(", ")", ")", ")", "adjustWritemask", "(", "Node", ",", "DAG", ")", ";", "return", "foldOperands", "(", "Node", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Fold", "the", "instructions", "after", "selecting", "them", "." ]

[ "R600", "SI", "SI", "SI" ]

[]

[ "<s>", "bool", "RISCVExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "TII", "=", "static_cast", "<", "const", "RISCVInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "Modified", "|=", "expandMBB", "(", "MBB", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "AArch64DCFunction", "&", "getParent", "(", ")", "{", "return", "static_cast", "<", "AArch64DCFunction", "&", ">", "(", "DCBasicBlock", "::", "getParent", "(", ")", ")", ";", "}", "</s>" ]

[ "getParent", "-", "Return", "the", "last", "analyzed", "interval", "." ]

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

[]

[ "<s>", "static", "MCAsmInfo", "*", "createMCAsmInfo", "(", "const", "Target", "&", "T", ",", "StringRef", "TT", ")", "{", "Triple", "TheTriple", "(", "TT", ")", ";", "bool", "isPPC64", "=", "TheTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "ppc64", ";", "if", "(", "TheTriple", ".", "getOS", "(", ")", "==", "Triple", "::", "Darwin", ")", "return", "new", "PPCMCAsmInfoDarwin", "(", "isPPC64", ")", ";", "return", "new", "PPCLinuxMCAsmInfo", "(", "isPPC64", ")", ";", "}", "</s>" ]

[ "createMCAsmInfo", "-", "Create", "a", "MCAsmInfo", "implementation", "for", "the", "specified", "target", "triple", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "int", "rbt_insert", "(", "struct", "rbt_strings", "*", "t", ",", "char", "*", "str", ")", "{", "struct", "rbt_string_node", "*", "curr", "=", "t", "->", "rbt_root", ";", "struct", "rbt_string_node", "*", "trail", "=", "t", "->", "rbt_nil", ";", "while", "(", "curr", "!=", "t", "->", "rbt_nil", ")", "{", "trail", "=", "curr", ";", "int", "cmp", "=", "strcmp", "(", "str", ",", "curr", "->", "str", ")", ";", "if", "(", "cmp", "<", "0", ")", "curr", "=", "curr", "->", "left", ";", "else", "if", "(", "cmp", ">", "0", ")", "curr", "=", "curr", "->", "right", ";", "else", "return", "0", ";", "}", "struct", "rbt_string_node", "*", "fresh", "=", "rbt_create_node", "(", "t", ",", "str", ")", ";", "fresh", "->", "par", "=", "trail", ";", "if", "(", "trail", "==", "t", "->", "rbt_nil", ")", "t", "->", "rbt_root", "=", "fresh", ";", "else", "if", "(", "strcmp", "(", "fresh", "->", "str", ",", "trail", "->", "str", ")", "<", "0", ")", "trail", "->", "left", "=", "fresh", ";", "else", "trail", "->", "right", "=", "fresh", ";", "fresh", "->", "left", "=", "t", "->", "rbt_nil", ";", "fresh", "->", "right", "=", "t", "->", "rbt_nil", ";", "curr", "=", "fresh", ";", "while", "(", "curr", "->", "par", "->", "color", "==", "RBT_RED", ")", "if", "(", "curr", "->", "par", "==", "curr", "->", "par", "->", "par", "->", "left", ")", "{", "struct", "rbt_string_node", "*", "uncle", "=", "curr", "->", "par", "->", "par", "->", "right", ";", "if", "(", "uncle", "->", "color", "==", "RBT_RED", ")", "{", "curr", "->", "par", "->", "color", "=", "RBT_BLACK", ";", "uncle", "->", "color", "=", "RBT_BLACK", ";", "curr", "->", "par", "->", "par", "->", "color", "=", "RBT_RED", ";", "curr", "=", "curr", "->", "par", "->", "par", ";", "}", "else", "if", "(", "curr", "==", "curr", "->", "par", "->", "right", ")", "{", "curr", "=", "curr", "->", "par", ";", "rbt_left_rotate", "(", "t", ",", "curr", ")", ";", "}", "else", "{", "curr", "->", "par", "->", "color", "=", "RBT_BLACK", ";", "curr", "->", "par", "->", "par", "->", "color", "=", "RBT_RED", ";", "rbt_right_rotate", "(", "t", ",", "curr", "->", "par", "->", "par", ")", ";", "}", "}", "else", "{", "struct", "rbt_string_node", "*", "aunt", "=", "curr", "->", "par", "->", "par", "->", "left", ";", "if", "(", "aunt", "->", "color", "==", "RBT_RED", ")", "{", "curr", "->", "par", "->", "color", "=", "RBT_BLACK", ";", "aunt", "->", "color", "=", "RBT_BLACK", ";", "curr", "->", "par", "->", "par", "->", "color", "=", "RBT_RED", ";", "curr", "=", "curr", "->", "par", "->", "par", ";", "}", "else", "if", "(", "curr", "==", "curr", "->", "par", "->", "left", ")", "{", "curr", "=", "curr", "->", "par", ";", "rbt_right_rotate", "(", "t", ",", "curr", ")", ";", "}", "else", "{", "curr", "->", "par", "->", "color", "=", "RBT_BLACK", ";", "curr", "->", "par", "->", "par", "->", "color", "=", "RBT_RED", ";", "rbt_left_rotate", "(", "t", ",", "curr", "->", "par", "->", "par", ")", ";", "}", "}", "t", "->", "rbt_root", "->", "color", "=", "RBT_BLACK", ";", "return", "1", ";", "}", "</s>" ]

[ "Insert", "STR", "into", "the", "tree", ",", "returning", "1", "for", "success", "and", "0", "if", "STR", "already", "appears", "in", "the", "tree", "." ]

[ "rs6000", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "SDValue", "N0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "EVT", "Ty", "=", "N0", ".", "getValueType", "(", ")", ";", "if", "(", "Ty", ".", "isScalarInteger", "(", ")", "&&", "(", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "||", "N0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "OR", ")", ")", "{", "auto", "*", "C1", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N0", "->", "getOperand", "(", "1", ")", ")", ";", "auto", "*", "C2", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N", "->", "getOperand", "(", "1", ")", ")", ";", "if", "(", "C1", "&&", "C2", ")", "{", "APInt", "C1Int", "=", "C1", "->", "getAPIntValue", "(", ")", ";", "APInt", "ShiftedC1Int", "=", "C1Int", "<<", "C2", "->", "getAPIntValue", "(", ")", ";", "if", "(", "ShiftedC1Int", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "isLegalAddImmediate", "(", "ShiftedC1Int", ".", "getSExtValue", "(", ")", ")", ")", "return", "true", ";", "if", "(", "C1Int", ".", "getMinSignedBits", "(", ")", "<=", "64", "&&", "isLegalAddImmediate", "(", "C1Int", ".", "getSExtValue", "(", ")", ")", ")", "return", "false", ";", "int", "C1Cost", "=", "RISCVMatInt", "::", "getIntMatCost", "(", "C1Int", ",", "Ty", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "int", "ShiftedC1Cost", "=", "RISCVMatInt", "::", "getIntMatCost", "(", "ShiftedC1Int", ",", "Ty", ".", "getSizeInBits", "(", ")", ",", "Subtarget", ".", "is64Bit", "(", ")", ")", ";", "if", "(", "C1Cost", "<", "ShiftedC1Cost", ")", "return", "false", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "move", "this", "shift", "by", "a", "constant", "amount", "through", "its", "operand", ",", "adjusting", "any", "immediate", "operands", "as", "necessary", "to", "preserve", "semantics", "." ]

[ "RISCV", "RISCV", "0", "ISD::ADD", "ISD::OR", "1", "1", "64", "64", "RISCVMatInt::getIntMatCost", "RISCVMatInt::getIntMatCost" ]

[]

[ "<s>", "bool", "AArch64InstrInfo", "::", "isPreLdSt", "(", "const", "MachineInstr", "&", "MI", ")", "{", "return", "isPreLd", "(", "MI", ")", "||", "isPreSt", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "whether", "the", "instruction", "is", "a", "pre-indexed", "load/store", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "machine_mode", "loongarch_promote_function_mode", "(", "const_tree", "type", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ",", "int", "*", "punsignedp", "ATTRIBUTE_UNUSED", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ",", "int", "for_return", "ATTRIBUTE_UNUSED", ")", "{", "int", "unsignedp", ";", "if", "(", "type", "!=", "NULL_TREE", ")", "return", "promote_mode", "(", "type", ",", "mode", ",", "punsignedp", ")", ";", "unsignedp", "=", "*", "punsignedp", ";", "PROMOTE_MODE", "(", "mode", ",", "unsignedp", ",", "type", ")", ";", "*", "punsignedp", "=", "unsignedp", ";", "return", "mode", ";", "}", "</s>" ]

[ "This", "function", "is", "equivalent", "to", "default_promote_function_mode_always_promote", "except", "that", "it", "returns", "a", "promoted", "mode", "even", "if", "type", "is", "NULL_TREE", ".", "This", "is", "needed", "by", "libcalls", "which", "have", "no", "type", "(", "only", "a", "mode", ")", "such", "as", "fixed", "conversion", "routines", "that", "take", "a", "signed", "or", "unsigned", "char/short", "argument", "and", "convert", "it", "to", "a", "fixed", "type", "." ]

[ "loongarch" ]

[]

[ "<s>", "unsigned", "char", "X86Subtarget", "::", "classifyGlobalFunctionReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "Module", "&", "M", ")", "const", "{", "if", "(", "TM", ".", "shouldAssumeDSOLocal", "(", "M", ",", "GV", ")", ")", "return", "X86II", "::", "MO_NO_FLAG", ";", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "assert", "(", "GV", "->", "hasDLLImportStorageClass", "(", ")", "&&", "\"shouldAssumeDSOLocal gave inconsistent answer\"", ")", ";", "return", "X86II", "::", "MO_DLLIMPORT", ";", "}", "const", "Function", "*", "F", "=", "dyn_cast_or_null", "<", "Function", ">", "(", "GV", ")", ";", "if", "(", "isTargetELF", "(", ")", ")", "{", "if", "(", "is64Bit", "(", ")", "&&", "F", "&&", "(", "CallingConv", "::", "X86_RegCall", "==", "F", "->", "getCallingConv", "(", ")", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "if", "(", "(", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "||", "(", "!", "F", "&&", "M", ".", "getRtLibUseGOT", "(", ")", ")", ")", "&&", "is64Bit", "(", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_PLT", ";", "}", "if", "(", "is64Bit", "(", ")", ")", "{", "if", "(", "F", "&&", "F", "->", "hasFnAttribute", "(", "Attribute", "::", "NonLazyBind", ")", ")", "return", "X86II", "::", "MO_GOTPCREL", ";", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "return", "X86II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "Classify", "a", "global", "function", "reference", "for", "the", "current", "subtarget", "." ]

[ "X86", "X86", "X86II::MO_NO_FLAG", "\"shouldAssumeDSOLocal gave inconsistent answer\"", "X86II::MO_DLLIMPORT", "X86", "X86II::MO_GOTPCREL", "X86II::MO_GOTPCREL", "X86II::MO_PLT", "X86II::MO_GOTPCREL", "X86II::MO_NO_FLAG", "X86II::MO_NO_FLAG" ]

[]

[ "<s>", "static", "tree", "ix86_handle_tm_regparm_attribute", "(", "tree", "*", "node", ",", "tree", ",", "tree", ",", "int", "flags", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "alt", ";", "*", "no_add_attrs", "=", "true", ";", "if", "(", "TARGET_64BIT", ")", "return", "NULL_TREE", ";", "if", "(", "CHECK_STACK_LIMIT", ">", "0", ")", "alt", "=", "tree_cons", "(", "get_identifier", "(", "\"fastcall\"", ")", ",", "NULL", ",", "NULL", ")", ";", "else", "{", "alt", "=", "tree_cons", "(", "NULL", ",", "build_int_cst", "(", "NULL", ",", "2", ")", ",", "NULL", ")", ";", "alt", "=", "tree_cons", "(", "get_identifier", "(", "\"regparm\"", ")", ",", "alt", ",", "NULL", ")", ";", "}", "decl_attributes", "(", "node", ",", "alt", ",", "flags", ")", ";", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "The", "transactional", "memory", "builtins", "are", "implicitly", "regparm", "or", "fastcall", "depending", "on", "the", "ABI", ".", "Override", "the", "generic", "do-nothing", "attribute", "that", "these", "builtins", "were", "declared", "with", ",", "and", "replace", "it", "with", "one", "of", "the", "two", "attributes", "that", "we", "expect", "elsewhere", "." ]

[ "i386", "0", "\"fastcall\"", "2", "\"regparm\"" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isImmConstraint", "(", "Constraint", ")", ")", "{", "uint64_t", "Val", ";", "if", "(", "getAsmOperandConstVal", "(", "Op", ",", "Val", ")", "&&", "checkAsmConstraintVal", "(", "Op", ",", "Constraint", ",", "Val", ")", ")", "{", "Val", "=", "clearUnusedBits", "(", "Val", ",", "Op", ".", "getScalarValueSizeInBits", "(", ")", ")", ";", "Ops", ".", "push_back", "(", "DAG", ".", "getTargetConstant", "(", "Val", ",", "SDLoc", "(", "Op", ")", ",", "MVT", "::", "i64", ")", ")", ";", "}", "}", "else", "{", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "AMDGPU", "SI", "MVT::i64" ]

[]

[ "<s>", "const", "char", "*", "output_ubranch", "(", "rtx", "dest", ",", "int", "label", ",", "rtx", "insn", ")", "{", "static", "char", "string", "[", "64", "]", ";", "bool", "v9_form", "=", "false", ";", "char", "*", "p", ";", "if", "(", "TARGET_V9", "&&", "INSN_ADDRESSES_SET_P", "(", ")", ")", "{", "int", "delta", "=", "(", "INSN_ADDRESSES", "(", "INSN_UID", "(", "dest", ")", ")", "-", "INSN_ADDRESSES", "(", "INSN_UID", "(", "insn", ")", ")", ")", ";", "if", "(", "delta", ">=", "-", "260000", "&&", "delta", "<", "260000", ")", "v9_form", "=", "true", ";", "}", "if", "(", "v9_form", ")", "strcpy", "(", "string", ",", "\"ba%*,pt\\t%%xcc, \"", ")", ";", "else", "strcpy", "(", "string", ",", "\"b%*\\t\"", ")", ";", "p", "=", "strchr", "(", "string", ",", "'\\0'", ")", ";", "*", "p", "++", "=", "'%'", ";", "*", "p", "++", "=", "'l'", ";", "*", "p", "++", "=", "'0'", "+", "label", ";", "*", "p", "++", "=", "'%'", ";", "*", "p", "++", "=", "'('", ";", "*", "p", "=", "'\\0'", ";", "return", "string", ";", "}", "</s>" ]

[ "Output", "an", "unconditional", "branch", "to", "LABEL", ".", "INSN", "is", "the", "instruction", "." ]

[ "sparc", "64", "260000", "260000", "\"ba%*,pt\\t%%xcc, \"", "\"b%*\\t\"" ]

[]

[ "<s>", "const", "Z80RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "getInstrInfo", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"XCore Assembly Printer\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "XCore", "\"XCore Assembly Printer\"" ]

[]

[ "<s>", "static", "machine_mode", "rs6000_c_mode_for_suffix", "(", "char", "suffix", ")", "{", "if", "(", "TARGET_FLOAT128_TYPE", ")", "{", "if", "(", "suffix", "==", "'q'", "||", "suffix", "==", "'Q'", ")", "return", "(", "FLOAT128_IEEE_P", "(", "TFmode", ")", ")", "?", "TFmode", ":", "KFmode", ";", "}", "return", "VOIDmode", ";", "}", "</s>" ]

[ "Target", "hook", "for", "c_mode_for_suffix", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "loongarch_print_operand_reloc", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "bool", "hi64_part", ",", "bool", "hi_reloc", ")", "{", "const", "char", "*", "reloc", ";", "enum", "loongarch_symbol_type", "symbol_type", "=", "loongarch_classify_symbolic_expression", "(", "op", ")", ";", "if", "(", "loongarch_symbol_extreme_p", "(", "symbol_type", ")", ")", "gcc_assert", "(", "TARGET_EXPLICIT_RELOCS", ")", ";", "switch", "(", "symbol_type", ")", "{", "case", "SYMBOL_PCREL64", ":", "if", "(", "hi64_part", ")", "{", "reloc", "=", "hi_reloc", "?", "\"%pc64_hi12\"", ":", "\"%pc64_lo20\"", ";", "break", ";", "}", "case", "SYMBOL_PCREL", ":", "reloc", "=", "hi_reloc", "?", "\"%pc_hi20\"", ":", "\"%pc_lo12\"", ";", "break", ";", "case", "SYMBOL_GOT_DISP", ":", "if", "(", "hi64_part", ")", "{", "if", "(", "TARGET_CMODEL_EXTREME", ")", "reloc", "=", "hi_reloc", "?", "\"%got64_pc_hi12\"", ":", "\"%got64_pc_lo20\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "reloc", "=", "hi_reloc", "?", "\"%got_pc_hi20\"", ":", "\"%got_pc_lo12\"", ";", "break", ";", "case", "SYMBOL_TLS_IE", ":", "if", "(", "hi64_part", ")", "{", "if", "(", "TARGET_CMODEL_EXTREME", ")", "reloc", "=", "hi_reloc", "?", "\"%ie64_pc_hi12\"", ":", "\"%ie64_pc_lo20\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "reloc", "=", "hi_reloc", "?", "\"%ie_pc_hi20\"", ":", "\"%ie_pc_lo12\"", ";", "break", ";", "case", "SYMBOL_TLS_LE", ":", "if", "(", "hi64_part", ")", "{", "if", "(", "TARGET_CMODEL_EXTREME", ")", "reloc", "=", "hi_reloc", "?", "\"%le64_hi12\"", ":", "\"%le64_lo20\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "reloc", "=", "hi_reloc", "?", "\"%le_hi20\"", ":", "\"%le_lo12\"", ";", "break", ";", "case", "SYMBOL_TLSGD", ":", "if", "(", "hi64_part", ")", "{", "if", "(", "TARGET_CMODEL_EXTREME", ")", "reloc", "=", "hi_reloc", "?", "\"%got64_pc_hi12\"", ":", "\"%got64_pc_lo20\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "reloc", "=", "hi_reloc", "?", "\"%gd_pc_hi20\"", ":", "\"%got_pc_lo12\"", ";", "break", ";", "case", "SYMBOL_TLSLDM", ":", "if", "(", "hi64_part", ")", "{", "if", "(", "TARGET_CMODEL_EXTREME", ")", "reloc", "=", "hi_reloc", "?", "\"%got64_pc_hi12\"", ":", "\"%got64_pc_lo20\"", ";", "else", "gcc_unreachable", "(", ")", ";", "}", "else", "reloc", "=", "hi_reloc", "?", "\"%ld_pc_hi20\"", ":", "\"%got_pc_lo12\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "file", ",", "\"%s(\"", ",", "reloc", ")", ";", "output_addr_const", "(", "file", ",", "loongarch_strip_unspec_address", "(", "op", ")", ")", ";", "fputc", "(", "')'", ",", "file", ")", ";", "}", "</s>" ]

[ "Print", "symbolic", "operand", "OP", ",", "which", "is", "part", "of", "a", "HIGH", "or", "LO_SUM", "in", "context", "CONTEXT", ".", "HI_RELOC", "indicates", "a", "high-part", "reloc", "." ]

[ "loongarch", "\"%pc64_hi12\"", "\"%pc64_lo20\"", "\"%pc_hi20\"", "\"%pc_lo12\"", "\"%got64_pc_hi12\"", "\"%got64_pc_lo20\"", "\"%got_pc_hi20\"", "\"%got_pc_lo12\"", "\"%ie64_pc_hi12\"", "\"%ie64_pc_lo20\"", "\"%ie_pc_hi20\"", "\"%ie_pc_lo12\"", "\"%le64_hi12\"", "\"%le64_lo20\"", "\"%le_hi20\"", "\"%le_lo12\"", "\"%got64_pc_hi12\"", "\"%got64_pc_lo20\"", "\"%gd_pc_hi20\"", "\"%got_pc_lo12\"", "\"%got64_pc_hi12\"", "\"%got64_pc_lo20\"", "\"%ld_pc_hi20\"", "\"%got_pc_lo12\"", "\"%s(\"" ]

[]

[ "<s>", "void", "dump", "(", ")", "{", "errs", "(", ")", "<<", "\"KudeyarISelAddressMode \"", "<<", "this", "<<", "'\\n'", ";", "if", "(", "BaseType", "==", "RegBase", "&&", "Base", ".", "Reg", ".", "getNode", "(", ")", "!=", "0", ")", "{", "errs", "(", ")", "<<", "\"Base.Reg \"", ";", "Base", ".", "Reg", ".", "getNode", "(", ")", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "BaseType", "==", "FrameIndexBase", ")", "{", "errs", "(", ")", "<<", "\" Base.FrameIndex \"", "<<", "Base", ".", "FrameIndex", "<<", "'\\n'", ";", "}", "errs", "(", ")", "<<", "\" Disp \"", "<<", "Disp", "<<", "'\\n'", ";", "if", "(", "GV", ")", "{", "errs", "(", ")", "<<", "\"GV \"", ";", "GV", "->", "dump", "(", ")", ";", "}", "else", "if", "(", "CP", ")", "{", "errs", "(", ")", "<<", "\" CP \"", ";", "CP", "->", "dump", "(", ")", ";", "errs", "(", ")", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "else", "if", "(", "ES", ")", "{", "errs", "(", ")", "<<", "\"ES \"", ";", "errs", "(", ")", "<<", "ES", "<<", "'\\n'", ";", "}", "else", "if", "(", "JT", "!=", "-", "1", ")", "errs", "(", ")", "<<", "\" JT\"", "<<", "JT", "<<", "\" Align\"", "<<", "Align", "<<", "'\\n'", ";", "}", "</s>" ]

[ "Dump", "the", "plan", "to", "stderr", "(", "for", "debugging", ")", "." ]

[ "Kudeyar", "\"KudeyarISelAddressMode \"", "0", "\"Base.Reg \"", "\" Base.FrameIndex \"", "\" Disp \"", "\"GV \"", "\" CP \"", "\" Align\"", "\"ES \"", "1", "\" JT\"", "\" Align\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldFoldConstantShiftPairToMask", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "return", "true", ";", "if", "(", "Level", "==", "BeforeLegalizeTypes", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "fold", "a", "pair", "of", "shifts", "into", "a", "mask", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "SIFrameLowering", "::", "processFunctionBeforeFrameFinalized", "(", "MachineFunction", "&", "MF", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "MFI", ".", "hasStackObjects", "(", ")", ")", "return", ";", "bool", "MayNeedScavengingEmergencySlot", "=", "MFI", ".", "hasStackObjects", "(", ")", ";", "assert", "(", "(", "RS", "||", "!", "MayNeedScavengingEmergencySlot", ")", "&&", "\"RegScavenger required if spilling\"", ")", ";", "if", "(", "MayNeedScavengingEmergencySlot", ")", "{", "int", "ScavengeFI", "=", "MFI", ".", "CreateStackObject", "(", "AMDGPU", "::", "SGPR_32RegClass", ".", "getSize", "(", ")", ",", "AMDGPU", "::", "SGPR_32RegClass", ".", "getAlignment", "(", ")", ",", "false", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "ScavengeFI", ")", ";", "}", "}", "</s>" ]

[ "processFunctionBeforeFrameFinalized", "-", "This", "method", "is", "called", "immediately", "before", "the", "specified", "function", "'s", "frame", "layout", "(", "MF.getFrameInfo", "(", ")", ")", "is", "finalized", "." ]

[ "AMDGPU", "SI", "\"RegScavenger required if spilling\"", "AMDGPU::SGPR_32RegClass", "AMDGPU::SGPR_32RegClass" ]

[]

[ "<s>", "SDValue", "NVPTXTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "DebugLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "bool", "isABI", "=", "(", "nvptxSubtarget", ".", "getSmVersion", "(", ")", ">=", "20", ")", ";", "unsigned", "sizesofar", "=", "0", ";", "unsigned", "idx", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Outs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "SDValue", "theVal", "=", "OutVals", "[", "i", "]", ";", "EVT", "theValType", "=", "theVal", ".", "getValueType", "(", ")", ";", "unsigned", "numElems", "=", "1", ";", "if", "(", "theValType", ".", "isVector", "(", ")", ")", "numElems", "=", "theValType", ".", "getVectorNumElements", "(", ")", ";", "for", "(", "unsigned", "j", "=", "0", ",", "je", "=", "numElems", ";", "j", "!=", "je", ";", "++", "j", ")", "{", "SDValue", "tmpval", "=", "theVal", ";", "if", "(", "theValType", ".", "isVector", "(", ")", ")", "tmpval", "=", "DAG", ".", "getNode", "(", "ISD", "::", "EXTRACT_VECTOR_ELT", ",", "dl", ",", "theValType", ".", "getVectorElementType", "(", ")", ",", "tmpval", ",", "DAG", ".", "getIntPtrConstant", "(", "j", ")", ")", ";", "Chain", "=", "DAG", ".", "getNode", "(", "isABI", "?", "NVPTXISD", "::", "StoreRetval", ":", "NVPTXISD", "::", "MoveToRetval", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ",", "DAG", ".", "getConstant", "(", "isABI", "?", "sizesofar", ":", "idx", ",", "MVT", "::", "i32", ")", ",", "tmpval", ")", ";", "if", "(", "theValType", ".", "isVector", "(", ")", ")", "sizesofar", "+=", "theValType", ".", "getVectorElementType", "(", ")", ".", "getStoreSizeInBits", "(", ")", "/", "8", ";", "else", "sizesofar", "+=", "theValType", ".", "getStoreSizeInBits", "(", ")", "/", "8", ";", "++", "idx", ";", "}", "}", "return", "DAG", ".", "getNode", "(", "NVPTXISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "NVPTX", "NVPTX", "ISD::OutputArg", "20", "0", "0", "0", "1", "0", "ISD::EXTRACT_VECTOR_ELT", "NVPTXISD::StoreRetval", "NVPTXISD::MoveToRetval", "MVT::Other", "MVT::i32", "8", "8", "NVPTXISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "void", "write_worker_buffer", "(", "FILE", "*", "file", ",", "rtx", "sym", ",", "unsigned", "align", ",", "unsigned", "size", ")", "{", "const", "char", "*", "name", "=", "XSTR", "(", "sym", ",", "0", ")", ";", "write_var_marker", "(", "file", ",", "true", ",", "false", ",", "name", ")", ";", "fprintf", "(", "file", ",", "\".shared .align %d .u8 %s[%d];\\n\"", ",", "align", ",", "name", ",", "size", ")", ";", "}", "</s>" ]

[ "Emit", "a", "declaration", "for", "a", "worker-level", "buffer", "in", ".shared", "memory", "." ]

[ "nvptx", "0", "\".shared .align %d .u8 %s[%d];\\n\"" ]

[]

[ "<s>", "bool", "X86CondBrFoldingPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "if", "(", "!", "ST", ".", "threewayBranchProfitable", "(", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "MachineBranchProbabilityInfo", "*", "MBPI", "=", "&", "getAnalysis", "<", "MachineBranchProbabilityInfo", ">", "(", ")", ";", "X86CondBrFolding", "CondBr", "(", "TII", ",", "MBPI", ",", "MF", ")", ";", "return", "CondBr", ".", "optimize", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "int", "rbt_find", "(", "struct", "rbt_strings", "*", "t", ",", "char", "*", "str", ")", "{", "struct", "rbt_string_node", "*", "curr", "=", "t", "->", "rbt_root", ";", "while", "(", "curr", "!=", "t", "->", "rbt_nil", ")", "{", "int", "cmp", "=", "strcmp", "(", "str", ",", "curr", "->", "str", ")", ";", "if", "(", "cmp", "<", "0", ")", "curr", "=", "curr", "->", "left", ";", "else", "if", "(", "cmp", ">", "0", ")", "curr", "=", "curr", "->", "right", ";", "else", "return", "1", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "if", "STR", "is", "in", "the", "red-black", "tree", ",", "else", "0", "." ]

[ "rs6000", "0", "0", "1", "0" ]

[]

[ "<s>", "void", "pass_shorten_memrefs", "::", "transform", "(", "regno_map", "*", "m", ",", "basic_block", "bb", ")", "{", "rtx_insn", "*", "insn", ";", "FOR_BB_INSNS", "(", "bb", ",", "insn", ")", "{", "if", "(", "!", "NONJUMP_INSN_P", "(", "insn", ")", ")", "continue", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", ")", "continue", ";", "start_sequence", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "2", ";", "i", "++", ")", "{", "rtx", "mem", "=", "XEXP", "(", "pat", ",", "i", ")", ";", "rtx", "addr", ";", "bool", "extend", "=", "false", ";", "if", "(", "get_si_mem_base_reg", "(", "mem", ",", "&", "addr", ",", "&", "extend", ")", ")", "{", "HOST_WIDE_INT", "regno", "=", "REGNO", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ";", "if", "(", "i", "==", "0", ")", "{", "if", "(", "XEXP", "(", "pat", ",", "1", ")", "==", "CONST0_RTX", "(", "GET_MODE", "(", "XEXP", "(", "pat", ",", "1", ")", ")", ")", ")", "continue", ";", "}", "if", "(", "m", "->", "get_or_insert", "(", "regno", ")", ">", "3", ")", "{", "if", "(", "extend", ")", "{", "addr", "=", "targetm", ".", "legitimize_address", "(", "addr", ",", "addr", ",", "GET_MODE", "(", "XEXP", "(", "mem", ",", "0", ")", ")", ")", ";", "XEXP", "(", "XEXP", "(", "pat", ",", "i", ")", ",", "0", ")", "=", "replace_equiv_address", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "addr", ")", ";", "}", "else", "{", "addr", "=", "targetm", ".", "legitimize_address", "(", "addr", ",", "addr", ",", "GET_MODE", "(", "mem", ")", ")", ";", "XEXP", "(", "pat", ",", "i", ")", "=", "replace_equiv_address", "(", "mem", ",", "addr", ")", ";", "}", "df_insn_rescan", "(", "insn", ")", ";", "}", "}", "}", "rtx_insn", "*", "seq", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "emit_insn_before", "(", "seq", ",", "insn", ")", ";", "}", "}", "</s>" ]

[ "Convert", "BASE", "+", "LARGE_OFFSET", "to", "NEW_BASE", "+", "SMALL_OFFSET", "for", "each", "load/store", "with", "a", "base", "reg", "referenced", "at", "least", "4", "times", "." ]

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

[]

[ "<s>", "bool", "AlphaRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", "->", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "MachineFrameInfo", "&", "FrameInfo", "=", "MF", "->", "getFrameInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "unsigned", "Size", "=", "FrameInfo", ".", "getObjectSize", "(", "FrameIndex", ")", ";", "unsigned", "Align", "=", "FrameInfo", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachinePointerInfo", "PtrInfo", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "*", "MF", ",", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", "->", "getMachineMemOperand", "(", "PtrInfo", ",", "MachineMemOperand", "::", "MOStore", ",", "Size", ",", "Align", ")", ";", "unsigned", "SpillSize", "=", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", ";", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "{", "MFI", "->", "setHasSpilledSGPRs", "(", ")", ";", "const", "MCInstrDesc", "&", "OpDesc", "=", "get", "(", "getSGPRSpillSaveOpcode", "(", "SpillSize", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "SrcReg", ")", "&&", "SpillSize", "==", "4", ")", "{", "MachineRegisterInfo", "&", "MRI", "=", "MF", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "constrainRegClass", "(", "SrcReg", ",", "&", "AMDGPU", "::", "SReg_32_XM0RegClass", ")", ";", "}", "MachineInstrBuilder", "Spill", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "OpDesc", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ",", "RegState", "::", "Implicit", ")", ";", "FrameInfo", ".", "setStackID", "(", "FrameIndex", ",", "SIStackID", "::", "SGPR_SPILL", ")", ";", "if", "(", "ST", ".", "hasScalarStores", "(", ")", ")", "{", "Spill", ".", "addReg", "(", "AMDGPU", "::", "M0", ",", "RegState", "::", "ImplicitDefine", "|", "RegState", "::", "Dead", ")", ";", "}", "return", ";", "}", "assert", "(", "RI", ".", "hasVGPRs", "(", "RC", ")", "&&", "\"Only VGPR spilling expected\"", ")", ";", "unsigned", "Opcode", "=", "getVGPRSpillSaveOpcode", "(", "SpillSize", ")", ";", "MFI", "->", "setHasSpilledVGPRs", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "MFI", "->", "getScratchRSrcReg", "(", ")", ")", ".", "addReg", "(", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "4", "AMDGPU::SReg_32_XM0RegClass", "SIStackID::SGPR_SPILL", "AMDGPU::M0", "\"Only VGPR spilling expected\"", "0" ]

[]

[ "<s>", "EVT", "AArch64TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "bool", "CanImplicitFloat", "=", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ";", "bool", "CanUseNEON", "=", "Subtarget", "->", "hasNEON", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "CanUseFP", "=", "Subtarget", "->", "hasFPARMv8", "(", ")", "&&", "CanImplicitFloat", ";", "bool", "IsSmallMemset", "=", "IsMemset", "&&", "Size", "<", "32", ";", "auto", "AlignmentIsAcceptable", "=", "[", "&", "]", "(", "EVT", "VT", ",", "unsigned", "AlignCheck", ")", "{", "if", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "AlignCheck", ")", ")", "return", "true", ";", "bool", "Fast", ";", "return", "allowsMisalignedMemoryAccesses", "(", "VT", ",", "0", ",", "1", ",", "&", "Fast", ")", "&&", "Fast", ";", "}", ";", "if", "(", "CanUseNEON", "&&", "IsMemset", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "v2i64", ",", "16", ")", ")", "return", "MVT", "::", "v2i64", ";", "if", "(", "CanUseFP", "&&", "!", "IsSmallMemset", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "f128", ",", "16", ")", ")", "return", "MVT", "::", "f128", ";", "if", "(", "Size", ">=", "8", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i64", ",", "8", ")", ")", "return", "MVT", "::", "i64", ";", "if", "(", "Size", ">=", "4", "&&", "AlignmentIsAcceptable", "(", "MVT", "::", "i32", ",", "4", ")", ")", "return", "MVT", "::", "i32", ";", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "AArch64", "AArch64", "32", "0", "1", "MVT::v2i64", "16", "MVT::v2i64", "MVT::f128", "16", "MVT::f128", "8", "MVT::i64", "8", "MVT::i64", "4", "MVT::i32", "4", "MVT::i32", "MVT::Other" ]

[]

[ "<s>", "void", "P2InstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i32", ")", ")", "{", "Opcode", "=", "P2", "::", "WRLONGri", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\">> store reg \"", "<<", "SrcReg", "<<", "\" to stack frame index \"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "}", "</s>" ]

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

[ "P2", "P2", "0", "MVT::i32", "P2::WRLONGri", "\"Cannot store this register into a stack slot!\"", "\">> store reg \"", "\" to stack frame index \"", "\"\\n\"" ]

[]

[ "<s>", "static", "tree", "lookup_sve_type_attribute", "(", "const_tree", "type", ")", "{", "if", "(", "type", "==", "error_mark_node", ")", "return", "NULL_TREE", ";", "return", "lookup_attribute", "(", "\"SVE type\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "}", "</s>" ]

[ "If", "TYPE", "is", "an", "ABI-defined", "SVE", "type", ",", "return", "its", "attribute", "descriptor", ",", "otherwise", "return", "null", "." ]

[ "aarch64", "\"SVE type\"" ]

[]

[ "<s>", "static", "void", "ix86_setup_incoming_varargs", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "CUMULATIVE_ARGS", "next_cum", ";", "tree", "fntype", ";", "gcc_assert", "(", "!", "no_rtl", ")", ";", "if", "(", "!", "TARGET_64BIT", ")", "return", ";", "fntype", "=", "TREE_TYPE", "(", "current_function_decl", ")", ";", "next_cum", "=", "*", "cum", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", "&&", "stdarg_p", "(", "fntype", ")", ")", "ix86_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "next_cum", ")", ",", "arg", ")", ";", "if", "(", "cum", "->", "call_abi", "==", "MS_ABI", ")", "setup_incoming_varargs_ms_64", "(", "&", "next_cum", ")", ";", "else", "setup_incoming_varargs_64", "(", "&", "next_cum", ")", ";", "}", "</s>" ]

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

[ "i386" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_bseti", "(", "rtx", "dst", ",", "int", "mask", ")", "{", "rtx", "out_operands", "[", "2", "]", ";", "int", "bit", ";", "out_operands", "[", "0", "]", "=", "dst", ";", "for", "(", "bit", "=", "0", ";", "bit", "<", "32", ";", "bit", "++", ")", "{", "if", "(", "(", "mask", "&", "0x1", ")", "==", "0x1", ")", "{", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "bit", ")", ";", "output_asm_insn", "(", "\"bseti\\t%0,%1\"", ",", "out_operands", ")", ";", "}", "mask", ">>=", "1", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "series", "of", "bseti", "'s", "corresponding", "to", "mask", "." ]

[ "mcore", "2", "0", "0", "32", "0x1", "0x1", "1", "\"bseti\\t%0,%1\"", "1", "\"\"" ]

[]

[ "<s>", "void", "HexagonDCE", "::", "removeOperand", "(", "NodeAddr", "<", "InstrNode", "*", ">", "IA", ",", "unsigned", "OpNum", ")", "{", "MachineInstr", "*", "MI", "=", "NodeAddr", "<", "StmtNode", "*", ">", "(", "IA", ")", ".", "Addr", "->", "getCode", "(", ")", ";", "auto", "getOpNum", "=", "[", "MI", "]", "(", "MachineOperand", "&", "Op", ")", "->", "unsigned", "{", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "n", ";", "++", "i", ")", "if", "(", "&", "MI", "->", "getOperand", "(", "i", ")", "==", "&", "Op", ")", "return", "i", ";", "llvm_unreachable", "(", "\"Invalid operand\"", ")", ";", "}", ";", "DenseMap", "<", "NodeId", ",", "unsigned", ">", "OpMap", ";", "DataFlowGraph", "&", "DFG", "=", "getDFG", "(", ")", ";", "NodeList", "Refs", "=", "IA", ".", "Addr", "->", "members", "(", "DFG", ")", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "Refs", ")", "OpMap", ".", "insert", "(", "std", "::", "make_pair", "(", "RA", ".", "Id", ",", "getOpNum", "(", "RA", ".", "Addr", "->", "getOp", "(", ")", ")", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "OpNum", ")", ";", "for", "(", "NodeAddr", "<", "RefNode", "*", ">", "RA", ":", "Refs", ")", "{", "unsigned", "N", "=", "OpMap", "[", "RA", ".", "Id", "]", ";", "if", "(", "N", "<", "OpNum", ")", "RA", ".", "Addr", "->", "setRegRef", "(", "&", "MI", "->", "getOperand", "(", "N", ")", ",", "DFG", ")", ";", "else", "if", "(", "N", ">", "OpNum", ")", "RA", ".", "Addr", "->", "setRegRef", "(", "&", "MI", "->", "getOperand", "(", "N", "-", "1", ")", ",", "DFG", ")", ";", "}", "}", "</s>" ]

[ "Erase", "an", "operand", "from", "an", "instruction", ",", "leaving", "it", "with", "one", "fewer", "operand", "than", "it", "started", "with", "." ]

[ "Hexagon", "Hexagon", "0", "\"Invalid operand\"", "1" ]

[]

[ "<s>", "bool", "WebAssemblyCFGSort", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** CFG Sorting **********\\n\"", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "const", "auto", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "const", "auto", "&", "WEI", "=", "getAnalysis", "<", "WebAssemblyExceptionInfo", ">", "(", ")", ";", "auto", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "MF", ".", "getRegInfo", "(", ")", ".", "invalidateLiveness", "(", ")", ";", "SortBlocks", "(", "MF", ",", "MLI", ",", "WEI", ",", "MDT", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "\"********** CFG Sorting **********\\n\"", "\"********** Function: \"", "WebAssembly" ]

[]

[ "<s>", "bool", "X86FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "ArrayRef", "<", "CalleeSavedInfo", ">", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "if", "(", "MBB", ".", "isEHFuncletEntry", "(", ")", "&&", "STI", ".", "is32Bit", "(", ")", "&&", "STI", ".", "isOSWindows", "(", ")", ")", "return", "true", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "unsigned", "Opc", "=", "STI", ".", "is64Bit", "(", ")", "?", "X86", "::", "PUSH64r", ":", "X86", "::", "PUSH32r", ";", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "!", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "&&", "!", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "const", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "isLiveIn", "=", "MRI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "bool", "CanKill", "=", "!", "isLiveIn", ";", "if", "(", "CanKill", ")", "{", "for", "(", "MCRegAliasIterator", "AReg", "(", "Reg", ",", "TRI", ",", "false", ")", ";", "AReg", ".", "isValid", "(", ")", ";", "++", "AReg", ")", "{", "if", "(", "MRI", ".", "isLiveIn", "(", "*", "AReg", ")", ")", "{", "CanKill", "=", "false", ";", "break", ";", "}", "}", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "CanKill", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "for", "(", "const", "CalleeSavedInfo", "&", "I", ":", "llvm", "::", "reverse", "(", "CSI", ")", ")", "{", "Register", "Reg", "=", "I", ".", "getReg", "(", ")", ";", "if", "(", "X86", "::", "GR64RegClass", ".", "contains", "(", "Reg", ")", "||", "X86", "::", "GR32RegClass", ".", "contains", "(", "Reg", ")", ")", "continue", ";", "MVT", "VT", "=", "MVT", "::", "Other", ";", "if", "(", "X86", "::", "VK16RegClass", ".", "contains", "(", "Reg", ")", ")", "VT", "=", "STI", ".", "hasBWI", "(", ")", "?", "MVT", "::", "v64i1", ":", "MVT", "::", "v16i1", ";", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ",", "VT", ")", ";", "TII", ".", "storeRegToStackSlot", "(", "MBB", ",", "MI", ",", "Reg", ",", "true", ",", "I", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "--", "MI", ";", "MI", "->", "setFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "++", "MI", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "X86", "X86", "X86::PUSH64r", "X86::PUSH32r", "X86::GR64RegClass", "X86::GR32RegClass", "X86::GR64RegClass", "X86::GR32RegClass", "MVT::Other", "X86::VK16RegClass", "MVT::v64i1", "MVT::v16i1" ]

[]

[ "<s>", "void", "execute_tag_collision_avoidance", "(", ")", "{", "struct", "loop", "*", "loop", ";", "df_set_flags", "(", "DF_RD_PRUNE_DEAD_DEFS", ")", ";", "df_chain_add_problem", "(", "DF_UD_CHAIN", ")", ";", "df_compute_regs_ever_live", "(", "true", ")", ";", "df_note_add_problem", "(", ")", ";", "df_analyze", "(", ")", ";", "df_set_flags", "(", "DF_DEFER_INSN_RESCAN", ")", ";", "regrename_init", "(", "true", ")", ";", "regrename_analyze", "(", "NULL", ")", ";", "compute_bb_for_insn", "(", ")", ";", "calculate_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "loop_optimizer_init", "(", "AVOID_CFG_MODIFICATIONS", ")", ";", "FOR_EACH_LOOP", "(", "loop", ",", "LI_FROM_INNERMOST", ")", "{", "tag_map_t", "tag_map", "(", "512", ")", ";", "record_loads", "(", "tag_map", ",", "loop", ")", ";", "avoid_collisions", "(", "tag_map", ")", ";", "if", "(", "dump_file", ")", "{", "fprintf", "(", "dump_file", ",", "\"Loop %d: Completed rename.\\n\"", ",", "loop", "->", "num", ")", ";", "tag_map", ".", "traverse", "<", "void", "*", ",", "dump_insn_list", ">", "(", "NULL", ")", ";", "}", "tag_map", ".", "traverse", "<", "void", "*", ",", "free_insn_info", ">", "(", "NULL", ")", ";", "}", "loop_optimizer_finalize", "(", ")", ";", "free_dominance_info", "(", "CDI_DOMINATORS", ")", ";", "regrename_finish", "(", ")", ";", "}", "</s>" ]

[ "Tag", "collision", "avoidance", "pass", "for", "Falkor", ".", "The", "pass", "runs", "in", "two", "phases", "for", "each", "loop", ";", "the", "first", "phase", "collects", "all", "loads", "that", "we", "consider", "as", "interesting", "for", "renaming", "into", "a", "tag-indexed", "map", "of", "lists", ".", "The", "second", "phase", "renames", "the", "destination", "register", "of", "the", "loads", "in", "an", "attempt", "to", "spread", "out", "the", "loads", "into", "different", "tags", "." ]

[ "aarch64", "512", "\"Loop %d: Completed rename.\\n\"" ]

[]

[ "<s>", "int", "cpat_const_p", "(", "rtx", "x", ",", "machine_mode", "mode", ")", "{", "if", "(", "CONSTANT_P", "(", "x", ")", ")", "{", "enum", "immediate_class", "c", "=", "classify_immediate", "(", "x", ",", "mode", ")", ";", "return", "c", "==", "IC_CPAT", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "x", "is", "a", "CONST_INT", ",", "CONST_DOUBLE", "or", "CONST_VECTOR", "that", "can", "be", "generated", "using", "the", "cbd", ",", "chd", ",", "cwd", "or", "cdd", "instruction", "." ]

[ "spu", "0" ]

[]

[ "<s>", "static", "bool", "s390_lra_p", "(", "void", ")", "{", "return", "s390_lra_flag", ";", "}", "</s>" ]

[ "Return", "true", "if", "we", "use", "LRA", "instead", "of", "reload", "pass", "." ]

[ "s390" ]

[]

[ "<s>", "void", "Z80InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "bool", "MOSStaticStackAlloc", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "MachineModuleInfo", "&", "MMI", "=", "getAnalysis", "<", "MachineModuleInfoWrapperPass", ">", "(", ")", ".", "getMMI", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "MachineFunction", "*", "MF", "=", "MMI", ".", "getMachineFunction", "(", "F", ")", ";", "if", "(", "!", "MF", ")", "continue", ";", "const", "MOSFrameLowering", "&", "TFL", "=", "*", "MF", "->", "getSubtarget", "<", "MOSSubtarget", ">", "(", ")", ".", "getFrameLowering", "(", ")", ";", "uint64_t", "Size", "=", "TFL", ".", "staticSize", "(", "MF", "->", "getFrameInfo", "(", ")", ")", ";", "if", "(", "!", "Size", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found static stack for \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Size \"", "<<", "Size", "<<", "\"\\n\"", ")", ";", "Type", "*", "Typ", "=", "ArrayType", "::", "get", "(", "Type", "::", "getInt8Ty", "(", "M", ".", "getContext", "(", ")", ")", ",", "Size", ")", ";", "GlobalVariable", "*", "Stack", "=", "new", "GlobalVariable", "(", "M", ",", "Typ", ",", "false", ",", "GlobalValue", "::", "PrivateLinkage", ",", "UndefValue", "::", "get", "(", "Typ", ")", ",", "Twine", "(", "F", ".", "getName", "(", ")", ")", "+", "\"_sstk\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Allocated: \"", "<<", "*", "Stack", "<<", "\"\\n\"", ")", ";", "Changed", "=", "true", ";", "MOSFunctionInfo", "&", "MFI", "=", "*", "MF", "->", "getInfo", "<", "MOSFunctionInfo", ">", "(", ")", ";", "MFI", ".", "setStaticStackVariable", "(", "Stack", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "*", "MF", ")", "{", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "{", "for", "(", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isTargetIndex", "(", ")", ")", "continue", ";", "MO", ".", "ChangeToGA", "(", "Stack", ",", "MO", ".", "getOffset", "(", ")", ",", "MO", ".", "getTargetFlags", "(", ")", ")", ";", "}", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "MOS", "MOS", "MOS", "MOS", "\"Found static stack for \"", "\"\\n\"", "\"Size \"", "\"\\n\"", "\"_sstk\"", "\"Allocated: \"", "\"\\n\"", "MOS", "MOS" ]

[]

[ "<s>", "bool", "SystemZDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "assert", "(", "ConstraintCode", "==", "'m'", "&&", "\"Unexpected constraint code\"", ")", ";", "SDValue", "Base", ",", "Disp", ",", "Index", ";", "if", "(", "!", "selectBDXAddr", "(", "SystemZAddressingMode", "::", "FormBD", ",", "SystemZAddressingMode", "::", "Disp12Only", ",", "Op", ",", "Base", ",", "Disp", ",", "Index", ")", ")", "return", "true", ";", "OutOps", ".", "push_back", "(", "Base", ")", ";", "OutOps", ".", "push_back", "(", "Disp", ")", ";", "OutOps", ".", "push_back", "(", "Index", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "SystemZ", "SystemZ", "\"Unexpected constraint code\"", "SystemZAddressingMode::FormBD", "SystemZAddressingMode::Disp12Only" ]

[]

[ "<s>", "static", "bool", "loongarch_classify_address", "(", "struct", "loongarch_address_info", "*", "info", ",", "rtx", "x", ",", "machine_mode", "mode", ",", "bool", "strict_p", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "REG", ":", "case", "SUBREG", ":", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "x", ";", "info", "->", "offset", "=", "const0_rtx", ";", "return", "loongarch_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", ";", "case", "PLUS", ":", "if", "(", "loongarch_valid_base_register_p", "(", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_index_p", "(", "info", ",", "XEXP", "(", "x", ",", "1", ")", ",", "mode", ",", "strict_p", ")", ")", "{", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "return", "true", ";", "}", "if", "(", "loongarch_valid_base_register_p", "(", "XEXP", "(", "x", ",", "1", ")", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_index_p", "(", "info", ",", "XEXP", "(", "x", ",", "0", ")", ",", "mode", ",", "strict_p", ")", ")", "{", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "true", ";", "}", "info", "->", "type", "=", "ADDRESS_REG", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "return", "(", "loongarch_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_offset_p", "(", "info", "->", "offset", ",", "mode", ")", ")", ";", "case", "LO_SUM", ":", "info", "->", "type", "=", "ADDRESS_LO_SUM", ";", "info", "->", "reg", "=", "XEXP", "(", "x", ",", "0", ")", ";", "info", "->", "offset", "=", "XEXP", "(", "x", ",", "1", ")", ";", "info", "->", "symbol_type", "=", "loongarch_classify_symbolic_expression", "(", "info", "->", "offset", ")", ";", "return", "(", "loongarch_valid_base_register_p", "(", "info", "->", "reg", ",", "mode", ",", "strict_p", ")", "&&", "loongarch_valid_lo_sum_p", "(", "info", "->", "symbol_type", ",", "mode", ",", "info", "->", "offset", ")", ")", ";", "case", "CONST_INT", ":", "info", "->", "type", "=", "ADDRESS_CONST_INT", ";", "return", "IMM12_OPERAND", "(", "INTVAL", "(", "x", ")", ")", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "valid", "address", "for", "machine", "mode", "MODE", ".", "If", "it", "is", ",", "fill", "in", "INFO", "appropriately", ".", "STRICT_P", "is", "true", "if", "REG_OK_STRICT", "is", "in", "effect", "." ]

[ "loongarch", "0", "1", "0", "1", "0", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "LinearizedRegion", "::", "setEntry", "(", "MachineBasicBlock", "*", "NewEntry", ")", "{", "Entry", "=", "NewEntry", ";", "}", "</s>" ]

[ "Set", "EntryBlock", "as", "the", "entry", "VPBlockBase", "of", "this", "VPRegionBlock", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "outliner", "::", "InstrType", "X86InstrInfo", "::", "getOutliningType", "(", "MachineBasicBlock", "::", "iterator", "&", "MIT", ",", "unsigned", "Flags", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "MIT", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isIndirectDebugValue", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "if", "(", "MI", ".", "isKill", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Invisible", ";", "if", "(", "isTailCall", "(", "MI", ")", ")", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "if", "(", "MI", ".", "isTerminator", "(", ")", "||", "MI", ".", "isReturn", "(", ")", ")", "{", "if", "(", "MI", ".", "getParent", "(", ")", "->", "succ_empty", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "}", "if", "(", "MI", ".", "modifiesRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "readsRegister", "(", "X86", "::", "RSP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RSP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RSP", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "readsRegister", "(", "X86", "::", "RIP", ",", "&", "RI", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitUseOfPhysReg", "(", "X86", "::", "RIP", ")", "||", "MI", ".", "getDesc", "(", ")", ".", "hasImplicitDefOfPhysReg", "(", "X86", "::", "RIP", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "if", "(", "MI", ".", "isPosition", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "for", "(", "const", "MachineOperand", "&", "MOP", ":", "MI", ".", "operands", "(", ")", ")", "if", "(", "MOP", ".", "isCPI", "(", ")", "||", "MOP", ".", "isJTI", "(", ")", "||", "MOP", ".", "isCFIIndex", "(", ")", "||", "MOP", ".", "isFI", "(", ")", "||", "MOP", ".", "isTargetIndex", "(", ")", ")", "return", "outliner", "::", "InstrType", "::", "Illegal", ";", "return", "outliner", "::", "InstrType", "::", "Legal", ";", "}", "</s>" ]

[ "Returns", "how", "or", "if", "MIT", "should", "be", "outlined", "." ]

[ "X86", "X86", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RSP", "X86::RIP", "X86::RIP", "X86::RIP" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "(", "!", "IsMemset", "||", "ZeroMemset", ")", "&&", "!", "F", "->", "getAttributes", "(", ")", ".", "hasAttribute", "(", "AttributeSet", "::", "FunctionIndex", ",", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", ")", "{", "if", "(", "Size", ">=", "32", ")", "{", "if", "(", "Subtarget", "->", "hasInt256", "(", ")", ")", "return", "MVT", "::", "v8i32", ";", "if", "(", "Subtarget", "->", "hasFp256", "(", ")", ")", "return", "MVT", "::", "v8f32", ";", "}", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "32", "MVT::v8i32", "MVT::v8f32", "MVT::v4i32", "MVT::v4f32", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "bool", "R600VectorRegMerger", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "const", "R600Subtarget", "&", "ST", "=", "Fn", ".", "getSubtarget", "<", "R600Subtarget", ">", "(", ")", ";", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "*", "MB", "=", "&", "*", "MBB", ";", "PreviousRegSeq", ".", "clear", "(", ")", ";", "PreviousRegSeqByReg", ".", "clear", "(", ")", ";", "PreviousRegSeqByUndefCount", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MII", "=", "MB", "->", "begin", "(", ")", ",", "MIIE", "=", "MB", "->", "end", "(", ")", ";", "MII", "!=", "MIIE", ";", "++", "MII", ")", "{", "MachineInstr", "&", "MI", "=", "*", "MII", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "!=", "AMDGPU", "::", "REG_SEQUENCE", ")", "{", "if", "(", "TII", "->", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "TSFlags", "&", "R600_InstFlag", "::", "TEX_INST", ")", "{", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "for", "(", "MachineRegisterInfo", "::", "def_instr_iterator", "It", "=", "MRI", "->", "def_instr_begin", "(", "Reg", ")", ",", "E", "=", "MRI", "->", "def_instr_end", "(", ")", ";", "It", "!=", "E", ";", "++", "It", ")", "{", "RemoveMI", "(", "&", "(", "*", "It", ")", ")", ";", "}", "}", "continue", ";", "}", "RegSeqInfo", "RSI", "(", "*", "MRI", ",", "&", "MI", ")", ";", "unsigned", "Reg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "!", "areAllUsesSwizzeable", "(", "Reg", ")", ")", "continue", ";", "DEBUG", "(", "{", "dbgs", "(", ")", "<<", "\"Trying to optimize \"", ";", "MI", ".", "dump", "(", ")", ";", "}", ")", ";", "RegSeqInfo", "CandidateRSI", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "unsigned", ",", "unsigned", ">", ">", "RemapChan", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using common slots...\\n\"", ";", ")", ";", "if", "(", "tryMergeUsingCommonSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Using free slots...\\n\"", ";", ")", ";", "RemapChan", ".", "clear", "(", ")", ";", "if", "(", "tryMergeUsingFreeSlot", "(", "RSI", ",", "CandidateRSI", ",", "RemapChan", ")", ")", "{", "RemoveMI", "(", "CandidateRSI", ".", "Instr", ")", ";", "MII", "=", "RebuildVector", "(", "&", "RSI", ",", "&", "CandidateRSI", ",", "RemapChan", ")", ";", "trackRSI", "(", "RSI", ")", ";", "continue", ";", "}", "trackRSI", "(", "RSI", ")", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "R600", "R600", "R600", "AMDGPU::REG_SEQUENCE", "R600_InstFlag::TEX_INST", "1", "SI", "0", "\"Trying to optimize \"", "SI", "\"Using common slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "\"Using free slots...\\n\"", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI", "SI" ]

[]

[ "<s>", "enum", "reg_class", "nds32_regno_reg_class", "(", "int", "regno", ")", "{", "if", "(", "regno", ">=", "0", "&&", "regno", "<=", "7", ")", "return", "LOW_REGS", ";", "else", "if", "(", "regno", ">=", "8", "&&", "regno", "<=", "11", ")", "return", "MIDDLE_REGS", ";", "else", "if", "(", "regno", ">=", "12", "&&", "regno", "<=", "14", ")", "return", "HIGH_REGS", ";", "else", "if", "(", "regno", "==", "15", ")", "return", "R15_TA_REG", ";", "else", "if", "(", "regno", ">=", "16", "&&", "regno", "<=", "19", ")", "return", "MIDDLE_REGS", ";", "else", "if", "(", "regno", ">=", "20", "&&", "regno", "<=", "31", ")", "return", "HIGH_REGS", ";", "else", "if", "(", "regno", "==", "32", "||", "regno", "==", "33", ")", "{", "return", "GENERAL_REGS", ";", "}", "else", "if", "(", "regno", ">=", "34", "&&", "regno", "<=", "97", ")", "return", "FP_REGS", ";", "else", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Register", "Classes", "." ]

[ "nds32", "0", "7", "8", "11", "12", "14", "15", "16", "19", "20", "31", "32", "33", "34", "97" ]

[]

[ "<s>", "static", "bool", "aarch64_can_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "reg_class_t", ")", "{", "unsigned", "int", "from_flags", "=", "aarch64_classify_vector_mode", "(", "from", ")", ";", "unsigned", "int", "to_flags", "=", "aarch64_classify_vector_mode", "(", "to", ")", ";", "bool", "from_sve_p", "=", "(", "from_flags", "&", "VEC_ANY_SVE", ")", ";", "bool", "to_sve_p", "=", "(", "to_flags", "&", "VEC_ANY_SVE", ")", ";", "bool", "from_partial_sve_p", "=", "from_sve_p", "&&", "(", "from_flags", "&", "VEC_PARTIAL", ")", ";", "bool", "to_partial_sve_p", "=", "to_sve_p", "&&", "(", "to_flags", "&", "VEC_PARTIAL", ")", ";", "bool", "from_pred_p", "=", "(", "from_flags", "&", "VEC_SVE_PRED", ")", ";", "bool", "to_pred_p", "=", "(", "to_flags", "&", "VEC_SVE_PRED", ")", ";", "if", "(", "from_pred_p", "!=", "to_pred_p", ")", "return", "false", ";", "if", "(", "from_partial_sve_p", "!=", "to_partial_sve_p", ")", "return", "false", ";", "if", "(", "from_partial_sve_p", "&&", "(", "aarch64_sve_container_bits", "(", "from", ")", "!=", "aarch64_sve_container_bits", "(", "to", ")", "||", "GET_MODE_UNIT_SIZE", "(", "from", ")", "!=", "GET_MODE_UNIT_SIZE", "(", "to", ")", ")", ")", "return", "false", ";", "if", "(", "maybe_ne", "(", "BITS_PER_SVE_VECTOR", ",", "128u", ")", ")", "{", "if", "(", "from_sve_p", "&&", "!", "to_sve_p", "&&", "maybe_gt", "(", "GET_MODE_BITSIZE", "(", "to", ")", ",", "128", ")", ")", "return", "false", ";", "if", "(", "to_sve_p", "&&", "!", "from_sve_p", "&&", "maybe_gt", "(", "GET_MODE_BITSIZE", "(", "from", ")", ",", "128", ")", ")", "return", "false", ";", "}", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "if", "(", "from_sve_p", "!=", "to_sve_p", ")", "return", "false", ";", "if", "(", "from_sve_p", "&&", "GET_MODE_UNIT_SIZE", "(", "from", ")", "!=", "GET_MODE_UNIT_SIZE", "(", "to", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Implement", "TARGET_CAN_CHANGE_MODE_CLASS", "." ]

[ "aarch64", "128u", "128", "128" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isHighLatencyDef", "(", "int", "Opc", ")", "const", "{", "return", "get", "(", "Opc", ")", ".", "mayLoad", "(", ")", "&&", "(", "isMUBUF", "(", "Opc", ")", "||", "isMTBUF", "(", "Opc", ")", "||", "isMIMG", "(", "Opc", ")", "||", "isFLAT", "(", "Opc", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "opcode", "has", "high", "latency", "to", "its", "result", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "Register", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "if", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", "{", "FrameIdx", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", "->", "getCRSpillFrameIndex", "(", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "PowerPC", "PPC", "PPC::CR2", "PPC::CR4", "PPC" ]

[]

[ "<s>", "void", "SIInstrInfo", "::", "legalizeOpWithMove", "(", "MachineInstr", "&", "MI", ",", "unsigned", "OpIdx", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ";", "MachineBasicBlock", "*", "MBB", "=", "MI", ".", "getParent", "(", ")", ";", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpIdx", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MBB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "RCID", "=", "get", "(", "MI", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "OpIdx", "]", ".", "RegClass", ";", "const", "TargetRegisterClass", "*", "RC", "=", "RI", ".", "getRegClass", "(", "RCID", ")", ";", "unsigned", "Opcode", "=", "AMDGPU", "::", "V_MOV_B32_e32", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "Opcode", "=", "AMDGPU", "::", "COPY", ";", "else", "if", "(", "RI", ".", "isSGPRClass", "(", "RC", ")", ")", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "const", "TargetRegisterClass", "*", "VRC", "=", "RI", ".", "getEquivalentVGPRClass", "(", "RC", ")", ";", "if", "(", "RI", ".", "getCommonSubClass", "(", "&", "AMDGPU", "::", "VReg_64RegClass", ",", "VRC", ")", ")", "VRC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "else", "VRC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "VRC", ")", ";", "DebugLoc", "DL", "=", "MBB", "->", "findDebugLoc", "(", "I", ")", ";", "BuildMI", "(", "*", "MI", ".", "getParent", "(", ")", ",", "I", ",", "DL", ",", "get", "(", "Opcode", ")", ",", "Reg", ")", ".", "add", "(", "MO", ")", ";", "MO", ".", "ChangeToRegister", "(", "Reg", ",", "false", ")", ";", "}", "</s>" ]

[ "Legalize", "the", "OpIndex", "operand", "of", "this", "instruction", "by", "inserting", "a", "MOV", "." ]

[ "AMDGPU", "SI", "AMDGPU::V_MOV_B32_e32", "AMDGPU::COPY", "AMDGPU::S_MOV_B32", "AMDGPU::VReg_64RegClass", "AMDGPU::VReg_64RegClass", "AMDGPU::VGPR_32RegClass" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "if", "(", "CC", "==", "CallingConv", "::", "GHC", ")", "return", "CSR_AArch64_NoRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "AnyReg", ")", "return", "CSR_AArch64_AllRegs_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "CXX_FAST_TLS", ")", "return", "CSR_AArch64_CXX_TLS_Darwin_RegMask", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", ".", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_AArch64_AAPCS_SwiftError_RegMask", ";", "if", "(", "CC", "==", "CallingConv", "::", "PreserveMost", ")", "return", "CSR_AArch64_RT_MostRegs_RegMask", ";", "else", "return", "CSR_AArch64_AAPCS_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PPCFastISel", "::", "fastSelectInstruction", "(", "const", "Instruction", "*", "I", ")", "{", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Load", ":", "return", "SelectLoad", "(", "I", ")", ";", "case", "Instruction", "::", "Store", ":", "return", "SelectStore", "(", "I", ")", ";", "case", "Instruction", "::", "Br", ":", "return", "SelectBranch", "(", "I", ")", ";", "case", "Instruction", "::", "IndirectBr", ":", "return", "SelectIndirectBr", "(", "I", ")", ";", "case", "Instruction", "::", "FPExt", ":", "return", "SelectFPExt", "(", "I", ")", ";", "case", "Instruction", "::", "FPTrunc", ":", "return", "SelectFPTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "SIToFP", ":", "return", "SelectIToFP", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "UIToFP", ":", "return", "SelectIToFP", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "FPToSI", ":", "return", "SelectFPToI", "(", "I", ",", "true", ")", ";", "case", "Instruction", "::", "FPToUI", ":", "return", "SelectFPToI", "(", "I", ",", "false", ")", ";", "case", "Instruction", "::", "Add", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "ADD", ")", ";", "case", "Instruction", "::", "Or", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "OR", ")", ";", "case", "Instruction", "::", "Sub", ":", "return", "SelectBinaryIntOp", "(", "I", ",", "ISD", "::", "SUB", ")", ";", "case", "Instruction", "::", "Call", ":", "return", "selectCall", "(", "I", ")", ";", "case", "Instruction", "::", "Ret", ":", "return", "SelectRet", "(", "I", ")", ";", "case", "Instruction", "::", "Trunc", ":", "return", "SelectTrunc", "(", "I", ")", ";", "case", "Instruction", "::", "ZExt", ":", "case", "Instruction", "::", "SExt", ":", "return", "SelectIntExt", "(", "I", ")", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "by", "target-independent", "code", "when", "the", "normal", "FastISel", "process", "fails", "to", "select", "an", "instruction", "." ]

[ "PowerPC", "PPC", "ISD::ADD", "ISD::OR", "ISD::SUB" ]

[]

[ "<s>", "static", "void", "nvptx_file_end", "(", "void", ")", "{", "hash_table", "<", "tree_hasher", ">", "::", "iterator", "iter", ";", "tree", "decl", ";", "FOR_EACH_HASH_TABLE_ELEMENT", "(", "*", "needed_fndecls_htab", ",", "decl", ",", "tree", ",", "iter", ")", "nvptx_record_fndecl", "(", "decl", ",", "true", ")", ";", "fputs", "(", "func_decls", ".", "str", "(", ")", ".", "c_str", "(", ")", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Write", "out", "the", "function", "declarations", "we", "'ve", "collected", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "tree", "arm_handle_notshared_attribute", "(", "tree", "*", "node", ",", "tree", "name", "ATTRIBUTE_UNUSED", ",", "tree", "args", "ATTRIBUTE_UNUSED", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "tree", "decl", "=", "TYPE_NAME", "(", "*", "node", ")", ";", "if", "(", "decl", ")", "{", "DECL_VISIBILITY", "(", "decl", ")", "=", "VISIBILITY_HIDDEN", ";", "DECL_VISIBILITY_SPECIFIED", "(", "decl", ")", "=", "1", ";", "*", "no_add_attrs", "=", "false", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Handle", "the", "``", "notshared", "''", "attribute", ".", "This", "attribute", "is", "another", "way", "of", "requesting", "hidden", "visibility", ".", "ARM", "'s", "compiler", "supports", "``", "__declspec", "(", "notshared", ")", "''", ";", "we", "support", "the", "same", "thing", "via", "an", "attribute", "." ]

[ "arm", "1" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "MachineMemOperand", "::", "Flags", ",", "const", "char", "*", ">>", "AArch64InstrInfo", "::", "getSerializableMachineMemOperandTargetFlags", "(", ")", "const", "{", "static", "const", "std", "::", "pair", "<", "MachineMemOperand", "::", "Flags", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MOSuppressPair", ",", "\"aarch64-suppress-pair\"", "}", ",", "{", "MOStridedAccess", ",", "\"aarch64-strided-access\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "MMO", "target", "flag", "values", "and", "their", "names", "." ]

[ "AArch64", "AArch64", "\"aarch64-suppress-pair\"", "\"aarch64-strided-access\"" ]

[]

[ "<s>", "bool", "PPCAsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ")", ";", "else", "if", "(", "IDVal", "==", "\".llong\"", ")", "ParseDirectiveWord", "(", "8", ",", "DirectiveID", ")", ";", "else", "if", "(", "IDVal", "==", "\".tc\"", ")", "ParseDirectiveTC", "(", "isPPC64", "(", ")", "?", "8", ":", "4", ",", "DirectiveID", ")", ";", "else", "if", "(", "IDVal", "==", "\".machine\"", ")", "ParseDirectiveMachine", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".abiversion\"", ")", "ParseDirectiveAbiVersion", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", "==", "\".localentry\"", ")", "ParseDirectiveLocalEntry", "(", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "PowerPC", "PPC", "\".word\"", "2", "\".llong\"", "8", "\".tc\"", "PPC", "8", "4", "\".machine\"", "\".abiversion\"", "\".localentry\"" ]

[]

[ "<s>", "static", "bool", "isValidOffset", "(", "RISCVAddressingMode", "::", "OffRange", "OffR", ",", "int64_t", "Val", ")", "{", "assert", "(", "selectOffset", "(", "OffR", ",", "Val", ")", "&&", "\"Invalid displacement\"", ")", ";", "switch", "(", "OffR", ")", "{", "case", "RISCVAddressingMode", "::", "Off12Only", ":", "return", "true", ";", "}", "llvm_unreachable", "(", "\"Unhandled displacement range\"", ")", ";", "}", "</s>" ]

[ "Test", "the", "validity", "of", "offset", "." ]

[ "RISCV", "RISCVAddressingMode::OffRange", "\"Invalid displacement\"", "RISCVAddressingMode::Off12Only", "\"Unhandled displacement range\"" ]

[]

[ "<s>", "BitVector", "AVRRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R0", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R1", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R1R0", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SPL", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SPH", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "SP", ")", ";", "if", "(", "MF", ".", "getSubtarget", "<", "AVRSubtarget", ">", "(", ")", ".", "hasTinyEncoding", "(", ")", ")", "{", "for", "(", "unsigned", "Reg", "=", "AVR", "::", "R2", ";", "Reg", "<=", "AVR", "::", "R17", ";", "Reg", "++", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "for", "(", "unsigned", "Reg", "=", "AVR", "::", "R3R2", ";", "Reg", "<=", "AVR", "::", "R18R17", ";", "Reg", "++", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "}", "Reserved", ".", "set", "(", "AVR", "::", "R28", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "AVR", "::", "R29R28", ")", ";", "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", "." ]

[ "AVR", "AVR", "AVR::R0", "AVR::R1", "AVR::R1R0", "AVR::SPL", "AVR::SPH", "AVR::SP", "AVR", "AVR::R2", "AVR::R17", "AVR::R3R2", "AVR::R18R17", "AVR::R28", "AVR::R29", "AVR::R29R28" ]

[]

[ "<s>", "void", "mn10300_override_options", "(", "void", ")", "{", "if", "(", "TARGET_AM33", ")", "target_flags", "&=", "~", "MASK_MULT_BUG", ";", "}", "</s>" ]

[ "Implement", "OVERRIDE_OPTIONS", "." ]

[ "mn10300" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "const", "MemOp", "&", "Op", ",", "const", "AttributeList", "&", "FuncAttributes", ")", "const", "{", "if", "(", "!", "FuncAttributes", ".", "hasFnAttribute", "(", "Attribute", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Op", ".", "size", "(", ")", ">=", "16", "&&", "(", "!", "Subtarget", ".", "isUnalignedMem16Slow", "(", ")", "||", "Op", ".", "isAligned", "(", "Align", "(", "16", ")", ")", ")", ")", "{", "if", "(", "Op", ".", "size", "(", ")", ">=", "64", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "512", ")", ")", "{", "return", "Subtarget", ".", "hasBWI", "(", ")", "?", "MVT", "::", "v64i8", ":", "MVT", "::", "v16i32", ";", "}", "if", "(", "Op", ".", "size", "(", ")", ">=", "32", "&&", "Subtarget", ".", "hasAVX", "(", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "256", ")", ")", "{", "return", "MVT", "::", "v32i8", ";", "}", "if", "(", "Subtarget", ".", "hasSSE2", "(", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "128", ")", ")", "return", "MVT", "::", "v16i8", ";", "if", "(", "Subtarget", ".", "hasSSE1", "(", ")", "&&", "(", "Subtarget", ".", "is64Bit", "(", ")", "||", "Subtarget", ".", "hasX87", "(", ")", ")", "&&", "(", "Subtarget", ".", "getPreferVectorWidth", "(", ")", ">=", "128", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "(", "(", "Op", ".", "isMemcpy", "(", ")", "&&", "!", "Op", ".", "isMemcpyStrSrc", "(", ")", ")", "||", "Op", ".", "isZeroMemset", "(", ")", ")", "&&", "Op", ".", "size", "(", ")", ">=", "8", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Subtarget", ".", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", ".", "is64Bit", "(", ")", "&&", "Op", ".", "size", "(", ")", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "16", "64", "512", "MVT::v64i8", "MVT::v16i32", "32", "256", "MVT::v32i8", "128", "MVT::v16i8", "128", "MVT::v4f32", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vuzp", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "odd", ",", "mask", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "out0", ",", "out1", ",", "in0", ",", "in1", ",", "x", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "if", "(", "GET_MODE_UNIT_SIZE", "(", "d", "->", "vmode", ")", ">=", "8", ")", "return", "false", ";", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "0", ")", "odd", "=", "0", ";", "else", "if", "(", "d", "->", "perm", "[", "0", "]", "==", "1", ")", "odd", "=", "1", ";", "else", "return", "false", ";", "mask", "=", "(", "d", "->", "one_vector_p", "?", "nelt", "-", "1", ":", "2", "*", "nelt", "-", "1", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "++", ")", "{", "unsigned", "elt", "=", "(", "i", "*", "2", "+", "odd", ")", "&", "mask", ";", "if", "(", "d", "->", "perm", "[", "i", "]", "!=", "elt", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vuzpv16qi_internal", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vuzpv8qi_internal", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vuzpv8hi_internal", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vuzpv4hi_internal", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vuzpv4si_internal", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vuzpv2si_internal", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vuzpv2sf_internal", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vuzpv4sf_internal", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "in0", "=", "d", "->", "op0", ";", "in1", "=", "d", "->", "op1", ";", "if", "(", "BYTES_BIG_ENDIAN", ")", "{", "x", "=", "in0", ",", "in0", "=", "in1", ",", "in1", "=", "x", ";", "odd", "=", "!", "odd", ";", "}", "out0", "=", "d", "->", "target", ";", "out1", "=", "gen_reg_rtx", "(", "d", "->", "vmode", ")", ";", "if", "(", "odd", ")", "x", "=", "out0", ",", "out0", "=", "out1", ",", "out1", "=", "x", ";", "emit_insn", "(", "gen", "(", "out0", ",", "in0", ",", "in1", ",", "out1", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VUZP", "insns", "." ]

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

[]

[ "<s>", "SDValue", "RISCVTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "RISCVISD", "::", "SplitF64", ":", "{", "SDValue", "Op0", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "Op0", "->", "getOpcode", "(", ")", "==", "RISCVISD", "::", "BuildPairF64", ")", "return", "DCI", ".", "CombineTo", "(", "N", ",", "Op0", ".", "getOperand", "(", "0", ")", ",", "Op0", ".", "getOperand", "(", "1", ")", ")", ";", "SDLoc", "DL", "(", "N", ")", ";", "if", "(", "!", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FNEG", "||", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FABS", ")", "||", "!", "Op0", ".", "getNode", "(", ")", "->", "hasOneUse", "(", ")", ")", "break", ";", "SDValue", "NewSplitF64", "=", "DAG", ".", "getNode", "(", "RISCVISD", "::", "SplitF64", ",", "DL", ",", "DAG", ".", "getVTList", "(", "MVT", "::", "i32", ",", "MVT", "::", "i32", ")", ",", "Op0", ".", "getOperand", "(", "0", ")", ")", ";", "SDValue", "Lo", "=", "NewSplitF64", ".", "getValue", "(", "0", ")", ";", "SDValue", "Hi", "=", "NewSplitF64", ".", "getValue", "(", "1", ")", ";", "APInt", "SignBit", "=", "APInt", "::", "getSignMask", "(", "32", ")", ";", "if", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FNEG", ")", "{", "SDValue", "NewHi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "XOR", ",", "DL", ",", "MVT", "::", "i32", ",", "Hi", ",", "DAG", ".", "getConstant", "(", "SignBit", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DCI", ".", "CombineTo", "(", "N", ",", "Lo", ",", "NewHi", ")", ";", "}", "assert", "(", "Op0", ".", "getOpcode", "(", ")", "==", "ISD", "::", "FABS", ")", ";", "SDValue", "NewHi", "=", "DAG", ".", "getNode", "(", "ISD", "::", "AND", ",", "DL", ",", "MVT", "::", "i32", ",", "Hi", ",", "DAG", ".", "getConstant", "(", "~", "SignBit", ",", "DL", ",", "MVT", "::", "i32", ")", ")", ";", "return", "DCI", ".", "CombineTo", "(", "N", ",", "Lo", ",", "NewHi", ")", ";", "}", "case", "RISCVISD", "::", "SLLW", ":", "case", "RISCVISD", "::", "SRAW", ":", "case", "RISCVISD", "::", "SRLW", ":", "{", "SDValue", "LHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "RHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "APInt", "LHSMask", "=", "APInt", "::", "getLowBitsSet", "(", "LHS", ".", "getValueSizeInBits", "(", ")", ",", "32", ")", ";", "APInt", "RHSMask", "=", "APInt", "::", "getLowBitsSet", "(", "RHS", ".", "getValueSizeInBits", "(", ")", ",", "5", ")", ";", "if", "(", "(", "SimplifyDemandedBits", "(", "N", "->", "getOperand", "(", "0", ")", ",", "LHSMask", ",", "DCI", ")", ")", "||", "(", "SimplifyDemandedBits", "(", "N", "->", "getOperand", "(", "1", ")", ",", "RHSMask", ",", "DCI", ")", ")", ")", "return", "SDValue", "(", ")", ";", "break", ";", "}", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "RISCV", "RISCV", "RISCVISD::SplitF64", "0", "RISCVISD::BuildPairF64", "0", "1", "ISD::FNEG", "ISD::FABS", "RISCVISD::SplitF64", "MVT::i32", "MVT::i32", "0", "0", "1", "32", "ISD::FNEG", "ISD::XOR", "MVT::i32", "MVT::i32", "ISD::FABS", "ISD::AND", "MVT::i32", "MVT::i32", "RISCVISD::SLLW", "RISCVISD::SRAW", "RISCVISD::SRLW", "0", "1", "32", "5", "0", "1" ]

[]

[ "<s>", "unsigned", "char", "AArch64Subtarget", "::", "ClassifyGlobalReference", "(", "const", "GlobalValue", "*", "GV", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "&&", "isTargetMachO", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "Reloc", "::", "Model", "RM", "=", "TM", ".", "getRelocationModel", "(", ")", ";", "if", "(", "!", "shouldAssumeDSOLocal", "(", "RM", ",", "TargetTriple", ",", "*", "GV", "->", "getParent", "(", ")", ",", "GV", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "if", "(", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", "&&", "GV", "->", "hasExternalWeakLinkage", "(", ")", ")", "return", "AArch64II", "::", "MO_GOT", ";", "return", "AArch64II", "::", "MO_NO_FLAG", ";", "}", "</s>" ]

[ "ClassifyGlobalReference", "-", "Find", "the", "target", "operand", "flags", "that", "describe", "how", "a", "global", "value", "should", "be", "referenced", "for", "the", "current", "subtarget", "." ]

[ "AArch64", "AArch64", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_GOT", "AArch64II::MO_NO_FLAG" ]

[]

[ "<s>", "MachineBasicBlock", "::", "iterator", "SIFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "int64_t", "Amount", "=", "I", "->", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "if", "(", "Amount", "==", "0", ")", "return", "MBB", ".", "erase", "(", "I", ")", ";", "const", "SISubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "const", "SIInstrInfo", "*", "TII", "=", "ST", ".", "getInstrInfo", "(", ")", ";", "const", "DebugLoc", "&", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "bool", "IsDestroy", "=", "Opc", "==", "TII", "->", "getCallFrameDestroyOpcode", "(", ")", ";", "uint64_t", "CalleePopAmount", "=", "IsDestroy", "?", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ":", "0", ";", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "if", "(", "!", "TFI", "->", "hasReservedCallFrame", "(", "MF", ")", ")", "{", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "Amount", "=", "alignTo", "(", "Amount", ",", "Align", ")", ";", "assert", "(", "isUInt", "<", "32", ">", "(", "Amount", ")", "&&", "\"exceeded stack address space size\"", ")", ";", "const", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "unsigned", "SPReg", "=", "MFI", "->", "getStackPtrOffsetReg", "(", ")", ";", "unsigned", "Op", "=", "IsDestroy", "?", "AMDGPU", "::", "S_SUB_U32", ":", "AMDGPU", "::", "S_ADD_U32", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", "->", "get", "(", "Op", ")", ",", "SPReg", ")", ".", "addReg", "(", "SPReg", ")", ".", "addImm", "(", "Amount", "*", "ST", ".", "getWavefrontSize", "(", ")", ")", ";", "}", "else", "if", "(", "CalleePopAmount", "!=", "0", ")", "{", "llvm_unreachable", "(", "\"is this used?\"", ")", ";", "}", "return", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "AMDGPU", "SI", "0", "0", "SI", "SI", "SI", "1", "0", "32", "\"exceeded stack address space size\"", "SI", "SI", "AMDGPU::S_SUB_U32", "AMDGPU::S_ADD_U32", "0", "\"is this used?\"" ]

[]

[ "<s>", "SMLoc", "getOffsetOfLoc", "(", ")", "const", "{", "return", "OffsetOfLoc", ";", "}", "</s>" ]

[ "getOffsetOfLoc", "-", "Get", "the", "location", "of", "the", "offset", "operator", "." ]

[ "X86" ]

[]

[ "<s>", "virtual", "const", "TOYInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "TOY", "TOY" ]

[]

[ "<s>", "void", "XCoreTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Don't know how to custom expand this!\"", ")", ";", "return", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "Results", ".", "push_back", "(", "ExpandADDSUB", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "XCore", "XCore", "\"Don't know how to custom expand this!\"", "ISD::ADD", "ISD::SUB" ]

[]

[ "<s>", "bool", "TeakTargetLowering", "::", "CanLowerReturn", "(", "CallingConv", "::", "ID", "CallConv", ",", "MachineFunction", "&", "MF", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "LLVMContext", "&", "Context", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "MF", ",", "RVLocs", ",", "Context", ")", ";", "if", "(", "!", "CCInfo", ".", "CheckReturn", "(", "Outs", ",", "RetCC_Teak", ")", ")", "{", "return", "false", ";", "}", "if", "(", "CCInfo", ".", "getNextStackOffset", "(", ")", "!=", "0", "&&", "isVarArg", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "should", "be", "implemented", "to", "check", "whether", "the", "return", "values", "described", "by", "the", "Outs", "array", "can", "fit", "into", "the", "return", "registers", "." ]

[ "Teak", "Teak", "ISD::OutputArg", "16", "Teak", "0" ]

[]

[ "<s>", "rtx", "msp430_return_addr_rtx", "(", "int", "count", ")", "{", "int", "ra_size", ";", "if", "(", "count", ")", "return", "NULL_RTX", ";", "ra_size", "=", "TARGET_LARGE", "?", "4", ":", "2", ";", "if", "(", "crtl", "->", "args", ".", "pretend_args_size", ")", "ra_size", "+=", "2", ";", "return", "gen_rtx_MEM", "(", "Pmode", ",", "gen_rtx_PLUS", "(", "Pmode", ",", "arg_pointer_rtx", ",", "GEN_INT", "(", "-", "ra_size", ")", ")", ")", ";", "}", "</s>" ]

[ "Frame", "stuff", "." ]

[ "msp430", "4", "2", "2" ]

[]

[ "<s>", "unsigned", "getCSRFirstUseCost", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "5", ";", "}", "</s>" ]

[ "Allow", "the", "target", "to", "override", "the", "cost", "of", "using", "a", "callee-saved", "register", "for", "the", "first", "time", "." ]

[ "AArch64", "5" ]

[]

[ "<s>", "MachineBasicBlock", "*", "Z80TargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "MBB", ")", "const", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "Z80", "::", "SELECT8", ":", "case", "Z80", "::", "SELECT16", ":", "return", "EmitSelectInstr", "(", "MI", ",", "MBB", ")", ";", "case", "Z80", "::", "SHL8", ":", "case", "Z80", "::", "LSHR8", ":", "case", "Z80", "::", "ASHR8", ":", "case", "Z80", "::", "SHL16", ":", "case", "Z80", "::", "LSHR16", ":", "case", "Z80", "::", "ASHR16", ":", "return", "EmitShiftInstr", "(", "MI", ",", "MBB", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Invalid Custom Inserter Instruction\"", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "Z80", "Z80", "Z80::SELECT8", "Z80::SELECT16", "Z80::SHL8", "Z80::LSHR8", "Z80::ASHR8", "Z80::SHL16", "Z80::LSHR16", "Z80::ASHR16", "\"Invalid Custom Inserter Instruction\"" ]

[]

[ "<s>", "inline", "unsigned", "int", "function_base", "::", "call_properties", "(", "const", "function_instance", "&", "instance", ")", "const", "{", "unsigned", "int", "flags", "=", "0", ";", "if", "(", "instance", ".", "any_type_float_p", "(", ")", ")", "return", "flags", "|", "CP_READ_FPCR", "|", "CP_RAISE_FP_EXCEPTIONS", ";", "return", "flags", ";", "}", "</s>" ]

[ "Default", "implementation", "of", "function_base", ":", ":call_properties", ",", "with", "conservatively", "correct", "behavior", "for", "floating-point", "instructions", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "bool", "AArch64CondBrTuning", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** AArch64 Conditional Branch Tuning **********\\n\"", "<<", "\"********** Function: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "'\\n'", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "bool", "LocalChange", "=", "false", ";", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ".", "terminators", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AArch64", "::", "CBZW", ":", "case", "AArch64", "::", "CBZX", ":", "case", "AArch64", "::", "CBNZW", ":", "case", "AArch64", "::", "CBNZX", ":", "case", "AArch64", "::", "TBZW", ":", "case", "AArch64", "::", "TBZX", ":", "case", "AArch64", "::", "TBNZW", ":", "case", "AArch64", "::", "TBNZX", ":", "MachineInstr", "*", "DefMI", "=", "getOperandDef", "(", "MI", ".", "getOperand", "(", "0", ")", ")", ";", "LocalChange", "=", "(", "DefMI", "&&", "tryToTuneBranch", "(", "MI", ",", "*", "DefMI", ")", ")", ";", "break", ";", "}", "if", "(", "LocalChange", ")", "{", "Changed", "=", "true", ";", "break", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"********** AArch64 Conditional Branch Tuning **********\\n\"", "\"********** Function: \"", "AArch64", "AArch64::CBZW", "AArch64::CBZX", "AArch64::CBNZW", "AArch64::CBNZX", "AArch64::TBZW", "AArch64::TBZX", "AArch64::TBNZW", "AArch64::TBNZX", "0" ]

[]

[ "<s>", "void", "DLXFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "DLXRegisterInfo", "*", "LRI", "=", "static_cast", "<", "const", "DLXRegisterInfo", "*", ">", "(", "STI", ".", "getRegisterInfo", "(", ")", ")", ";", "int", "Offset", "=", "-", "4", ";", "MFI", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "Offset", "-=", "4", ";", "MFI", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "Offset", "-=", "4", ";", "if", "(", "LRI", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "MFI", ".", "CreateFixedObject", "(", "4", ",", "Offset", ",", "true", ")", ";", "SavedRegs", ".", "reset", "(", "LRI", "->", "getBaseRegister", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "DLX", "DLX", "DLX", "DLX", "4", "4", "4", "4", "4", "4" ]

[]

[ "<s>", "bool", "WebAssemblyLateEHPrepare", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "getMCAsmInfo", "(", ")", "->", "getExceptionHandlingType", "(", ")", "!=", "ExceptionHandling", "::", "Wasm", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "Changed", "|=", "addRethrows", "(", "MF", ")", ";", "if", "(", "!", "MF", ".", "getFunction", "(", ")", ".", "hasPersonalityFn", "(", ")", ")", "return", "Changed", ";", "Changed", "|=", "replaceFuncletReturns", "(", "MF", ")", ";", "Changed", "|=", "hoistCatches", "(", "MF", ")", ";", "Changed", "|=", "addCatchAlls", "(", "MF", ")", ";", "Changed", "|=", "ensureSingleBBTermPads", "(", "MF", ")", ";", "Changed", "|=", "mergeTerminatePads", "(", "MF", ")", ";", "Changed", "|=", "addCatchAllTerminatePads", "(", "MF", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly" ]

[]

[ "<s>", "void", "aarch64_expand_compare_and_swap", "(", "rtx", "operands", "[", "]", ")", "{", "rtx", "bval", ",", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ",", "x", ";", "machine_mode", "mode", ",", "cmp_mode", ";", "typedef", "rtx", "(", "*", "gen_cas_fn", ")", "(", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ",", "rtx", ")", ";", "int", "idx", ";", "gen_cas_fn", "gen", ";", "const", "gen_cas_fn", "split_cas", "[", "]", "=", "{", "gen_aarch64_compare_and_swapqi", ",", "gen_aarch64_compare_and_swaphi", ",", "gen_aarch64_compare_and_swapsi", ",", "gen_aarch64_compare_and_swapdi", "}", ";", "const", "gen_cas_fn", "atomic_cas", "[", "]", "=", "{", "gen_aarch64_compare_and_swapqi_lse", ",", "gen_aarch64_compare_and_swaphi_lse", ",", "gen_aarch64_compare_and_swapsi_lse", ",", "gen_aarch64_compare_and_swapdi_lse", "}", ";", "bval", "=", "operands", "[", "0", "]", ";", "rval", "=", "operands", "[", "1", "]", ";", "mem", "=", "operands", "[", "2", "]", ";", "oldval", "=", "operands", "[", "3", "]", ";", "newval", "=", "operands", "[", "4", "]", ";", "is_weak", "=", "operands", "[", "5", "]", ";", "mod_s", "=", "operands", "[", "6", "]", ";", "mod_f", "=", "operands", "[", "7", "]", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "cmp_mode", "=", "mode", ";", "if", "(", "is_mm_acquire", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_f", ")", ")", ")", "&&", "is_mm_release", "(", "memmodel_from_int", "(", "INTVAL", "(", "mod_s", ")", ")", ")", ")", "mod_s", "=", "GEN_INT", "(", "MEMMODEL_ACQ_REL", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "cmp_mode", "=", "SImode", ";", "rval", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "oldval", "=", "convert_modes", "(", "SImode", ",", "mode", ",", "oldval", ",", "true", ")", ";", "case", "E_SImode", ":", "case", "E_DImode", ":", "if", "(", "!", "aarch64_plus_operand", "(", "oldval", ",", "mode", ")", ")", "oldval", "=", "force_reg", "(", "cmp_mode", ",", "oldval", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "mode", ")", "{", "case", "E_QImode", ":", "idx", "=", "0", ";", "break", ";", "case", "E_HImode", ":", "idx", "=", "1", ";", "break", ";", "case", "E_SImode", ":", "idx", "=", "2", ";", "break", ";", "case", "E_DImode", ":", "idx", "=", "3", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "if", "(", "TARGET_LSE", ")", "gen", "=", "atomic_cas", "[", "idx", "]", ";", "else", "gen", "=", "split_cas", "[", "idx", "]", ";", "emit_insn", "(", "gen", "(", "rval", ",", "mem", ",", "oldval", ",", "newval", ",", "is_weak", ",", "mod_s", ",", "mod_f", ")", ")", ";", "if", "(", "mode", "==", "QImode", "||", "mode", "==", "HImode", ")", "emit_move_insn", "(", "operands", "[", "1", "]", ",", "gen_lowpart", "(", "mode", ",", "rval", ")", ")", ";", "x", "=", "gen_rtx_REG", "(", "CCmode", ",", "CC_REGNUM", ")", ";", "x", "=", "gen_rtx_EQ", "(", "SImode", ",", "x", ",", "const0_rtx", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "bval", ",", "x", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "compare", "and", "swap", "pattern", "." ]

[ "aarch64", "0", "1", "2", "3", "4", "5", "6", "7", "0", "1", "2", "3", "1" ]

[]

[ "<s>", "void", "M88kPreLegalizerCombiner", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "TargetPassConfig", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "getSelectionDAGFallbackAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "addRequired", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelKnownBitsAnalysis", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "MachineDominatorTree", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "GISelCSEAnalysisWrapperPass", ">", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "M88k", "M88k" ]

[]

[ "<s>", "bool", "Z80InstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "&", "MI", ")", "const", "{", "if", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", "return", "false", ";", "if", "(", "MI", ".", "isBranch", "(", ")", "&&", "!", "MI", ".", "isBarrier", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MI", ".", "isPredicable", "(", ")", ")", "return", "true", ";", "return", "!", "isPredicated", "(", "MI", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "Z80", "Z80" ]

[]

[ "<s>", "const", "char", "*", "AMDGPUTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "NODE_NAME_CASE", "(", "MAD", ")", ";", "NODE_NAME_CASE", "(", "CALL", ")", ";", "NODE_NAME_CASE", "(", "UMUL", ")", ";", "NODE_NAME_CASE", "(", "DIV_INF", ")", ";", "NODE_NAME_CASE", "(", "RET_FLAG", ")", ";", "NODE_NAME_CASE", "(", "BRANCH_COND", ")", ";", "NODE_NAME_CASE", "(", "DWORDADDR", ")", "NODE_NAME_CASE", "(", "FRACT", ")", "NODE_NAME_CASE", "(", "FMAX", ")", "NODE_NAME_CASE", "(", "SMAX", ")", "NODE_NAME_CASE", "(", "UMAX", ")", "NODE_NAME_CASE", "(", "FMIN", ")", "NODE_NAME_CASE", "(", "SMIN", ")", "NODE_NAME_CASE", "(", "UMIN", ")", "NODE_NAME_CASE", "(", "URECIP", ")", "NODE_NAME_CASE", "(", "INTERP", ")", "NODE_NAME_CASE", "(", "INTERP_P0", ")", "NODE_NAME_CASE", "(", "EXPORT", ")", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "R600", "0" ]

[]

[ "<s>", "static", "int", "spu_sched_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "rtx", "set", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_blockage", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_blockage", ")", "return", "0", ";", "if", "(", "(", "INSN_P", "(", "insn", ")", "&&", "get_attr_length", "(", "insn", ")", "==", "0", ")", "||", "(", "INSN_P", "(", "dep_insn", ")", "&&", "get_attr_length", "(", "dep_insn", ")", "==", "0", ")", ")", "return", "0", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "&&", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", ")", "return", "8", ";", "if", "(", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_hbr", ")", "&&", "(", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_hbr", ")", ")", "return", "2", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR_iprefetch", "||", "INSN_CODE", "(", "dep_insn", ")", "==", "CODE_FOR_iprefetch", ")", "return", "0", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "target", "=", "get_branch_target", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "target", ")", "!=", "REG", "||", "!", "set_of", "(", "target", ",", "insn", ")", ")", "return", "cost", "-", "2", ";", "return", "cost", ";", "}", "if", "(", "CALL_P", "(", "dep_insn", ")", ")", "return", "cost", "-", "2", ";", "if", "(", "INSN_CODE", "(", "insn", ")", "==", "CODE_FOR__return", "&&", "(", "set", "=", "single_set", "(", "dep_insn", ")", ")", "&&", "GET_CODE", "(", "SET_DEST", "(", "set", ")", ")", "==", "REG", "&&", "REGNO", "(", "SET_DEST", "(", "set", ")", ")", "==", "LINK_REGISTER_REGNUM", ")", "return", "20", ";", "if", "(", "JUMP_P", "(", "insn", ")", "&&", "REG_NOTE_KIND", "(", "link", ")", "==", "REG_DEP_ANTI", ")", "return", "insn_cost", "(", "dep_insn", ")", "-", "3", ";", "return", "cost", ";", "}", "</s>" ]

[ "INSN", "is", "dependent", "on", "DEP_INSN", "." ]

[ "spu", "0", "0", "0", "0", "8", "2", "0", "2", "2", "20", "3" ]

[]

[ "<s>", "static", "enum", "arm_pcs", "arm_get_pcs_model", "(", "const_tree", "type", ",", "const_tree", "decl", ")", "{", "bool", "user_convention", "=", "false", ";", "enum", "arm_pcs", "user_pcs", "=", "arm_pcs_default", ";", "tree", "attr", ";", "gcc_assert", "(", "type", ")", ";", "attr", "=", "lookup_attribute", "(", "\"pcs\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ";", "if", "(", "attr", ")", "{", "user_pcs", "=", "arm_pcs_from_attribute", "(", "TREE_VALUE", "(", "attr", ")", ")", ";", "user_convention", "=", "true", ";", "}", "if", "(", "TARGET_AAPCS_BASED", ")", "{", "bool", "base_rules", "=", "stdarg_p", "(", "type", ")", ";", "if", "(", "user_convention", ")", "{", "if", "(", "user_pcs", ">", "ARM_PCS_AAPCS_LOCAL", ")", "sorry", "(", "\"non-AAPCS derived PCS variant\"", ")", ";", "else", "if", "(", "base_rules", "&&", "user_pcs", "!=", "ARM_PCS_AAPCS", ")", "error", "(", "\"variadic functions must use the base AAPCS variant\"", ")", ";", "}", "if", "(", "base_rules", ")", "return", "ARM_PCS_AAPCS", ";", "else", "if", "(", "user_convention", ")", "return", "user_pcs", ";", "else", "if", "(", "decl", "&&", "flag_unit_at_a_time", ")", "{", "cgraph_local_info", "*", "i", "=", "cgraph_node", "::", "local_info", "(", "CONST_CAST_TREE", "(", "decl", ")", ")", ";", "if", "(", "i", "&&", "i", "->", "local", ")", "return", "ARM_PCS_AAPCS_LOCAL", ";", "}", "}", "else", "if", "(", "user_convention", "&&", "user_pcs", "!=", "arm_pcs_default", ")", "sorry", "(", "\"PCS variant\"", ")", ";", "return", "arm_pcs_default", ";", "}", "</s>" ]

[ "Get", "the", "PCS", "variant", "to", "use", "for", "this", "call", ".", "TYPE", "is", "the", "function", "'s", "type", "specification", ",", "DECL", "is", "the", "specific", "declartion", ".", "DECL", "may", "be", "null", "if", "the", "call", "could", "be", "indirect", "or", "if", "this", "is", "a", "library", "call", "." ]

[ "arm", "\"pcs\"", "\"non-AAPCS derived PCS variant\"", "\"variadic functions must use the base AAPCS variant\"", "\"PCS variant\"" ]

[]

[ "<s>", "SDValue", "PTXSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "DebugLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "llvm_unreachable", "(", "\"memset lowering not implemented for PTX yet\"", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "PTX", "PTX", "\"memset lowering not implemented for PTX yet\"" ]

[]

[ "<s>", "static", "bool", "tail_agnostic_p", "(", "rtx_insn", "*", "rinsn", ")", "{", "extract_insn_cached", "(", "rinsn", ")", ";", "int", "ta", "=", "get_attr_ta", "(", "rinsn", ")", ";", "return", "ta", "==", "INVALID_ATTRIBUTE", "?", "get_default_ta", "(", ")", ":", "IS_AGNOSTIC", "(", "ta", ")", ";", "}", "</s>" ]

[ "Helper", "function", "to", "get", "TA", "operand", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getJumpTableEncoding", "(", ")", "const", "{", "if", "(", "isPositionIndependent", "(", ")", "&&", "Subtarget", ".", "isPICStyleGOT", "(", ")", ")", "return", "MachineJumpTableInfo", "::", "EK_Custom32", ";", "return", "TargetLowering", "::", "getJumpTableEncoding", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "entry", "encoding", "for", "a", "jump", "table", "in", "the", "current", "function", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "const", "Value", "*", "Ptr", "=", "LI", "->", "getPointerOperand", "(", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "Ptr", ",", "AM", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "&", "XII", "=", "(", "const", "X86InstrInfo", "&", ")", "TII", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "Align", "Alignment", "=", "DL", ".", "getValueOrABITypeAlignment", "(", "LI", "->", "getAlign", "(", ")", ",", "LI", "->", "getType", "(", ")", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "AddrOps", ";", "AM", ".", "getFullAddress", "(", "AddrOps", ")", ";", "MachineInstr", "*", "Result", "=", "XII", ".", "foldMemoryOperandImpl", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ",", "OpNo", ",", "AddrOps", ",", "FuncInfo", ".", "InsertPt", ",", "Size", ",", "Alignment", ",", "true", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "unsigned", "OperandNo", "=", "0", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "I", "=", "Result", "->", "operands_begin", "(", ")", ",", "E", "=", "Result", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "OperandNo", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "AM", ".", "IndexReg", ")", "continue", ";", "unsigned", "IndexReg", "=", "constrainOperandRegClass", "(", "Result", "->", "getDesc", "(", ")", ",", "MO", ".", "getReg", "(", ")", ",", "OperandNo", ")", ";", "if", "(", "IndexReg", "==", "MO", ".", "getReg", "(", ")", ")", "continue", ";", "MO", ".", "setReg", "(", "IndexReg", ")", ";", "}", "Result", "->", "addMemOperand", "(", "*", "FuncInfo", ".", "MF", ",", "createMachineMemOperandFor", "(", "LI", ")", ")", ";", "Result", "->", "cloneInstrSymbols", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "(", "MI", ")", ";", "removeDeadCode", "(", "I", ",", "std", "::", "next", "(", "I", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

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

[]

[ "<s>", "void", "split_quadword_operands", "(", "rtx", "*", "operands", ",", "rtx", "*", "low", ",", "int", "n", "ATTRIBUTE_UNUSED", ")", "{", "int", "i", ";", "low", "[", "0", "]", "=", "low", "[", "1", "]", "=", "low", "[", "2", "]", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "3", ";", "i", "++", ")", "{", "if", "(", "low", "[", "i", "]", ")", ";", "else", "if", "(", "GET_CODE", "(", "operands", "[", "i", "]", ")", "==", "MEM", "&&", "(", "GET_CODE", "(", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ")", "==", "POST_INC", ")", ")", "{", "rtx", "addr", "=", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ";", "operands", "[", "i", "]", "=", "low", "[", "i", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ";", "if", "(", "which_alternative", "==", "0", "&&", "i", "==", "0", ")", "{", "addr", "=", "XEXP", "(", "operands", "[", "i", "]", ",", "0", ")", ";", "operands", "[", "i", "+", "1", "]", "=", "low", "[", "i", "+", "1", "]", "=", "gen_rtx_MEM", "(", "SImode", ",", "addr", ")", ";", "}", "}", "else", "{", "low", "[", "i", "]", "=", "operand_subword", "(", "operands", "[", "i", "]", ",", "0", ",", "0", ",", "DImode", ")", ";", "operands", "[", "i", "]", "=", "operand_subword", "(", "operands", "[", "i", "]", ",", "1", ",", "0", ",", "DImode", ")", ";", "}", "}", "}", "</s>" ]

[ "This", "is", "like", "nonimmediate_operand", "with", "a", "restriction", "on", "the", "type", "of", "MEM", "." ]

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

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "HexagonTargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "unsigned", "VecLen", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "MVT", "ElemTy", "=", "VT", ".", "getVectorElementType", "(", ")", ";", "if", "(", "VecLen", "==", "1", "||", "VT", ".", "isScalableVector", "(", ")", ")", "return", "TargetLoweringBase", "::", "TypeScalarizeVector", ";", "if", "(", "Subtarget", ".", "useHVXOps", "(", ")", ")", "{", "unsigned", "HwLen", "=", "Subtarget", ".", "getVectorLength", "(", ")", ";", "ArrayRef", "<", "MVT", ">", "Tys", "=", "Subtarget", ".", "getHVXElementTypes", "(", ")", ";", "if", "(", "llvm", "::", "find", "(", "Tys", ",", "ElemTy", ")", "!=", "Tys", ".", "end", "(", ")", ")", "{", "unsigned", "HwWidth", "=", "8", "*", "HwLen", ";", "unsigned", "VecWidth", "=", "VT", ".", "getSizeInBits", "(", ")", ";", "if", "(", "VecWidth", ">=", "HwWidth", "/", "2", "&&", "VecWidth", "<", "HwWidth", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "}", "if", "(", "ElemTy", "==", "MVT", "::", "i1", "&&", "VecLen", "==", "2", "*", "HwLen", ")", "return", "TargetLoweringBase", "::", "TypeSplitVector", ";", "}", "if", "(", "ElemTy", "==", "MVT", "::", "i1", ")", "return", "TargetLoweringBase", "::", "TypeWidenVector", ";", "return", "TargetLoweringBase", "::", "TypeSplitVector", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "Hexagon", "Hexagon", "1", "8", "2", "MVT::i1", "2", "MVT::i1" ]

[]

[ "<s>", "void", "SystemZTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "bool", "HasCall", "=", "false", ";", "unsigned", "NumStores", "=", "0", ";", "for", "(", "auto", "&", "BB", ":", "L", "->", "blocks", "(", ")", ")", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "isa", "<", "CallInst", ">", "(", "&", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "&", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "isLoweredToCall", "(", "F", ")", ")", "HasCall", "=", "true", ";", "if", "(", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memcpy", "||", "F", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "memset", ")", "NumStores", "++", ";", "}", "else", "{", "HasCall", "=", "true", ";", "}", "}", "if", "(", "isa", "<", "StoreInst", ">", "(", "&", "I", ")", ")", "{", "Type", "*", "MemAccessTy", "=", "I", ".", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "NumStores", "+=", "getMemoryOpCost", "(", "Instruction", "::", "Store", ",", "MemAccessTy", ",", "0", ",", "0", ")", ";", "}", "}", "unsigned", "const", "Max", "=", "(", "NumStores", "?", "(", "12", "/", "NumStores", ")", ":", "UINT_MAX", ")", ";", "if", "(", "HasCall", ")", "{", "UP", ".", "FullUnrollMaxCount", "=", "Max", ";", "UP", ".", "MaxCount", "=", "1", ";", "return", ";", "}", "UP", ".", "MaxCount", "=", "Max", ";", "if", "(", "UP", ".", "MaxCount", "<=", "1", ")", "return", ";", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "PartialThreshold", "=", "75", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "AllowExpensiveTripCount", "=", "true", ";", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "SystemZ", "SystemZ", "0", "Intrinsic::memcpy", "Intrinsic::memset", "0", "0", "0", "12", "1", "1", "75", "4" ]

[]

[ "<s>", "bool", "RISCVPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "TargetRegisterClass", "*", "TMS320C64XLowering", "::", "getRegClassFor", "(", "EVT", "VT", ")", "const", "{", "if", "(", "ST", "->", "enableClusterAssignment", "(", ")", ")", "return", "TMS320C64X", "::", "GPRegsRegisterClass", ";", "else", "return", "TMS320C64X", "::", "ARegsRegisterClass", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "that", "should", "be", "used", "for", "the", "specified", "value", "type", "." ]

[ "TMS320C64X", "TMS320C64X", "TMS320C64X::GPRegsRegisterClass", "TMS320C64X::ARegsRegisterClass" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "riscv_first_stack_step", "(", "struct", "riscv_frame_info", "*", "frame", ")", "{", "if", "(", "SMALL_OPERAND", "(", "frame", "->", "total_size", ")", ")", "return", "frame", "->", "total_size", ";", "HOST_WIDE_INT", "min_first_step", "=", "RISCV_STACK_ALIGN", "(", "frame", "->", "total_size", "-", "frame", "->", "fp_sp_offset", ")", ";", "HOST_WIDE_INT", "max_first_step", "=", "IMM_REACH", "/", "2", "-", "PREFERRED_STACK_BOUNDARY", "/", "8", ";", "HOST_WIDE_INT", "min_second_step", "=", "frame", "->", "total_size", "-", "max_first_step", ";", "gcc_assert", "(", "min_first_step", "<=", "max_first_step", ")", ";", "if", "(", "!", "SMALL_OPERAND", "(", "min_second_step", ")", "&&", "frame", "->", "total_size", "%", "IMM_REACH", "<", "IMM_REACH", "/", "2", "&&", "frame", "->", "total_size", "%", "IMM_REACH", ">=", "min_first_step", ")", "return", "frame", "->", "total_size", "%", "IMM_REACH", ";", "if", "(", "TARGET_RVC", ")", "{", "if", "(", "IN_RANGE", "(", "min_second_step", ",", "0", ",", "(", "TARGET_64BIT", "?", "SDSP_REACH", ":", "SWSP_REACH", ")", ")", ")", "return", "MAX", "(", "min_second_step", ",", "min_first_step", ")", ";", "else", "if", "(", "!", "SMALL_OPERAND", "(", "min_second_step", ")", ")", "return", "min_first_step", ";", "}", "return", "max_first_step", ";", "}", "</s>" ]

[ "For", "stack", "frames", "that", "ca", "n't", "be", "allocated", "with", "a", "single", "ADDI", "instruction", ",", "compute", "the", "best", "value", "to", "initially", "allocate", ".", "It", "must", "at", "a", "minimum", "allocate", "enough", "space", "to", "spill", "the", "callee-saved", "registers", "." ]

[ "riscv", "2", "8", "2", "0" ]

[]

[ "<s>", "bool", "Error", "(", "const", "StringRef", "&", "msg", ",", "const", "AsmToken", "&", "tok", ")", "{", "return", "Parser", ".", "Error", "(", "tok", ".", "getLoc", "(", ")", ",", "msg", "+", "tok", ".", "getString", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "bool", "arm_evpc_neon_vrev", "(", "struct", "expand_vec_perm_d", "*", "d", ")", "{", "unsigned", "int", "i", ",", "j", ",", "diff", ",", "nelt", "=", "d", "->", "nelt", ";", "rtx", "(", "*", "gen", ")", "(", "rtx", ",", "rtx", ")", ";", "if", "(", "!", "d", "->", "one_vector_p", ")", "return", "false", ";", "diff", "=", "d", "->", "perm", "[", "0", "]", ";", "switch", "(", "diff", ")", "{", "case", "7", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev64v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev64v8qi", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "3", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev32v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev32v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vrev64v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vrev64v4hi", ";", "break", ";", "case", "V8HFmode", ":", "gen", "=", "gen_neon_vrev64v8hf", ";", "break", ";", "case", "V4HFmode", ":", "gen", "=", "gen_neon_vrev64v4hf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "case", "1", ":", "switch", "(", "d", "->", "vmode", ")", "{", "case", "V16QImode", ":", "gen", "=", "gen_neon_vrev16v16qi", ";", "break", ";", "case", "V8QImode", ":", "gen", "=", "gen_neon_vrev16v8qi", ";", "break", ";", "case", "V8HImode", ":", "gen", "=", "gen_neon_vrev32v8hi", ";", "break", ";", "case", "V4HImode", ":", "gen", "=", "gen_neon_vrev32v4hi", ";", "break", ";", "case", "V4SImode", ":", "gen", "=", "gen_neon_vrev64v4si", ";", "break", ";", "case", "V2SImode", ":", "gen", "=", "gen_neon_vrev64v2si", ";", "break", ";", "case", "V4SFmode", ":", "gen", "=", "gen_neon_vrev64v4sf", ";", "break", ";", "case", "V2SFmode", ":", "gen", "=", "gen_neon_vrev64v2sf", ";", "break", ";", "default", ":", "return", "false", ";", "}", "break", ";", "default", ":", "return", "false", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "i", "+=", "diff", "+", "1", ")", "for", "(", "j", "=", "0", ";", "j", "<=", "diff", ";", "j", "+=", "1", ")", "{", "gcc_assert", "(", "i", "+", "j", "<", "nelt", ")", ";", "if", "(", "d", "->", "perm", "[", "i", "+", "j", "]", "!=", "i", "+", "diff", "-", "j", ")", "return", "false", ";", "}", "if", "(", "d", "->", "testing_p", ")", "return", "true", ";", "emit_insn", "(", "gen", "(", "d", "->", "target", ",", "d", "->", "op0", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Recognize", "patterns", "for", "the", "VREV", "insns", "." ]

[ "arm", "0", "7", "3", "1", "0", "1", "0", "1" ]

[]

[ "<s>", "bool", "PTXInstrInfo", "::", "isUnpredicatedTerminator", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "return", "!", "isPredicated", "(", "MI", ")", "&&", "MI", "->", "isTerminator", "(", ")", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "instruction", "is", "a", "terminator", "instruction", "that", "has", "not", "been", "predicated", "." ]

[ "PTX", "PTX" ]

[]

[ "<s>", "void", "TeakMCInstLower", "::", "Initialize", "(", "Mangler", "*", "M", ",", "MCContext", "*", "C", ")", "{", "Mang", "=", "M", ";", "Ctx", "=", "C", ";", "}", "</s>" ]

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

[ "Teak", "Teak" ]

[]

[ "<s>", "void", "PPCInstrInfo", "::", "insertNoop", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "unsigned", "Directive", "=", "Subtarget", ".", "getMcpu", "(", ")", ";", "unsigned", "Opcode", ";", "switch", "(", "Directive", ")", "{", "default", ":", "Opcode", "=", "PPC", "::", "NOP", ";", "break", ";", "case", "PPC", "::", "MCPU_PWR6", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR6", ";", "break", ";", "case", "PPC", "::", "MCPU_PWR7", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "MCPU_PWR8", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "case", "PPC", "::", "MCPU_PWR9", ":", "Opcode", "=", "PPC", "::", "NOP_GT_PWR7", ";", "break", ";", "}", "DebugLoc", "DL", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ";", "}", "</s>" ]

[ "Insert", "a", "noop", "into", "the", "instruction", "stream", "at", "the", "specified", "point", "." ]

[ "PowerPC", "PPC", "PPC::NOP", "PPC::MCPU_PWR6", "PPC::NOP_GT_PWR6", "PPC::MCPU_PWR7", "PPC::NOP_GT_PWR7", "PPC::MCPU_PWR8", "PPC::NOP_GT_PWR7", "PPC::MCPU_PWR9", "PPC::NOP_GT_PWR7" ]

[]

[ "<s>", "void", "tilegx_expand_movmisalign", "(", "machine_mode", "mode", ",", "rtx", "*", "operands", ")", "{", "if", "(", "MEM_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", ";", "if", "(", "register_operand", "(", "operands", "[", "0", "]", ",", "mode", ")", ")", "tmp", "=", "operands", "[", "0", "]", ";", "else", "tmp", "=", "gen_reg_rtx", "(", "mode", ")", ";", "tilegx_expand_unaligned_load", "(", "tmp", ",", "operands", "[", "1", "]", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "true", ")", ";", "if", "(", "tmp", "!=", "operands", "[", "0", "]", ")", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "tmp", ")", ";", "}", "else", "if", "(", "MEM_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "!", "reg_or_0_operand", "(", "operands", "[", "1", "]", ",", "mode", ")", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "mode", ",", "operands", "[", "1", "]", ")", ";", "tilegx_expand_unaligned_store", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ")", ";", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "movmisalign", "patterns", ".", "One", "of", "the", "operands", "is", "a", "memory", "that", "is", "not", "naturally", "aligned", ".", "Emit", "instructions", "to", "load", "it", "." ]

[ "tilegx", "1", "0", "0", "1", "0", "0", "0", "0", "1", "1", "1", "0", "1", "0" ]

[]