Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "std", "::", "vector", "<", "std", "::", "string", ">", "add", "(", "Px", "a", ",", "Bx", "b", ")", "{", "return", "D", "(", "\"add\"", ",", "R", "(", "a", ")", ",", "R", "(", "b", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "string", "to", "the", "builder", "." ]

[ "Teak", "\"add\"" ]

[]

[ "<s>", "bool", "ThumbRegisterInfo", "::", "useFPForScavengingIndex", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "MF", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isThumb1Only", "(", ")", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "wants", "to", "use", "frame", "pointer", "based", "accesses", "to", "spill", "to", "the", "scavenger", "emergency", "spill", "slot", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "HexagonPacketizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "const", "TargetInstrInfo", "*", "TII", "=", "Fn", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineLoopInfo", "&", "MLI", "=", "getAnalysis", "<", "MachineLoopInfo", ">", "(", ")", ";", "MachineDominatorTree", "&", "MDT", "=", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "HexagonPacketizerList", "Packetizer", "(", "Fn", ",", "MLI", ",", "MDT", ")", ";", "assert", "(", "Packetizer", ".", "getResourceTracker", "(", ")", "&&", "\"Empty DFA table!\"", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "MachineBasicBlock", "::", "iterator", "End", "=", "MBB", "->", "end", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MI", "=", "MBB", "->", "begin", "(", ")", ";", "while", "(", "MI", "!=", "End", ")", "{", "if", "(", "MI", "->", "isKill", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "DeleteMI", "=", "MI", ";", "++", "MI", ";", "MBB", "->", "erase", "(", "DeleteMI", ")", ";", "End", "=", "MBB", "->", "end", "(", ")", ";", "continue", ";", "}", "++", "MI", ";", "}", "}", "for", "(", "MachineFunction", "::", "iterator", "MBB", "=", "Fn", ".", "begin", "(", ")", ",", "MBBe", "=", "Fn", ".", "end", "(", ")", ";", "MBB", "!=", "MBBe", ";", "++", "MBB", ")", "{", "unsigned", "RemainingCount", "=", "MBB", "->", "size", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "RegionEnd", "=", "MBB", "->", "end", "(", ")", ";", "RegionEnd", "!=", "MBB", "->", "begin", "(", ")", ";", ")", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "RegionEnd", ";", "for", "(", ";", "I", "!=", "MBB", "->", "begin", "(", ")", ";", "--", "I", ",", "--", "RemainingCount", ")", "{", "if", "(", "TII", "->", "isSchedulingBoundary", "(", "llvm", "::", "prior", "(", "I", ")", ",", "MBB", ",", "Fn", ")", ")", "break", ";", "}", "I", "=", "MBB", "->", "begin", "(", ")", ";", "if", "(", "I", "==", "RegionEnd", ")", "{", "RegionEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "--", "RemainingCount", ";", "continue", ";", "}", "if", "(", "I", "==", "llvm", "::", "prior", "(", "RegionEnd", ")", ")", "{", "RegionEnd", "=", "llvm", "::", "prior", "(", "RegionEnd", ")", ";", "continue", ";", "}", "Packetizer", ".", "PacketizeMIs", "(", "MBB", ",", "I", ",", "RegionEnd", ")", ";", "RegionEnd", "=", "I", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"Empty DFA table!\"" ]

[]

[ "<s>", "void", "Warning", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ")", "{", "getParser", "(", ")", ".", "Warning", "(", "L", ",", "Msg", ")", ";", "}", "</s>" ]

[ "Emit", "a", "warning", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "AArch64" ]

[]

[ "<s>", "int", "move_double_src_operand", "(", "rtx", "op", ",", "enum", "machine_mode", "mode", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "SUBREG", ":", "if", "(", "GET_CODE", "(", "SUBREG_REG", "(", "op", ")", ")", "==", "MEM", ")", "return", "move_double_src_operand", "(", "SUBREG_REG", "(", "op", ")", ",", "mode", ")", ";", "else", "return", "register_operand", "(", "op", ",", "mode", ")", ";", "case", "MEM", ":", "if", "(", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PRE_DEC", "||", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PRE_INC", ")", "return", "0", ";", "return", "address_operand", "(", "XEXP", "(", "op", ",", "0", ")", ",", "mode", ")", ";", "case", "CONST_INT", ":", "case", "CONST_DOUBLE", ":", "return", "1", ";", "default", ":", "return", "0", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "OP", "is", "an", "acceptable", "argument", "for", "a", "double", "word", "move", "source", "." ]

[ "arc", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "bool", "hasTrue16BitInsts", "(", ")", "const", "{", "return", "HasTrue16BitInsts", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "subtarget", "supports", "True16", "instructions", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "const", "SICRegisterInfo", "&", "SICInstrInfo", "::", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC" ]

[]

[ "<s>", "static", "rtx", "nvptx_gen_unpack", "(", "rtx", "dst0", ",", "rtx", "dst1", ",", "rtx", "src", ")", "{", "rtx", "res", ";", "switch", "(", "GET_MODE", "(", "src", ")", ")", "{", "case", "DImode", ":", "res", "=", "gen_unpackdisi2", "(", "dst0", ",", "dst1", ",", "src", ")", ";", "break", ";", "case", "DFmode", ":", "res", "=", "gen_unpackdfsi2", "(", "dst0", ",", "dst1", ",", "src", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Generate", "instruction", "(", "s", ")", "to", "unpack", "a", "64", "bit", "object", "into", "2", "32", "bit", "objects", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "PIC16TargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "{", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "GlobalAddress", ":", "Results", ".", "push_back", "(", "ExpandGlobalAddress", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "ExternalSymbol", ":", "Results", ".", "push_back", "(", "ExpandExternalSymbol", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "STORE", ":", "Results", ".", "push_back", "(", "ExpandStore", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "case", "ISD", "::", "LOAD", ":", "PopulateResults", "(", "ExpandLoad", "(", "N", ",", "DAG", ")", ",", "Results", ")", ";", "return", ";", "case", "ISD", "::", "ADD", ":", "return", ";", "case", "ISD", "::", "FrameIndex", ":", "Results", ".", "push_back", "(", "ExpandFrameIndex", "(", "N", ",", "DAG", ")", ")", ";", "return", ";", "default", ":", "assert", "(", "0", "&&", "\"not implemented\"", ")", ";", "return", ";", "}", "}", "</s>" ]

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

[ "PIC16", "PIC16", "ISD::GlobalAddress", "ISD::ExternalSymbol", "ISD::STORE", "ISD::LOAD", "ISD::ADD", "ISD::FrameIndex", "0", "\"not implemented\"" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreGlobalInstructionSelect", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ")", "addPass", "(", "new", "Localizer", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "the", "(", "global", ")", "instruction", "selection", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "bool", "NVPTXTTI", "::", "hasBranchDivergence", "(", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "branch", "divergence", "exists", "." ]

[ "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addPreISel", "(", ")", "{", "if", "(", "(", "TM", "->", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "Aggressive", "&&", "EnableGlobalMerge", "==", "cl", "::", "BOU_UNSET", ")", "||", "EnableGlobalMerge", "==", "cl", "::", "BOU_TRUE", ")", "addPass", "(", "createGlobalMergePass", "(", "TM", ",", "127", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "{", "{", "@", "For", "GlobalISel" ]

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

[]

[ "<s>", "bool", "MBlazeTargetLowering", "::", "isOffsetFoldingLegal", "(", "const", "GlobalAddressSDNode", "*", "GA", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "folding", "a", "constant", "offset", "with", "the", "given", "GlobalAddress", "is", "legal", "." ]

[ "MBlaze", "MBlaze" ]

[]

[ "<s>", "bool", "ARMPreAllocLoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "TD", "=", "Fn", ".", "getTarget", "(", ")", ".", "getDataLayout", "(", ")", ";", "STI", "=", "&", "static_cast", "<", "const", "ARMSubtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "Fn", ".", "getRegInfo", "(", ")", ";", "MF", "=", "&", "Fn", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "Fn", ".", "begin", "(", ")", ",", "E", "=", "Fn", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "RescheduleLoadStoreInstrs", "(", "MFI", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "const", "char", "*", "arm_gen_far_branch", "(", "rtx", "*", "operands", ",", "int", "pos_label", ",", "const", "char", "*", "dest", ",", "const", "char", "*", "branch_format", ")", "{", "rtx_code_label", "*", "tmp_label", "=", "gen_label_rtx", "(", ")", ";", "char", "label_buf", "[", "256", "]", ";", "char", "buffer", "[", "128", "]", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "label_buf", ",", "dest", ",", "\\", "CODE_LABEL_NUMBER", "(", "tmp_label", ")", ")", ";", "const", "char", "*", "label_ptr", "=", "arm_strip_name_encoding", "(", "label_buf", ")", ";", "rtx", "dest_label", "=", "operands", "[", "pos_label", "]", ";", "operands", "[", "pos_label", "]", "=", "tmp_label", ";", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"%s%s\"", ",", "branch_format", ",", "label_ptr", ")", ";", "output_asm_insn", "(", "buffer", ",", "operands", ")", ";", "snprintf", "(", "buffer", ",", "sizeof", "(", "buffer", ")", ",", "\"b\\t%%l0%d\\n%s:\"", ",", "pos_label", ",", "label_ptr", ")", ";", "operands", "[", "pos_label", "]", "=", "dest_label", ";", "output_asm_insn", "(", "buffer", ",", "operands", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Generate", "code", "to", "enable", "conditional", "branches", "in", "functions", "over", "1", "MiB", ".", "Parameters", "are", ":", "operands", ":", "is", "the", "operands", "list", "of", "the", "asm", "insn", "(", "see", "arm_cond_branch", "or", "arm_cond_branch_reversed", ")", ".", "pos_label", ":", "is", "an", "index", "into", "the", "operands", "array", "where", "operands", "[", "pos_label", "]", "is", "the", "asm", "label", "of", "the", "final", "jump", "destination", ".", "dest", ":", "is", "a", "string", "which", "is", "used", "to", "generate", "the", "asm", "label", "of", "the", "intermediate", "destination", "branch_format", ":", "is", "a", "string", "denoting", "the", "intermediate", "branch", "format", ",", "e.g", ".", "``", "beq", "''", ",", "``", "bne", "''", ",", "etc", "." ]

[ "arm", "256", "128", "\"%s%s\"", "\"b\\t%%l0%d\\n%s:\"", "\"\"" ]

[]

[ "<s>", "void", "ARMTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "ScalarEvolution", "&", "SE", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "if", "(", "!", "ST", "->", "isMClass", "(", ")", ")", "return", "BasicTTIImplBase", "::", "getUnrollingPreferences", "(", "L", ",", "SE", ",", "UP", ")", ";", "UP", ".", "OptSizeThreshold", "=", "0", ";", "UP", ".", "PartialOptSizeThreshold", "=", "0", ";", "if", "(", "L", "->", "getHeader", "(", ")", "->", "getParent", "(", ")", "->", "hasOptSize", "(", ")", ")", "return", ";", "if", "(", "!", "ST", "->", "isThumb2", "(", ")", ")", "return", ";", "SmallVector", "<", "BasicBlock", "*", ",", "4", ">", "ExitingBlocks", ";", "L", "->", "getExitingBlocks", "(", "ExitingBlocks", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Loop has:\\n\"", "<<", "\"Blocks: \"", "<<", "L", "->", "getNumBlocks", "(", ")", "<<", "\"\\n\"", "<<", "\"Exit blocks: \"", "<<", "ExitingBlocks", ".", "size", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "ExitingBlocks", ".", "size", "(", ")", ">", "2", ")", "return", ";", "if", "(", "ST", "->", "hasBranchPredictor", "(", ")", "&&", "L", "->", "getNumBlocks", "(", ")", ">", "4", ")", "return", ";", "unsigned", "Cost", "=", "0", ";", "for", "(", "auto", "*", "BB", ":", "L", "->", "getBlocks", "(", ")", ")", "{", "for", "(", "auto", "&", "I", ":", "*", "BB", ")", "{", "if", "(", "I", ".", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", ";", "if", "(", "isa", "<", "CallInst", ">", "(", "I", ")", "||", "isa", "<", "InvokeInst", ">", "(", "I", ")", ")", "{", "ImmutableCallSite", "CS", "(", "&", "I", ")", ";", "if", "(", "const", "Function", "*", "F", "=", "CS", ".", "getCalledFunction", "(", ")", ")", "{", "if", "(", "!", "isLoweredToCall", "(", "F", ")", ")", "continue", ";", "}", "return", ";", "}", "SmallVector", "<", "const", "Value", "*", ",", "4", ">", "Operands", "(", "I", ".", "value_op_begin", "(", ")", ",", "I", ".", "value_op_end", "(", ")", ")", ";", "Cost", "+=", "getUserCost", "(", "&", "I", ",", "Operands", ")", ";", "}", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Cost of loop: \"", "<<", "Cost", "<<", "\"\\n\"", ")", ";", "UP", ".", "Partial", "=", "true", ";", "UP", ".", "Runtime", "=", "true", ";", "UP", ".", "UpperBound", "=", "true", ";", "UP", ".", "UnrollRemainder", "=", "true", ";", "UP", ".", "DefaultUnrollRuntimeCount", "=", "4", ";", "UP", ".", "UnrollAndJam", "=", "true", ";", "UP", ".", "UnrollAndJamInnerLoopThreshold", "=", "60", ";", "if", "(", "Cost", "<", "12", ")", "UP", ".", "Force", "=", "true", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "0", "0", "4", "\"Loop has:\\n\"", "\"Blocks: \"", "\"\\n\"", "\"Exit blocks: \"", "\"\\n\"", "2", "4", "0", "4", "\"Cost of loop: \"", "\"\\n\"", "4", "60", "12" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "RISCVFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCVABI", "::", "getBPReg", "(", ")", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "RISCV", "RISCV", "RISCV", "0", "RISCV", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8", "RISCVABI::getBPReg" ]

[]

[ "<s>", "void", "AArch64BranchFixup", "::", "verify", "(", ")", "{", "for", "(", "MachineFunction", "::", "iterator", "MBBI", "=", "MF", "->", "begin", "(", ")", ",", "E", "=", "MF", "->", "end", "(", ")", ";", "MBBI", "!=", "E", ";", "++", "MBBI", ")", "{", "MachineBasicBlock", "*", "MBB", "=", "MBBI", ";", "unsigned", "MBBId", "=", "MBB", "->", "getNumber", "(", ")", ";", "assert", "(", "!", "MBBId", "||", "BBInfo", "[", "MBBId", "-", "1", "]", ".", "postOffset", "(", ")", "<=", "BBInfo", "[", "MBBId", "]", ".", "Offset", ")", ";", "}", "}", "</s>" ]

[ "Check", "if", "this", "register", "bank", "is", "valid", "." ]

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

[]

[ "<s>", "TargetIRAnalysis", "TGSITargetMachine", "::", "getTargetIRAnalysis", "(", ")", "{", "return", "TargetIRAnalysis", "(", "[", "this", "]", "(", "const", "Function", "&", "F", ")", "{", "return", "TargetTransformInfo", "(", "TGSITTIImpl", "(", "this", ",", "F", ")", ")", ";", "}", ")", ";", "}", "</s>" ]

[ "Get", "a", "TargetIRAnalysis", "appropriate", "for", "the", "target", "." ]

[ "TGSI", "TGSI", "TGSI" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "CMPri", ":", "case", "ARM", "::", "t2CMPri", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "return", "true", ";", "case", "ARM", "::", "CMPrr", ":", "case", "ARM", "::", "t2CMPrr", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "ARM", "::", "TSTri", ":", "case", "ARM", "::", "t2TSTri", ":", "SrcReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "ARM", "ARM", "ARM::CMPri", "ARM::t2CMPri", "0", "0", "0", "1", "ARM::CMPrr", "ARM::t2CMPrr", "0", "1", "0", "0", "ARM::TSTri", "ARM::t2TSTri", "0", "0", "1", "0" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "aarch64_asan_shadow_offset", "(", "void", ")", "{", "return", "(", "HOST_WIDE_INT_1", "<<", "36", ")", ";", "}", "</s>" ]

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

[ "aarch64", "36" ]

[]

[ "<s>", "void", "HSAILInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "int", "Opc", "=", "0", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "DebugLoc", "DL", ";", "unsigned", "BT", ";", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unrecognized TargetRegisterClass\"", ")", ";", "break", ";", "case", "HSAIL", "::", "GPR32RegClassID", ":", "Opc", "=", "HSAIL", "::", "LD_U32", ";", "BT", "=", "BRIG_TYPE_U32", ";", "break", ";", "case", "HSAIL", "::", "GPR64RegClassID", ":", "Opc", "=", "HSAIL", "::", "LD_U64", ";", "BT", "=", "BRIG_TYPE_U64", ";", "break", ";", "case", "HSAIL", "::", "CRRegClassID", ":", "Opc", "=", "HSAIL", "::", "RESTORE_B1", ";", "BT", "=", "BRIG_TYPE_B1", ";", "break", ";", "}", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "switch", "(", "RC", "->", "getID", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unrecognized TargetRegisterClass\"", ")", ";", "break", ";", "case", "HSAIL", "::", "GPR32RegClassID", ":", "case", "HSAIL", "::", "GPR64RegClassID", ":", "case", "HSAIL", "::", "CRRegClassID", ":", "{", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "HSAIL", "::", "NoRegister", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "BT", ")", ".", "addImm", "(", "HSAILAS", "::", "SPILL_ADDRESS", ")", ".", "addImm", "(", "MMO", "->", "getAlignment", "(", ")", ")", ".", "addImm", "(", "BRIG_WIDTH_1", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "break", ";", "}", "}", "}", "</s>" ]

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

[ "HSAIL", "HSAIL", "0", "\"unrecognized TargetRegisterClass\"", "HSAIL::GPR32RegClassID", "HSAIL::LD_U32", "HSAIL::GPR64RegClassID", "HSAIL::LD_U64", "HSAIL::CRRegClassID", "HSAIL::RESTORE_B1", "\"unrecognized TargetRegisterClass\"", "HSAIL::GPR32RegClassID", "HSAIL::GPR64RegClassID", "HSAIL::CRRegClassID", "HSAIL::NoRegister", "0", "HSAILAS::SPILL_ADDRESS", "0" ]

[]

[ "<s>", "static", "void", "m68k_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "HARD_REG_SET", "x", ";", "if", "(", "!", "TARGET_HARD_FLOAT", ")", "{", "x", "=", "reg_class_contents", "[", "FP_REGS", "]", ";", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "if", "(", "TEST_HARD_REG_BIT", "(", "x", ",", "i", ")", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "1", ";", "}", "if", "(", "flag_pic", ")", "fixed_regs", "[", "PIC_REG", "]", "=", "call_used_regs", "[", "PIC_REG", "]", "=", "1", ";", "}", "</s>" ]

[ "Make", "sure", "everything", "'s", "fine", "if", "we", "*", "do", "n't", "*", "have", "a", "given", "processor", ".", "This", "assumes", "that", "putting", "a", "register", "in", "fixed_regs", "will", "keep", "the", "compiler", "'s", "mitts", "completely", "off", "it", ".", "We", "do", "n't", "bother", "to", "zero", "it", "out", "of", "register", "classes", "." ]

[ "m68k", "0", "1", "1" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitHeader", "(", "Module", "&", "M", ",", "raw_ostream", "&", "O", ")", "{", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"// Generated by LLVM NVPTX Back-End\\n\"", ";", "O", "<<", "\"//\\n\"", ";", "O", "<<", "\"\\n\"", ";", "unsigned", "PTXVersion", "=", "nvptxSubtarget", ".", "getPTXVersion", "(", ")", ";", "O", "<<", "\".version \"", "<<", "(", "PTXVersion", "/", "10", ")", "<<", "\".\"", "<<", "(", "PTXVersion", "%", "10", ")", "<<", "\"\\n\"", ";", "O", "<<", "\".target \"", ";", "O", "<<", "nvptxSubtarget", ".", "getTargetName", "(", ")", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "NVCL", ")", "O", "<<", "\", texmode_independent\"", ";", "if", "(", "nvptxSubtarget", ".", "getDrvInterface", "(", ")", "==", "NVPTX", "::", "CUDA", ")", "{", "if", "(", "!", "nvptxSubtarget", ".", "hasDouble", "(", ")", ")", "O", "<<", "\", map_f64_to_f32\"", ";", "}", "if", "(", "MAI", "->", "doesSupportDebugInformation", "(", ")", ")", "O", "<<", "\", debug\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\".address_size \"", ";", "if", "(", "nvptxSubtarget", ".", "is64Bit", "(", ")", ")", "O", "<<", "\"64\"", ";", "else", "O", "<<", "\"32\"", ";", "O", "<<", "\"\\n\"", ";", "O", "<<", "\"\\n\"", ";", "}", "</s>" ]

[ "Emit", "the", "header", "for", "this", "unit", ",", "not", "including", "the", "initial", "length", "field", "." ]

[ "NVPTX", "NVPTX", "\"//\\n\"", "\"// Generated by LLVM NVPTX Back-End\\n\"", "\"//\\n\"", "\"\\n\"", "\".version \"", "10", "\".\"", "10", "\"\\n\"", "\".target \"", "NVPTX::NVCL", "\", texmode_independent\"", "NVPTX::CUDA", "\", map_f64_to_f32\"", "\", debug\"", "\"\\n\"", "\".address_size \"", "\"64\"", "\"32\"", "\"\\n\"", "\"\\n\"" ]

[]

[ "<s>", "static", "unsigned", "HOST_WIDE_INT", "mips_asan_shadow_offset", "(", "void", ")", "{", "if", "(", "mips_abi", "==", "ABI_N32", ")", "return", "(", "HOST_WIDE_INT_1", "<<", "29", ")", ";", "if", "(", "POINTER_SIZE", "==", "64", ")", "return", "(", "HOST_WIDE_INT_1", "<<", "37", ")", ";", "else", "return", "HOST_WIDE_INT_C", "(", "0x0aaa0000", ")", ";", "}", "</s>" ]

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

[ "mips", "29", "64", "37", "0x0aaa0000" ]

[]

[ "<s>", "void", "ARMPassConfig", "::", "addCodeGenPrepare", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createTypePromotionPass", "(", ")", ")", ";", "TargetPassConfig", "::", "addCodeGenPrepare", "(", ")", ";", "}", "</s>" ]

[ "Add", "pass", "to", "prepare", "the", "LLVM", "IR", "for", "code", "generation", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "int", "arm_count_output_move_double_insns", "(", "rtx", "*", "operands", ")", "{", "int", "count", ";", "rtx", "ops", "[", "2", "]", ";", "ops", "[", "0", "]", "=", "operands", "[", "0", "]", ";", "ops", "[", "1", "]", "=", "operands", "[", "1", "]", ";", "output_move_double", "(", "ops", ",", "false", ",", "&", "count", ")", ";", "return", "count", ";", "}", "</s>" ]

[ "Compute", "the", "number", "of", "instructions", "emitted", "by", "output_move_double", "." ]

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

[]

[ "<s>", "BitVector", "SparcRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "const", "SparcSubtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "SparcSubtarget", ">", "(", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G1", ")", ";", "if", "(", "ReserveAppRegisters", ")", "{", "Reserved", ".", "set", "(", "SP", "::", "G2", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G3", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G4", ")", ";", "}", "if", "(", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "Reserved", ".", "set", "(", "SP", "::", "G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G0_G1", ")", ";", "if", "(", "ReserveAppRegisters", ")", "Reserved", ".", "set", "(", "SP", "::", "G2_G3", ")", ";", "if", "(", "ReserveAppRegisters", "||", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "Reserved", ".", "set", "(", "SP", "::", "G4_G5", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "O6_O7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "I6_I7", ")", ";", "Reserved", ".", "set", "(", "SP", "::", "G6_G7", ")", ";", "if", "(", "!", "Subtarget", ".", "isV9", "(", ")", ")", "{", "for", "(", "unsigned", "n", "=", "0", ";", "n", "!=", "16", ";", "++", "n", ")", "{", "for", "(", "MCRegAliasIterator", "AI", "(", "SP", "::", "D16", "+", "n", ",", "this", ",", "true", ")", ";", "AI", ".", "isValid", "(", ")", ";", "++", "AI", ")", "Reserved", ".", "set", "(", "*", "AI", ")", ";", "}", "}", "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", "." ]

[ "Sparc", "Sparc", "Sparc", "Sparc", "SP::G1", "SP::G2", "SP::G3", "SP::G4", "SP::G5", "SP::O6", "SP::I6", "SP::I7", "SP::G0", "SP::G6", "SP::G7", "SP::G0_G1", "SP::G2_G3", "SP::G4_G5", "SP::O6_O7", "SP::I6_I7", "SP::G6_G7", "0", "16", "SP::D16" ]

[]

[ "<s>", "int", "getRegClass", "(", ")", "const", "{", "assert", "(", "Kind", "==", "OpKind", "::", "Reg", "&&", "\"Invalid access!\"", ")", ";", "return", "Reg", ".", "Class", ";", "}", "</s>" ]

[ "Given", "a", "machine", "instruction", "descriptor", ",", "returns", "the", "register", "class", "constraint", "for", "OpNum", ",", "or", "NULL", "." ]

[ "TPC", "\"Invalid access!\"" ]

[]

[ "<s>", "unsigned", "MBlazeInstrInfo", "::", "getGlobalBaseReg", "(", "MachineFunction", "*", "MF", ")", "const", "{", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", "->", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "unsigned", "GlobalBaseReg", "=", "MBlazeFI", "->", "getGlobalBaseReg", "(", ")", ";", "if", "(", "GlobalBaseReg", "!=", "0", ")", "return", "GlobalBaseReg", ";", "MachineBasicBlock", "&", "FirstMBB", "=", "MF", "->", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "FirstMBB", ".", "begin", "(", ")", ";", "MachineRegisterInfo", "&", "RegInfo", "=", "MF", "->", "getRegInfo", "(", ")", ";", "const", "TargetInstrInfo", "*", "TII", "=", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "GlobalBaseReg", "=", "RegInfo", ".", "createVirtualRegister", "(", "MBlaze", "::", "CPURegsRegisterClass", ")", ";", "bool", "Ok", "=", "TII", "->", "copyRegToReg", "(", "FirstMBB", ",", "MBBI", ",", "GlobalBaseReg", ",", "MBlaze", "::", "R20", ",", "MBlaze", "::", "CPURegsRegisterClass", ",", "MBlaze", "::", "CPURegsRegisterClass", ")", ";", "assert", "(", "Ok", "&&", "\"Couldn't assign to global base register!\"", ")", ";", "Ok", "=", "Ok", ";", "RegInfo", ".", "addLiveIn", "(", "MBlaze", "::", "R20", ")", ";", "MBlazeFI", "->", "setGlobalBaseReg", "(", "GlobalBaseReg", ")", ";", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze::CPURegsRegisterClass", "MBlaze::R20", "MBlaze::CPURegsRegisterClass", "MBlaze::CPURegsRegisterClass", "\"Couldn't assign to global base register!\"", "MBlaze::R20", "MBlaze" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "isLegalMaskedGather", "(", "Type", "*", "DataTy", ",", "Align", "Alignment", ")", "{", "if", "(", "!", "supportsGather", "(", ")", ")", "return", "false", ";", "Type", "*", "ScalarTy", "=", "DataTy", "->", "getScalarType", "(", ")", ";", "if", "(", "ScalarTy", "->", "isPointerTy", "(", ")", ")", "return", "true", ";", "if", "(", "ScalarTy", "->", "isFloatTy", "(", ")", "||", "ScalarTy", "->", "isDoubleTy", "(", ")", ")", "return", "true", ";", "if", "(", "!", "ScalarTy", "->", "isIntegerTy", "(", ")", ")", "return", "false", ";", "unsigned", "IntWidth", "=", "ScalarTy", "->", "getIntegerBitWidth", "(", ")", ";", "return", "IntWidth", "==", "32", "||", "IntWidth", "==", "64", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

[ "X86", "X86", "32", "64" ]

[]

[ "<s>", "static", "unsigned", "int", "visium_hard_regno_nregs", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "regno", "==", "MDB_REGNUM", ")", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "2", "*", "UNITS_PER_WORD", ")", ";", "return", "CEIL", "(", "GET_MODE_SIZE", "(", "mode", ")", ",", "UNITS_PER_WORD", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_HARD_REGNO_NREGS", "." ]

[ "visium", "2" ]

[]

[ "<s>", "int", "GCNTTIImpl", "::", "getMinMaxReductionCost", "(", "VectorType", "*", "Ty", ",", "VectorType", "*", "CondTy", ",", "bool", "IsPairwise", ",", "bool", "IsUnsigned", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getMinMaxReductionCost", "(", "Ty", ",", "CondTy", ",", "IsPairwise", ",", "IsUnsigned", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "int", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getHalfRateInstrCost", "(", "CostKind", ")", ";", "}", "</s>" ]

[ "Try", "to", "calculate", "op", "costs", "for", "min/max", "reduction", "operations", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "SplitVectorLoad", "(", "const", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "LoadSDNode", "*", "Load", "=", "cast", "<", "LoadSDNode", ">", "(", "Op", ")", ";", "EVT", "VT", "=", "Op", ".", "getValueType", "(", ")", ";", "SDLoc", "SL", "(", "Op", ")", ";", "if", "(", "VT", ".", "getVectorNumElements", "(", ")", "==", "2", ")", "{", "SDValue", "Ops", "[", "2", "]", ";", "std", "::", "tie", "(", "Ops", "[", "0", "]", ",", "Ops", "[", "1", "]", ")", "=", "scalarizeVectorLoad", "(", "Load", ",", "DAG", ")", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "SDValue", "BasePtr", "=", "Load", "->", "getBasePtr", "(", ")", ";", "EVT", "MemVT", "=", "Load", "->", "getMemoryVT", "(", ")", ";", "const", "MachinePointerInfo", "&", "SrcValue", "=", "Load", "->", "getMemOperand", "(", ")", "->", "getPointerInfo", "(", ")", ";", "EVT", "LoVT", ",", "HiVT", ";", "EVT", "LoMemVT", ",", "HiMemVT", ";", "SDValue", "Lo", ",", "Hi", ";", "std", "::", "tie", "(", "LoVT", ",", "HiVT", ")", "=", "getSplitDestVTs", "(", "VT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "LoMemVT", ",", "HiMemVT", ")", "=", "getSplitDestVTs", "(", "MemVT", ",", "DAG", ")", ";", "std", "::", "tie", "(", "Lo", ",", "Hi", ")", "=", "splitVector", "(", "Op", ",", "SL", ",", "LoVT", ",", "HiVT", ",", "DAG", ")", ";", "unsigned", "Size", "=", "LoMemVT", ".", "getStoreSize", "(", ")", ";", "unsigned", "BaseAlign", "=", "Load", "->", "getAlignment", "(", ")", ";", "unsigned", "HiAlign", "=", "MinAlign", "(", "BaseAlign", ",", "Size", ")", ";", "SDValue", "LoLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "LoVT", ",", "Load", "->", "getChain", "(", ")", ",", "BasePtr", ",", "SrcValue", ",", "LoMemVT", ",", "BaseAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "SDValue", "HiPtr", "=", "DAG", ".", "getObjectPtrOffset", "(", "SL", ",", "BasePtr", ",", "Size", ")", ";", "SDValue", "HiLoad", "=", "DAG", ".", "getExtLoad", "(", "Load", "->", "getExtensionType", "(", ")", ",", "SL", ",", "HiVT", ",", "Load", "->", "getChain", "(", ")", ",", "HiPtr", ",", "SrcValue", ".", "getWithOffset", "(", "LoMemVT", ".", "getStoreSize", "(", ")", ")", ",", "HiMemVT", ",", "HiAlign", ",", "Load", "->", "getMemOperand", "(", ")", "->", "getFlags", "(", ")", ")", ";", "auto", "IdxTy", "=", "getVectorIdxTy", "(", "DAG", ".", "getDataLayout", "(", ")", ")", ";", "SDValue", "Join", ";", "if", "(", "LoVT", "==", "HiVT", ")", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "CONCAT_VECTORS", ",", "SL", ",", "VT", ",", "LoLoad", ",", "HiLoad", ")", ";", "}", "else", "{", "Join", "=", "DAG", ".", "getNode", "(", "ISD", "::", "INSERT_SUBVECTOR", ",", "SL", ",", "VT", ",", "DAG", ".", "getUNDEF", "(", "VT", ")", ",", "LoLoad", ",", "DAG", ".", "getConstant", "(", "0", ",", "SL", ",", "IdxTy", ")", ")", ";", "Join", "=", "DAG", ".", "getNode", "(", "HiVT", ".", "isVector", "(", ")", "?", "ISD", "::", "INSERT_SUBVECTOR", ":", "ISD", "::", "INSERT_VECTOR_ELT", ",", "SL", ",", "VT", ",", "Join", ",", "HiLoad", ",", "DAG", ".", "getConstant", "(", "LoVT", ".", "getVectorNumElements", "(", ")", ",", "SL", ",", "IdxTy", ")", ")", ";", "}", "SDValue", "Ops", "[", "]", "=", "{", "Join", ",", "DAG", ".", "getNode", "(", "ISD", "::", "TokenFactor", ",", "SL", ",", "MVT", "::", "Other", ",", "LoLoad", ".", "getValue", "(", "1", ")", ",", "HiLoad", ".", "getValue", "(", "1", ")", ")", "}", ";", "return", "DAG", ".", "getMergeValues", "(", "Ops", ",", "SL", ")", ";", "}", "</s>" ]

[ "Split", "a", "vector", "load", "into", "2", "loads", "of", "half", "the", "vector", "." ]

[ "AMDGPU", "AMDGPU", "2", "2", "0", "1", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "0", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::TokenFactor", "MVT::Other", "1", "1" ]

[]

[ "<s>", "static", "int", "msp430_muldiv_costs", "(", "rtx", "src", ",", "rtx", "dst", ",", "bool", "speed", ",", "rtx", "outer_rtx", ",", "machine_mode", "outer_mode", ")", "{", "enum", "rtx_code", "outer_code", "=", "GET_CODE", "(", "outer_rtx", ")", ";", "const", "struct", "msp430_multlib_costs", "*", "cost_p", ";", "cost_p", "=", "(", "msp430_use_16bit_hwmult", "(", ")", "?", "&", "cycle_cost_multlib_32bit", ":", "&", "cycle_cost_multlib_16bit", ")", ";", "int", "factor", "=", "1", ";", "int", "mode_factor", "=", "1", ";", "if", "(", "outer_mode", "==", "SImode", ")", "mode_factor", "=", "2", ";", "else", "if", "(", "outer_mode", "==", "PSImode", ")", "mode_factor", "=", "3", ";", "else", "if", "(", "outer_mode", "==", "DImode", ")", "mode_factor", "=", "4", ";", "if", "(", "!", "speed", ")", "{", "if", "(", "outer_code", "!=", "MULT", ")", "factor", "=", "7", ";", "else", "if", "(", "(", "(", "msp430_use_16bit_hwmult", "(", ")", "&&", "outer_mode", "!=", "DImode", ")", "||", "msp430_use_32bit_hwmult", "(", ")", "||", "msp430_use_f5_series_hwmult", "(", ")", ")", ")", "factor", "=", "2", ";", "else", "factor", "=", "5", ";", "return", "factor", "*", "mode_factor", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ";", "}", "if", "(", "outer_code", "!=", "MULT", "||", "!", "msp430_has_hwmult", "(", ")", "||", "(", "outer_mode", "==", "DImode", "&&", "msp430_use_16bit_hwmult", "(", ")", ")", ")", "{", "factor", "=", "(", "outer_code", "==", "MULT", "?", "50", ":", "70", ")", ";", "return", "factor", "*", "mode_factor", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ";", "}", "switch", "(", "outer_mode", ")", "{", "case", "E_QImode", ":", "case", "E_HImode", ":", "return", "cost_p", "->", "mulhi", "+", "(", "3", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ")", ";", "case", "E_PSImode", ":", "factor", "=", "2", ";", "case", "E_SImode", ":", "return", "factor", "*", "(", "cost_p", "->", "mulsi", "+", "(", "6", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ")", ")", ";", "case", "E_DImode", ":", "default", ":", "return", "cost_p", "->", "muldi", "+", "(", "12", "*", "msp430_costs", "(", "src", ",", "dst", ",", "speed", ",", "outer_rtx", ")", ")", ";", "}", "}", "</s>" ]

[ "Given", "source", "operand", "SRC", "and", "destination", "operand", "DST", "from", "the", "MULT/DIV/MOD", "RTX", "OUTER_RTX", ",", "return", "the", "cost", "of", "performing", "that", "operation", ",", "assuming", "optimization", "for", "speed", "when", "SPEED", "is", "true", "." ]

[ "msp430", "1", "1", "2", "3", "4", "7", "2", "5", "50", "70", "3", "2", "6", "12" ]

[]

[ "<s>", "void", "R600InstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "unsigned", "VectorComponents", "=", "0", ";", "if", "(", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "DestReg", ")", "||", "AMDGPU", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "AMDGPU", "::", "R600_Reg128RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "R600_Reg128VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "4", ";", "}", "else", "if", "(", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "DestReg", ")", "||", "AMDGPU", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "DestReg", ")", ")", "&&", "(", "AMDGPU", "::", "R600_Reg64RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "R600_Reg64VerticalRegClass", ".", "contains", "(", "SrcReg", ")", ")", ")", "{", "VectorComponents", "=", "2", ";", "}", "if", "(", "VectorComponents", ">", "0", ")", "{", "for", "(", "unsigned", "I", "=", "0", ";", "I", "<", "VectorComponents", ";", "I", "++", ")", "{", "unsigned", "SubRegIndex", "=", "AMDGPURegisterInfo", "::", "getSubRegFromChannel", "(", "I", ")", ";", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "RI", ".", "getSubReg", "(", "DestReg", ",", "SubRegIndex", ")", ",", "RI", ".", "getSubReg", "(", "SrcReg", ",", "SubRegIndex", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", "|", "RegState", "::", "Implicit", ")", ";", "}", "}", "else", "{", "MachineInstr", "*", "NewMI", "=", "buildDefaultInstruction", "(", "MBB", ",", "MI", ",", "AMDGPU", "::", "MOV", ",", "DestReg", ",", "SrcReg", ")", ";", "NewMI", "->", "getOperand", "(", "getOperandIdx", "(", "*", "NewMI", ",", "AMDGPU", "::", "OpName", "::", "src0", ")", ")", ".", "setIsKill", "(", "KillSrc", ")", ";", "}", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "AMDGPU", "R600", "0", "AMDGPU::R600_Reg128RegClass", "AMDGPU::R600_Reg128VerticalRegClass", "AMDGPU::R600_Reg128RegClass", "AMDGPU::R600_Reg128VerticalRegClass", "4", "AMDGPU::R600_Reg64RegClass", "AMDGPU::R600_Reg64VerticalRegClass", "AMDGPU::R600_Reg64RegClass", "AMDGPU::R600_Reg64VerticalRegClass", "2", "0", "0", "AMDGPU", "AMDGPU::MOV", "AMDGPU::MOV", "AMDGPU::OpName" ]

[]

[ "<s>", "MCSymbol", "*", "TLCS900MCInstLower", "::", "GetBlockAddressSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown target flag on GV operand\"", ")", ";", "case", "0", ":", "break", ";", "}", "return", "Printer", ".", "GetBlockAddressSymbol", "(", "MO", ".", "getBlockAddress", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "used", "to", "satisfy", "BlockAddress", "uses", "of", "the", "specified", "basic", "block", "." ]

[ "TLCS900", "TLCS900", "\"Unknown target flag on GV operand\"", "0" ]

[]

[ "<s>", "bool", "Thumb1RegisterInfo", "::", "saveScavengerRegister", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "MachineBasicBlock", "::", "iterator", "&", "UseMI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "unsigned", "Reg", ")", "const", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MBB", ".", "getParent", "(", ")", "->", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Kill", ")", ")", ";", "bool", "done", "=", "false", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "II", "=", "I", ";", "!", "done", "&&", "II", "!=", "UseMI", ";", "++", "II", ")", "{", "if", "(", "II", "->", "isDebugValue", "(", ")", ")", "continue", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "II", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "const", "MachineOperand", "&", "MO", "=", "II", "->", "getOperand", "(", "i", ")", ";", "if", "(", "MO", ".", "isRegMask", "(", ")", "&&", "MO", ".", "clobbersPhysReg", "(", "ARM", "::", "R12", ")", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isUndef", "(", ")", "||", "!", "MO", ".", "getReg", "(", ")", "||", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "continue", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "ARM", "::", "R12", ")", "{", "UseMI", "=", "II", ";", "done", "=", "true", ";", "break", ";", "}", "}", "}", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "UseMI", ",", "DL", ",", "TII", ".", "get", "(", "ARM", "::", "tMOVr", ")", ")", ".", "addReg", "(", "Reg", ",", "RegState", "::", "Define", ")", ".", "addReg", "(", "ARM", "::", "R12", ",", "RegState", "::", "Kill", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Spill", "the", "register", "so", "it", "can", "be", "used", "by", "the", "register", "scavenger", "." ]

[ "ARM", "ARM::tMOVr", "ARM::R12", "0", "ARM::R12", "ARM::R12", "ARM::tMOVr", "ARM::R12" ]

[]

[ "<s>", "static", "bool", "msp430_preserve_reg_p", "(", "int", "regno", ")", "{", "if", "(", "regno", "<=", "3", ")", "return", "false", ";", "if", "(", "crtl", "->", "calls_eh_return", ")", "return", "true", ";", "if", "(", "fixed_regs", "[", "regno", "]", ")", "return", "false", ";", "if", "(", "msp430_is_interrupt_func", "(", ")", "&&", "regno", ">=", "11", "&&", "regno", "<=", "15", ")", "{", "if", "(", "crtl", "->", "is_leaf", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "else", "if", "(", "!", "crtl", "->", "is_leaf", ")", "return", "true", ";", "}", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "regno", ")", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "is", "the", "one", "spot", "that", "decides", "if", "a", "register", "is", "to", "be", "saved", "and", "restored", "in", "the", "prologue/epilogue", "." ]

[ "msp430", "3", "11", "15" ]

[]

[ "<s>", "bool", "hasSPackHL", "(", ")", "const", "{", "return", "GFX11Insts", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "the", "S_PACK_HL_B32_B16", "instruction", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "bool", "XCorePassConfig", "::", "addPreEmitPass", "(", ")", "{", "addPass", "(", "createXCoreFrameToArgsOffsetEliminationPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

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

[]

[ "<s>", "bool", "AMDGPUPassConfig", "::", "addPreSched2", "(", ")", "{", "addPass", "(", "&", "IfConverterID", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "R600" ]

[]

[ "<s>", "static", "bool", "aapcs_vfp_allocate", "(", "CUMULATIVE_ARGS", "*", "pcum", ",", "machine_mode", "mode", ",", "const_tree", "type", "ATTRIBUTE_UNUSED", ")", "{", "int", "rmode_size", "=", "MAX", "(", "GET_MODE_SIZE", "(", "pcum", "->", "aapcs_vfp_rmode", ")", ",", "GET_MODE_SIZE", "(", "SFmode", ")", ")", ";", "int", "shift", "=", "rmode_size", "/", "GET_MODE_SIZE", "(", "SFmode", ")", ";", "unsigned", "mask", "=", "(", "1", "<<", "(", "shift", "*", "pcum", "->", "aapcs_vfp_rcount", ")", ")", "-", "1", ";", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "NUM_VFP_ARG_REGS", ";", "regno", "+=", "shift", ")", "if", "(", "(", "(", "pcum", "->", "aapcs_vfp_regs_free", ">>", "regno", ")", "&", "mask", ")", "==", "mask", ")", "{", "pcum", "->", "aapcs_vfp_reg_alloc", "=", "mask", "<<", "regno", ";", "if", "(", "mode", "==", "BLKmode", "||", "(", "mode", "==", "TImode", "&&", "!", "TARGET_NEON", ")", "||", "!", "arm_hard_regno_mode_ok", "(", "FIRST_VFP_REGNUM", "+", "regno", ",", "mode", ")", ")", "{", "int", "i", ";", "int", "rcount", "=", "pcum", "->", "aapcs_vfp_rcount", ";", "int", "rshift", "=", "shift", ";", "machine_mode", "rmode", "=", "pcum", "->", "aapcs_vfp_rmode", ";", "rtx", "par", ";", "if", "(", "!", "TARGET_NEON", ")", "{", "if", "(", "rmode", "==", "V2SImode", ")", "rmode", "=", "DImode", ";", "else", "if", "(", "rmode", "==", "V4SImode", ")", "{", "rmode", "=", "DImode", ";", "rcount", "*=", "2", ";", "rshift", "/=", "2", ";", "}", "}", "par", "=", "gen_rtx_PARALLEL", "(", "mode", ",", "rtvec_alloc", "(", "rcount", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "rcount", ";", "i", "++", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "rmode", ",", "FIRST_VFP_REGNUM", "+", "regno", "+", "i", "*", "rshift", ")", ";", "tmp", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "tmp", ",", "GEN_INT", "(", "i", "*", "GET_MODE_SIZE", "(", "rmode", ")", ")", ")", ";", "XVECEXP", "(", "par", ",", "0", ",", "i", ")", "=", "tmp", ";", "}", "pcum", "->", "aapcs_reg", "=", "par", ";", "}", "else", "pcum", "->", "aapcs_reg", "=", "gen_rtx_REG", "(", "mode", ",", "FIRST_VFP_REGNUM", "+", "regno", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "the", "allocate", "field", "in", "aapcs_cp_arg_layout", ".", "See", "the", "comment", "there", "for", "the", "behaviour", "of", "this", "function", "." ]

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

[]

[ "<s>", "void", "mips_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "machine_mode", "imode", "=", "GET_MODE_INNER", "(", "vmode", ")", ";", "unsigned", "i", ",", "nelt", "=", "GET_MODE_NUNITS", "(", "vmode", ")", ";", "unsigned", "nvar", "=", "0", ",", "one_var", "=", "-", "1u", ";", "bool", "all_same", "=", "true", ";", "rtx", "x", ";", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "x", "=", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ";", "if", "(", "!", "mips_constant_elt_p", "(", "x", ")", ")", "nvar", "++", ",", "one_var", "=", "i", ";", "if", "(", "i", ">", "0", "&&", "!", "rtx_equal_p", "(", "x", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ")", "all_same", "=", "false", ";", "}", "if", "(", "nvar", "==", "0", ")", "{", "emit_move_insn", "(", "target", ",", "gen_rtx_CONST_VECTOR", "(", "vmode", ",", "XVEC", "(", "vals", ",", "0", ")", ")", ")", ";", "return", ";", "}", "if", "(", "nelt", "==", "2", ")", "{", "rtx", "op0", "=", "force_reg", "(", "imode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "rtx", "op1", "=", "force_reg", "(", "imode", ",", "XVECEXP", "(", "vals", ",", "0", ",", "1", ")", ")", ";", "x", "=", "gen_rtx_VEC_CONCAT", "(", "vmode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "target", ",", "x", ")", ")", ";", "return", ";", "}", "gcc_assert", "(", "TARGET_HARD_FLOAT", "&&", "TARGET_LOONGSON_VECTORS", ")", ";", "if", "(", "all_same", ")", "{", "mips_expand_vi_broadcast", "(", "vmode", ",", "target", ",", "XVECEXP", "(", "vals", ",", "0", ",", "0", ")", ")", ";", "return", ";", "}", "if", "(", "nvar", "==", "1", "&&", "vmode", "==", "V4HImode", ")", "{", "mips_expand_vi_loongson_one_pinsrh", "(", "target", ",", "vals", ",", "one_var", ")", ";", "return", ";", "}", "mips_expand_vi_general", "(", "vmode", ",", "imode", ",", "nelt", ",", "nvar", ",", "target", ",", "vals", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vector", "initialization", "." ]

[ "mips", "0", "1u", "0", "0", "0", "0", "0", "0", "0", "2", "0", "0", "0", "1", "0", "0", "1" ]

[]

[ "<s>", "void", "finishLayout", "(", "MCAssembler", "const", "&", "Asm", ",", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "for", "(", "auto", "I", ":", "Layout", ".", "getSectionOrder", "(", ")", ")", "{", "auto", "&", "Fragments", "=", "I", "->", "getFragmentList", "(", ")", ";", "for", "(", "auto", "&", "J", ":", "Fragments", ")", "{", "switch", "(", "J", ".", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "auto", "Size", "=", "Asm", ".", "computeFragmentSize", "(", "Layout", ",", "J", ")", ";", "for", "(", "auto", "K", "=", "J", ".", "getIterator", "(", ")", ";", "K", "!=", "Fragments", ".", "begin", "(", ")", "&&", "Size", ">=", "HEXAGON_PACKET_SIZE", ";", ")", "{", "--", "K", ";", "switch", "(", "K", "->", "getKind", "(", ")", ")", "{", "default", ":", "break", ";", "case", "MCFragment", "::", "FT_Align", ":", "{", "Size", "=", "0", ";", "break", ";", "}", "case", "MCFragment", "::", "FT_Relaxable", ":", "{", "auto", "&", "RF", "=", "cast", "<", "MCRelaxableFragment", ">", "(", "*", "K", ")", ";", "auto", "&", "Inst", "=", "const_cast", "<", "MCInst", "&", ">", "(", "RF", ".", "getInst", "(", ")", ")", ";", "while", "(", "Size", ">", "0", "&&", "HexagonMCInstrInfo", "::", "bundleSize", "(", "Inst", ")", "<", "4", ")", "{", "MCInst", "*", "Nop", "=", "new", "(", "Asm", ".", "getContext", "(", ")", ")", "MCInst", ";", "Nop", "->", "setOpcode", "(", "Hexagon", "::", "A2_nop", ")", ";", "Inst", ".", "addOperand", "(", "MCOperand", "::", "createInst", "(", "Nop", ")", ")", ";", "Size", "-=", "4", ";", "if", "(", "!", "HexagonMCChecker", "(", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ",", "Inst", ",", "*", "Asm", ".", "getContext", "(", ")", ".", "getRegisterInfo", "(", ")", ")", ".", "check", "(", ")", ")", "{", "Inst", ".", "erase", "(", "Inst", ".", "end", "(", ")", "-", "1", ")", ";", "Size", "=", "0", ";", "}", "}", "bool", "Error", "=", "HexagonMCShuffle", "(", "true", ",", "*", "MCII", ",", "RF", ".", "getSubtargetInfo", "(", ")", ",", "Inst", ")", ";", "(", "void", ")", "Error", ";", "ReplaceInstruction", "(", "Asm", ".", "getEmitter", "(", ")", ",", "RF", ",", "Inst", ")", ";", "Layout", ".", "invalidateFragmentsFrom", "(", "&", "RF", ")", ";", "Size", "=", "0", ";", "break", ";", "}", "}", "}", "}", "}", "}", "}", "}", "</s>" ]

[ "Give", "backend", "an", "opportunity", "to", "finish", "layout", "after", "relaxation", "." ]

[ "Hexagon", "0", "0", "Hexagon", "4", "Hexagon::A2_nop", "4", "Hexagon", "1", "0", "Hexagon", "0" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "StringRef", "WinEHParentName", "=", "F", ".", "getFnAttribute", "(", "\"wineh-parent\"", ")", ".", "getValueAsString", "(", ")", ";", "if", "(", "WinEHParentName", "!=", "F", ".", "getName", "(", ")", "&&", "!", "WinEHParentName", ".", "empty", "(", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCasts", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isMSVCEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "auto", "*", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "std", "::", "unique_ptr", "<", "WinEHFuncInfo", ">", "FuncInfoPtr", ";", "if", "(", "!", "MMI", ")", "FuncInfoPtr", ".", "reset", "(", "new", "WinEHFuncInfo", "(", ")", ")", ";", "WinEHFuncInfo", "&", "FuncInfo", "=", "*", "(", "MMI", "?", "&", "MMI", "->", "getWinEHFuncInfo", "(", "&", "F", ")", ":", "FuncInfoPtr", ".", "get", "(", ")", ")", ";", "FuncInfo", ".", "EHRegNode", "=", "RegNode", ";", "switch", "(", "Personality", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unexpected personality function\"", ")", ";", "case", "EHPersonality", "::", "MSVC_CXX", ":", "addCXXStateStores", "(", "F", ",", "FuncInfo", ")", ";", "break", ";", "case", "EHPersonality", "::", "MSVC_X86SEH", ":", "addSEHStateStores", "(", "F", ",", "FuncInfo", ")", ";", "break", ";", "}", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "return", "true", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

[ "X86", "\"wineh-parent\"", "\"no-frame-pointer-elim\"", "\"true\"", "\"unexpected personality function\"", "X86" ]

[]

[ "<s>", "void", "HCE", "::", "collect", "(", "MachineFunction", "&", "MF", ")", "{", "Extenders", ".", "clear", "(", ")", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "for", "(", "MachineInstr", "&", "MI", ":", "MBB", ")", "collectInstr", "(", "MI", ")", ";", "}", "</s>" ]

[ "Analyze", "the", "given", "instruction", "MI", "and", "fill", "in", "the", "Uses", ",", "Defs", "and", "DeadDefs", "list", "based", "on", "the", "MachineOperand", "flags", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "s390_expand_atomic", "(", "machine_mode", "mode", ",", "enum", "rtx_code", "code", ",", "rtx", "target", ",", "rtx", "mem", ",", "rtx", "val", ",", "bool", "after", ")", "{", "struct", "alignment_context", "ac", ";", "rtx", "cmp", ";", "rtx", "new_rtx", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "orig", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx_code_label", "*", "csloop", "=", "gen_label_rtx", "(", ")", ";", "gcc_assert", "(", "!", "target", "||", "register_operand", "(", "target", ",", "VOIDmode", ")", ")", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "init_alignment_context", "(", "&", "ac", ",", "mem", ",", "mode", ")", ";", "if", "(", "!", "(", "ac", ".", "aligned", "&&", "code", "==", "SET", "&&", "MEM_P", "(", "val", ")", ")", ")", "val", "=", "s390_expand_mask_and_shift", "(", "val", ",", "mode", ",", "ac", ".", "shift", ")", ";", "if", "(", "code", "==", "PLUS", "||", "code", "==", "MINUS", ")", "emit_move_insn", "(", "orig", ",", "val", ")", ";", "else", "if", "(", "code", "==", "MULT", "||", "code", "==", "AND", ")", "val", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "val", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "cmp", "=", "force_reg", "(", "SImode", ",", "ac", ".", "memsi", ")", ";", "emit_label", "(", "csloop", ")", ";", "emit_move_insn", "(", "new_rtx", ",", "cmp", ")", ";", "switch", "(", "code", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "val", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new_rtx", ",", "orig", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "val", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "case", "SET", ":", "if", "(", "ac", ".", "aligned", "&&", "MEM_P", "(", "val", ")", ")", "store_bit_field", "(", "new_rtx", ",", "GET_MODE_BITSIZE", "(", "mode", ")", ",", "0", ",", "0", ",", "0", ",", "SImode", ",", "val", ")", ";", "else", "{", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new_rtx", ",", "ac", ".", "modemaski", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "IOR", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "break", ";", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "code", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "case", "MULT", ":", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "new_rtx", ",", "val", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "new_rtx", "=", "expand_simple_binop", "(", "SImode", ",", "XOR", ",", "new_rtx", ",", "ac", ".", "modemask", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "s390_emit_jump", "(", "csloop", ",", "s390_emit_compare_and_swap", "(", "NE", ",", "cmp", ",", "ac", ".", "memsi", ",", "cmp", ",", "new_rtx", ")", ")", ";", "if", "(", "target", ")", "convert_move", "(", "target", ",", "expand_simple_binop", "(", "SImode", ",", "LSHIFTRT", ",", "after", "?", "new_rtx", ":", "cmp", ",", "ac", ".", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ",", "1", ")", ";", "}", "</s>" ]

[ "Expand", "an", "atomic", "operation", "CODE", "of", "mode", "MODE", ".", "MEM", "is", "the", "memory", "location", "and", "VAL", "the", "value", "to", "play", "with", ".", "If", "AFTER", "is", "true", "then", "store", "the", "the", "value", "MEM", "holds", "after", "the", "operation", ",", "if", "AFTER", "is", "false", "then", "store", "the", "value", "MEM", "holds", "before", "the", "operation", ".", "If", "TARGET", "is", "zero", "then", "discard", "that", "value", ",", "else", "store", "it", "to", "TARGET", "." ]

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

[]

[ "<s>", "const", "DLXRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "DLX", "DLX" ]

[]

[ "<s>", "unsigned", "getTypeID", "(", "Type", "*", "T", ")", "const", "{", "TypeMapType", "::", "const_iterator", "I", "=", "TypeMap", ".", "find", "(", "T", ")", ";", "assert", "(", "I", "!=", "TypeMap", ".", "end", "(", ")", "&&", "\"Type not in ValueEnumerator!\"", ")", ";", "return", "I", "->", "second", "-", "1", ";", "}", "</s>" ]

[ "Return", "the", "type", "id", "for", "the", "type", "." ]

[ "DirectX", "\"Type not in ValueEnumerator!\"", "1" ]

[]

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

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

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

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "LLVMContext", "&", "Context", ",", "CallingConv", "::", "ID", "CC", ",", "EVT", "VT", ",", "EVT", "&", "IntermediateVT", ",", "unsigned", "&", "NumIntermediates", ",", "MVT", "&", "RegisterVT", ")", "const", "{", "if", "(", "VT", ".", "isVector", "(", ")", "&&", "VT", ".", "getVectorElementType", "(", ")", "==", "MVT", "::", "i1", "&&", "Subtarget", ".", "hasAVX512", "(", ")", "&&", "(", "!", "isPowerOf2_32", "(", "VT", ".", "getVectorNumElements", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "16", "&&", "!", "Subtarget", ".", "hasBWI", "(", ")", ")", "||", "(", "VT", ".", "getVectorNumElements", "(", ")", ">", "64", "&&", "Subtarget", ".", "hasBWI", "(", ")", ")", ")", ")", "{", "RegisterVT", "=", "MVT", "::", "i8", ";", "IntermediateVT", "=", "MVT", "::", "i1", ";", "NumIntermediates", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "return", "NumIntermediates", ";", "}", "if", "(", "VT", "==", "MVT", "::", "v64i1", "&&", "Subtarget", ".", "hasBWI", "(", ")", "&&", "!", "Subtarget", ".", "useAVX512Regs", "(", ")", "&&", "CC", "!=", "CallingConv", "::", "X86_RegCall", ")", "{", "RegisterVT", "=", "MVT", "::", "v32i1", ";", "IntermediateVT", "=", "MVT", "::", "v32i1", ";", "NumIntermediates", "=", "2", ";", "return", "2", ";", "}", "return", "TargetLowering", "::", "getVectorTypeBreakdownForCallingConv", "(", "Context", ",", "CC", ",", "VT", ",", "IntermediateVT", ",", "NumIntermediates", ",", "RegisterVT", ")", ";", "}", "</s>" ]

[ "Certain", "targets", "such", "as", "MIPS", "require", "that", "some", "types", "such", "as", "vectors", "are", "always", "broken", "down", "into", "scalars", "in", "some", "contexts", "." ]

[ "X86", "X86", "MVT::i1", "16", "64", "MVT::i8", "MVT::i1", "MVT::v64i1", "X86", "MVT::v32i1", "MVT::v32i1", "2", "2" ]

[]

[ "<s>", "static", "bool", "dimode_scalar_to_vector_candidate_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "def_set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "def_set", ")", "return", "false", ";", "if", "(", "has_non_address_hard_reg", "(", "insn", ")", ")", "return", "false", ";", "rtx", "src", "=", "SET_SRC", "(", "def_set", ")", ";", "rtx", "dst", "=", "SET_DEST", "(", "def_set", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "COMPARE", ")", "return", "convertible_comparison_p", "(", "insn", ")", ";", "if", "(", "(", "GET_MODE", "(", "src", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "src", ")", ")", "||", "GET_MODE", "(", "dst", ")", "!=", "DImode", ")", "return", "false", ";", "if", "(", "!", "REG_P", "(", "dst", ")", "&&", "!", "MEM_P", "(", "dst", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "src", ")", ")", "{", "case", "ASHIFTRT", ":", "if", "(", "!", "TARGET_AVX512VL", ")", "return", "false", ";", "case", "ASHIFT", ":", "case", "LSHIFTRT", ":", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "||", "!", "IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "src", ",", "1", ")", ")", ",", "0", ",", "63", ")", ")", "return", "false", ";", "break", ";", "case", "PLUS", ":", "case", "MINUS", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "AND", ":", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "1", ")", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "1", ")", ")", ")", "return", "false", ";", "break", ";", "case", "NEG", ":", "case", "NOT", ":", "break", ";", "case", "REG", ":", "return", "true", ";", "case", "MEM", ":", "case", "CONST_INT", ":", "return", "REG_P", "(", "dst", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "!", "REG_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "MEM_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", "&&", "(", "GET_CODE", "(", "src", ")", "!=", "AND", "||", "GET_CODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "NOT", "||", "!", "REG_P", "(", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ")", ")", ")", "return", "false", ";", "if", "(", "GET_MODE", "(", "XEXP", "(", "src", ",", "0", ")", ")", "!=", "DImode", "&&", "!", "CONST_INT_P", "(", "XEXP", "(", "src", ",", "0", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "DImode", "version", "of", "scalar_to_vector_candidate_p", "." ]

[ "i386", "1", "1", "0", "63", "1", "1", "1", "1", "1", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "AAPAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "Operands", ".", "push_back", "(", "AAPOperand", "::", "CreateToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "while", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", "&&", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "Comma", ")", ")", "{", "getLexer", "(", ")", ".", "Lex", "(", ")", ";", "if", "(", "ParseOperand", "(", "Operands", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AAP", "AAP", "AAPOperand::CreateToken" ]

[]

[ "<s>", "static", "machine_mode", "frv_matching_accg_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "V4SImode", ":", "return", "V4QImode", ";", "case", "DImode", ":", "return", "HImode", ";", "case", "SImode", ":", "return", "QImode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "If", "an", "ACC", "rtx", "has", "mode", "MODE", ",", "return", "the", "mode", "that", "the", "matching", "ACCG", "should", "have", "." ]

[ "frv" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "CI", ",", "MachineFunction", "&", "MF", ",", "unsigned", "IntrID", ")", "const", "{", "if", "(", "const", "AMDGPU", "::", "RsrcIntrinsic", "*", "RsrcIntr", "=", "AMDGPU", "::", "lookupRsrcIntrinsic", "(", "IntrID", ")", ")", "{", "AttributeList", "Attr", "=", "Intrinsic", "::", "getAttributes", "(", "CI", ".", "getContext", "(", ")", ",", "(", "Intrinsic", "::", "ID", ")", "IntrID", ")", ";", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "ReadNone", ")", ")", "return", "false", ";", "SIMachineFunctionInfo", "*", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "if", "(", "RsrcIntr", "->", "IsImage", ")", "{", "Info", ".", "ptrVal", "=", "MFI", "->", "getImagePSV", "(", "*", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "RsrcIntr", "->", "RsrcArg", ")", ")", ";", "Info", ".", "align", "=", "0", ";", "}", "else", "{", "Info", ".", "ptrVal", "=", "MFI", "->", "getBufferPSV", "(", "*", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ",", "CI", ".", "getArgOperand", "(", "RsrcIntr", "->", "RsrcArg", ")", ")", ";", "}", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MODereferenceable", ";", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "ReadOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ",", "true", ")", ";", "if", "(", "Info", ".", "memVT", "==", "MVT", "::", "Other", ")", "{", "Info", ".", "memVT", "=", "memVTFromAggregate", "(", "CI", ".", "getType", "(", ")", ")", ";", "}", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "}", "else", "if", "(", "Attr", ".", "hasFnAttribute", "(", "Attribute", "::", "WriteOnly", ")", ")", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_VOID", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "}", "else", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MODereferenceable", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "}", "return", "true", ";", "}", "switch", "(", "IntrID", ")", "{", "case", "Intrinsic", "::", "amdgcn_atomic_inc", ":", "case", "Intrinsic", "::", "amdgcn_atomic_dec", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_add", ":", "case", "Intrinsic", "::", "amdgcn_ds_ordered_swap", ":", "case", "Intrinsic", "::", "amdgcn_ds_fadd", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmin", ":", "case", "Intrinsic", "::", "amdgcn_ds_fmax", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "CI", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "CI", ".", "getOperand", "(", "0", ")", ";", "Info", ".", "align", "=", "0", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", ";", "const", "ConstantInt", "*", "Vol", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CI", ".", "getOperand", "(", "4", ")", ")", ";", "if", "(", "!", "Vol", "||", "!", "Vol", "->", "isZero", "(", ")", ")", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "AMDGPU", "SI", "AMDGPU::RsrcIntrinsic", "AMDGPU::lookupRsrcIntrinsic", "Intrinsic::getAttributes", "Intrinsic::ID", "SI", "SI", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "MVT::Other", "ISD::INTRINSIC_VOID", "MVT::getVT", "0", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "Intrinsic::amdgcn_atomic_inc", "Intrinsic::amdgcn_atomic_dec", "Intrinsic::amdgcn_ds_ordered_add", "Intrinsic::amdgcn_ds_ordered_swap", "Intrinsic::amdgcn_ds_fadd", "Intrinsic::amdgcn_ds_fmin", "Intrinsic::amdgcn_ds_fmax", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "4" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AsmPrinter", "::", "getAnalysisUsage", "(", "AU", ")", ";", "AU", ".", "setPreservesAll", "(", ")", ";", "}", "</s>" ]

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

[ "ARM64" ]

[]

[ "<s>", "void", "AMDGPUTTI", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "for", "(", "Loop", "::", "block_iterator", "BI", "=", "L", "->", "block_begin", "(", ")", ",", "BE", "=", "L", "->", "block_end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "BasicBlock", "*", "BB", "=", "*", "BI", ";", "for", "(", "BasicBlock", "::", "const_iterator", "I", "=", "BB", "->", "begin", "(", ")", ",", "E", "=", "BB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "const", "GetElementPtrInst", "*", "GEP", "=", "dyn_cast", "<", "GetElementPtrInst", ">", "(", "I", ")", ";", "if", "(", "!", "GEP", ")", "continue", ";", "const", "Value", "*", "Ptr", "=", "GEP", "->", "getPointerOperand", "(", ")", ";", "const", "AllocaInst", "*", "Alloca", "=", "dyn_cast", "<", "AllocaInst", ">", "(", "GetUnderlyingObject", "(", "Ptr", ")", ")", ";", "if", "(", "Alloca", ")", "{", "UP", ".", "Threshold", "=", "500", ";", "}", "}", "}", "}", "</s>" ]

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

[ "R600", "500" ]

[]

[ "<s>", "bool", "sh2a_function_vector_p", "(", "tree", "func", ")", "{", "if", "(", "TREE_CODE", "(", "func", ")", "!=", "FUNCTION_DECL", ")", "return", "false", ";", "for", "(", "tree", "list", "=", "SH_ATTRIBUTES", "(", "func", ")", ";", "list", ";", "list", "=", "TREE_CHAIN", "(", "list", ")", ")", "if", "(", "is_attribute_p", "(", "\"function_vector\"", ",", "get_attribute_name", "(", "list", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "true", "if", "FUNC", "has", "been", "assigned", "the", "attribute", "``", "function_vector", "''", "." ]

[ "sh", "\"function_vector\"" ]

[]

[ "<s>", "bool", "PTXPassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createPTXISelDag", "(", "getPTXTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PTX", "PTX", "PTX", "PTX" ]

[]

[ "<s>", "static", "rtx_insn", "*", "conditionalize_block", "(", "rtx_insn", "*", "first", ")", "{", "rtx_insn", "*", "insn", ";", "rtx", "br_pat", ";", "rtx_insn", "*", "end_blk_1_br", "=", "0", ";", "rtx_insn", "*", "end_blk_2_insn", "=", "0", ";", "rtx_insn", "*", "start_blk_3_lab", "=", "0", ";", "int", "cond", ";", "int", "br_lab_num", ";", "int", "blk_size", "=", "0", ";", "if", "(", "!", "JUMP_P", "(", "first", ")", "||", "GET_CODE", "(", "PATTERN", "(", "first", ")", ")", "!=", "SET", "||", "GET_CODE", "(", "XEXP", "(", "PATTERN", "(", "first", ")", ",", "1", ")", ")", "!=", "IF_THEN_ELSE", ")", "return", "NEXT_INSN", "(", "first", ")", ";", "end_blk_1_br", "=", "first", ";", "br_pat", "=", "PATTERN", "(", "end_blk_1_br", ")", ";", "cond", "=", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "br_pat", ",", "1", ")", ",", "0", ")", ")", "==", "EQ", ")", ";", "if", "(", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "br_pat", ",", "1", ")", ",", "1", ")", ")", "==", "LABEL_REF", ")", "{", "br_lab_num", "=", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "br_pat", ",", "1", ")", ",", "1", ")", ",", "0", ")", ")", ";", "}", "else", "{", "cond", "=", "(", "cond", "==", "0", ")", ";", "br_lab_num", "=", "CODE_LABEL_NUMBER", "(", "XEXP", "(", "XEXP", "(", "XEXP", "(", "br_pat", ",", "1", ")", ",", "2", ")", ",", "0", ")", ")", ";", "}", "for", "(", "insn", "=", "NEXT_INSN", "(", "first", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "enum", "rtx_code", "code", ";", "code", "=", "GET_CODE", "(", "insn", ")", ";", "if", "(", "code", "==", "CODE_LABEL", "&&", "CODE_LABEL_NUMBER", "(", "insn", ")", "==", "br_lab_num", ")", "break", ";", "if", "(", "code", "!=", "BARRIER", "&&", "code", "!=", "NOTE", "&&", "!", "is_cond_candidate", "(", "insn", ")", ")", "return", "NEXT_INSN", "(", "insn", ")", ";", "if", "(", "code", "==", "JUMP_INSN", "||", "code", "==", "INSN", ")", "{", "blk_size", "++", ";", "end_blk_2_insn", "=", "insn", ";", "}", "}", "if", "(", "!", "insn", ")", "return", "insn", ";", "if", "(", "optimize", ">", "1", "&&", "blk_size", ">", "2", ")", "return", "insn", ";", "start_blk_3_lab", "=", "insn", ";", "for", "(", "insn", "=", "NEXT_INSN", "(", "end_blk_1_br", ")", ";", "insn", "!=", "start_blk_3_lab", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "rtx_insn", "*", "newinsn", ";", "if", "(", "insn", "->", "deleted", "(", ")", ")", "continue", ";", "if", "(", "(", "newinsn", "=", "emit_new_cond_insn", "(", "insn", ",", "cond", ")", ")", ")", "{", "if", "(", "end_blk_2_insn", "==", "insn", ")", "end_blk_2_insn", "=", "newinsn", ";", "insn", "=", "newinsn", ";", "}", "}", "if", "(", "LABEL_NUSES", "(", "start_blk_3_lab", ")", "==", "1", ")", "{", "start_blk_3_lab", "=", "0", ";", "}", "delete_insn", "(", "end_blk_1_br", ")", ";", "if", "(", "!", "start_blk_3_lab", ")", "return", "end_blk_2_insn", ";", "return", "NEXT_INSN", "(", "start_blk_3_lab", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "change", "a", "basic", "block", "into", "a", "series", "of", "conditional", "insns", ".", "This", "works", "by", "taking", "the", "branch", "at", "the", "end", "of", "the", "1st", "block", "and", "scanning", "for", "the", "end", "of", "the", "2nd", "block", ".", "If", "all", "instructions", "in", "the", "2nd", "block", "have", "cond", ".", "versions", "and", "the", "label", "at", "the", "start", "of", "block", "3", "is", "the", "same", "as", "the", "target", "from", "the", "branch", "at", "block", "1", ",", "then", "conditionalize", "all", "insn", "in", "block", "2", "using", "the", "inverse", "condition", "of", "the", "branch", "at", "block", "1", ".", "(", "Note", "I", "'m", "bending", "the", "definition", "of", "basic", "block", "here", ".", ")", "e.g.", ",", "change", ":", "bt", "L2", "<", "--", "end", "of", "block", "1", "(", "delete", ")", "mov", "r7", ",", "r8", "addu", "r7,1", "br", "L3", "<", "--", "end", "of", "block", "2", "L2", ":", "...", "<", "--", "start", "of", "block", "3", "(", "NUSES==1", ")", "L3", ":", "...", "to", ":", "movf", "r7", ",", "r8", "incf", "r7", "bf", "L3", "L3", ":", "...", "we", "can", "delete", "the", "L2", "label", "if", "NUSES==1", "and", "re-apply", "the", "optimization", "starting", "at", "the", "last", "instruction", "of", "block", "2", ".", "This", "may", "allow", "an", "entire", "if-then-else", "statement", "to", "be", "conditionalized", ".", "BRC" ]

[ "mcore", "0", "0", "0", "0", "1", "1", "0", "1", "1", "1", "1", "0", "0", "1", "2", "0", "1", "2", "1", "0" ]

[]

[ "<s>", "static", "HOST_WIDE_INT", "spu_static_rtx_alignment", "(", "machine_mode", "mode", ")", "{", "return", "MAX", "(", "GET_MODE_ALIGNMENT", "(", "mode", ")", ",", "128", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_STATIC_RTX_ALIGNMENT", ".", "Make", "all", "static", "objects", "16-byte", "aligned", ".", "This", "allows", "us", "to", "assume", "they", "are", "also", "padded", "to", "16", "bytes", ",", "which", "means", "we", "can", "use", "a", "single", "load", "or", "store", "instruction", "to", "access", "them", "." ]

[ "spu", "128" ]

[]

[ "<s>", "int", "ConvergingVLIWScheduler", "::", "SchedulingCost", "(", "ReadyQueue", "&", "Q", ",", "SUnit", "*", "SU", ",", "SchedCandidate", "&", "Candidate", ",", "RegPressureDelta", "&", "Delta", ",", "bool", "verbose", ")", "{", "int", "ResCount", "=", "1", ";", "if", "(", "!", "SU", "||", "SU", "->", "isScheduled", ")", "return", "ResCount", ";", "if", "(", "SU", "->", "isScheduleHigh", ")", "ResCount", "+=", "PriorityOne", ";", "if", "(", "Q", ".", "getID", "(", ")", "==", "TopQID", ")", "{", "ResCount", "+=", "(", "SU", "->", "getHeight", "(", ")", "*", "ScaleTwo", ")", ";", "if", "(", "Top", ".", "ResourceModel", "->", "isResourceAvailable", "(", "SU", ")", ")", "ResCount", "<<=", "FactorOne", ";", "}", "else", "{", "ResCount", "+=", "(", "SU", "->", "getDepth", "(", ")", "*", "ScaleTwo", ")", ";", "if", "(", "Bot", ".", "ResourceModel", "->", "isResourceAvailable", "(", "SU", ")", ")", "ResCount", "<<=", "FactorOne", ";", "}", "unsigned", "NumNodesBlocking", "=", "0", ";", "if", "(", "Q", ".", "getID", "(", ")", "==", "TopQID", ")", "{", "for", "(", "SUnit", "::", "const_succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "getSingleUnscheduledPred", "(", "I", "->", "getSUnit", "(", ")", ")", "==", "SU", ")", "++", "NumNodesBlocking", ";", "}", "else", "{", "for", "(", "SUnit", "::", "const_pred_iterator", "I", "=", "SU", "->", "Preds", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Preds", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "getSingleUnscheduledSucc", "(", "I", "->", "getSUnit", "(", ")", ")", "==", "SU", ")", "++", "NumNodesBlocking", ";", "}", "ResCount", "+=", "(", "NumNodesBlocking", "*", "ScaleTwo", ")", ";", "ResCount", "-=", "(", "Delta", ".", "Excess", ".", "getUnitInc", "(", ")", "*", "PriorityTwo", ")", ";", "ResCount", "-=", "(", "Delta", ".", "CriticalMax", ".", "getUnitInc", "(", ")", "*", "PriorityTwo", ")", ";", "DEBUG", "(", "if", "(", "verbose", ")", "dbgs", "(", ")", "<<", "\" Total(\"", "<<", "ResCount", "<<", "\")\"", ")", ";", "return", "ResCount", ";", "}", "</s>" ]

[ "Single", "point", "to", "compute", "overall", "scheduling", "cost", "." ]

[ "Hexagon", "1", "0", "\" Total(\"", "\")\"" ]

[]

[ "<s>", "const", "uint32_t", "*", "X86RegisterInfo", "::", "getCallPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "const", "X86Subtarget", "&", "Subtarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "bool", "HasSSE", "=", "Subtarget", ".", "hasSSE1", "(", ")", ";", "bool", "HasAVX", "=", "Subtarget", ".", "hasAVX", "(", ")", ";", "bool", "HasAVX512", "=", "Subtarget", ".", "hasAVX512", "(", ")", ";", "switch", "(", "CC", ")", "{", "case", "CallingConv", "::", "GHC", ":", "case", "CallingConv", "::", "HiPE", ":", "return", "CSR_NoRegs_RegMask", ";", "case", "CallingConv", "::", "AnyReg", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveMost", ":", "return", "CSR_64_RT_MostRegs_RegMask", ";", "case", "CallingConv", "::", "PreserveAll", ":", "if", "(", "HasAVX", ")", "return", "CSR_64_RT_AllRegs_AVX_RegMask", ";", "return", "CSR_64_RT_AllRegs_RegMask", ";", "case", "CallingConv", "::", "CXX_FAST_TLS", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_TLS_Darwin_RegMask", ";", "break", ";", "case", "CallingConv", "::", "Intel_OCL_BI", ":", "{", "if", "(", "HasAVX512", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX512", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX512_RegMask", ";", "if", "(", "HasAVX", "&&", "IsWin64", ")", "return", "CSR_Win64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "HasAVX", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_AVX_RegMask", ";", "if", "(", "!", "HasAVX", "&&", "!", "IsWin64", "&&", "Is64Bit", ")", "return", "CSR_64_Intel_OCL_BI_RegMask", ";", "break", ";", "}", "case", "CallingConv", "::", "HHVM", ":", "return", "CSR_64_HHVM_RegMask", ";", "case", "CallingConv", "::", "Cold", ":", "if", "(", "Is64Bit", ")", "return", "CSR_64_MostRegs_RegMask", ";", "break", ";", "case", "CallingConv", "::", "X86_64_Win64", ":", "return", "CSR_Win64_RegMask", ";", "case", "CallingConv", "::", "X86_64_SysV", ":", "return", "CSR_64_RegMask", ";", "case", "CallingConv", "::", "X86_INTR", ":", "if", "(", "Is64Bit", ")", "{", "if", "(", "HasAVX512", ")", "return", "CSR_64_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_64_AllRegs_AVX_RegMask", ";", "return", "CSR_64_AllRegs_RegMask", ";", "}", "else", "{", "if", "(", "HasAVX512", ")", "return", "CSR_32_AllRegs_AVX512_RegMask", ";", "if", "(", "HasAVX", ")", "return", "CSR_32_AllRegs_AVX_RegMask", ";", "if", "(", "HasSSE", ")", "return", "CSR_32_AllRegs_SSE_RegMask", ";", "return", "CSR_32_AllRegs_RegMask", ";", "}", "default", ":", "break", ";", "}", "if", "(", "Is64Bit", ")", "{", "if", "(", "IsWin64", ")", "return", "CSR_Win64_RegMask", ";", "if", "(", "Subtarget", ".", "getTargetLowering", "(", ")", "->", "supportSwiftError", "(", ")", "&&", "MF", ".", "getFunction", "(", ")", "->", "getAttributes", "(", ")", ".", "hasAttrSomewhere", "(", "Attribute", "::", "SwiftError", ")", ")", "return", "CSR_64_SwiftError_RegMask", ";", "return", "CSR_64_RegMask", ";", "}", "return", "CSR_32_RegMask", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "X86FrameInfo", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "!", "MF", ".", "getFrameInfo", "(", ")", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "&", "SP", "::", "I64RegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDXri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "IntRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "FPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "if", "(", "RC", "==", "&", "SP", "::", "DFPRegsRegClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "LDDFri", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "else", "llvm_unreachable", "(", "\"Can't load this register from stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::I64RegsRegClass", "SP::LDXri", "0", "SP::IntRegsRegClass", "SP::LDri", "0", "SP::FPRegsRegClass", "SP::LDFri", "0", "SP::DFPRegsRegClass", "SP::LDDFri", "0", "\"Can't load this register from stack slot\"" ]

[]

[ "<s>", "static", "void", "setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", ",", "int", "*", "pretend_size", ",", "int", "no_rtl", ")", "{", "rtx", "mem", ";", "int", "i", ";", "if", "(", "no_rtl", ")", "return", ";", "for", "(", "i", "=", "get_cumulative_args", "(", "cum", ")", "->", "words", "+", "1", ";", "i", "<", "max_arg_registers", ";", "i", "++", ")", "{", "mem", "=", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "arg_pointer_rtx", ",", "(", "i", "*", "UNITS_PER_WORD", ")", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "gen_rtx_REG", "(", "Pmode", ",", "i", ")", ")", ";", "}", "*", "pretend_size", "=", "0", ";", "}", "</s>" ]

[ "Perform", "any", "needed", "actions", "needed", "for", "a", "function", "that", "is", "receiving", "a", "variable", "number", "of", "arguments", ".", "CUM", "is", "as", "above", ".", "MODE", "and", "TYPE", "are", "the", "mode", "and", "type", "of", "the", "current", "parameter", ".", "PRETEND_SIZE", "is", "a", "variable", "that", "should", "be", "set", "to", "the", "amount", "of", "stack", "that", "must", "be", "pushed", "by", "the", "prolog", "to", "pretend", "that", "our", "caller", "pushed", "it", ".", "Normally", ",", "this", "macro", "will", "push", "all", "remaining", "incoming", "registers", "on", "the", "stack", "and", "set", "PRETEND_SIZE", "to", "the", "length", "of", "the", "registers", "pushed", "." ]

[ "bfin", "1", "0" ]

[]

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

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

[ "ARM" ]

[]

[ "<s>", "unsigned", "getNumFixupKinds", "(", ")", "const", "{", "return", "OR1K", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "OR1K", "OR1K::NumTargetFixupKinds" ]

[]

[ "<s>", "bool", "AArch64AsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNum", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "OpNum", ")", ";", "if", "(", "!", "AsmPrinter", "::", "PrintAsmOperand", "(", "MI", ",", "OpNum", ",", "ExtraCode", ",", "O", ")", ")", "return", "false", ";", "if", "(", "ExtraCode", "&&", "ExtraCode", "[", "0", "]", ")", "{", "if", "(", "ExtraCode", "[", "1", "]", "!=", "0", ")", "return", "true", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "default", ":", "return", "true", ";", "case", "'w'", ":", "case", "'x'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "ExtraCode", "[", "0", "]", ",", "O", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", "&&", "MO", ".", "getImm", "(", ")", "==", "0", ")", "{", "unsigned", "Reg", "=", "ExtraCode", "[", "0", "]", "==", "'w'", "?", "AArch64", "::", "WZR", ":", "AArch64", "::", "XZR", ";", "O", "<<", "AArch64InstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "return", "false", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "case", "'b'", ":", "case", "'h'", ":", "case", "'s'", ":", "case", "'d'", ":", "case", "'q'", ":", "case", "'z'", ":", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "ExtraCode", "[", "0", "]", ")", "{", "case", "'b'", ":", "RC", "=", "&", "AArch64", "::", "FPR8RegClass", ";", "break", ";", "case", "'h'", ":", "RC", "=", "&", "AArch64", "::", "FPR16RegClass", ";", "break", ";", "case", "'s'", ":", "RC", "=", "&", "AArch64", "::", "FPR32RegClass", ";", "break", ";", "case", "'d'", ":", "RC", "=", "&", "AArch64", "::", "FPR64RegClass", ";", "break", ";", "case", "'q'", ":", "RC", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "break", ";", "case", "'z'", ":", "RC", "=", "&", "AArch64", "::", "ZPRRegClass", ";", "break", ";", "default", ":", "return", "true", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RC", ",", "AArch64", "::", "NoRegAltName", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "}", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "Register", "Reg", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "AArch64", "::", "GPR32allRegClass", ".", "contains", "(", "Reg", ")", "||", "AArch64", "::", "GPR64allRegClass", ".", "contains", "(", "Reg", ")", ")", "return", "printAsmMRegister", "(", "MO", ",", "'x'", ",", "O", ")", ";", "unsigned", "AltName", "=", "AArch64", "::", "NoRegAltName", ";", "const", "TargetRegisterClass", "*", "RegClass", ";", "if", "(", "AArch64", "::", "ZPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "RegClass", "=", "&", "AArch64", "::", "ZPRRegClass", ";", "}", "else", "if", "(", "AArch64", "::", "PPRRegClass", ".", "contains", "(", "Reg", ")", ")", "{", "RegClass", "=", "&", "AArch64", "::", "PPRRegClass", ";", "}", "else", "{", "RegClass", "=", "&", "AArch64", "::", "FPR128RegClass", ";", "AltName", "=", "AArch64", "::", "vreg", ";", "}", "return", "printAsmRegInClass", "(", "MO", ",", "RegClass", ",", "AltName", ",", "O", ")", ";", "}", "printOperand", "(", "MI", ",", "OpNum", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "1", "0", "0", "0", "0", "0", "AArch64::WZR", "AArch64::XZR", "AArch64", "0", "AArch64::FPR8RegClass", "AArch64::FPR16RegClass", "AArch64::FPR32RegClass", "AArch64::FPR64RegClass", "AArch64::FPR128RegClass", "AArch64::ZPRRegClass", "AArch64::NoRegAltName", "AArch64::GPR32allRegClass", "AArch64::GPR64allRegClass", "AArch64::NoRegAltName", "AArch64::ZPRRegClass", "AArch64::ZPRRegClass", "AArch64::PPRRegClass", "AArch64::PPRRegClass", "AArch64::FPR128RegClass", "AArch64::vreg" ]

[]

[ "<s>", "void", "aarch64_sve_expand_vector_init", "(", "rtx", "target", ",", "rtx", "vals", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "target", ")", ";", "int", "nelts", "=", "XVECLEN", "(", "vals", ",", "0", ")", ";", "rtx_vector_builder", "v", "(", "mode", ",", "nelts", ",", "1", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nelts", ";", "i", "++", ")", "v", ".", "quick_push", "(", "XVECEXP", "(", "vals", ",", "0", ",", "i", ")", ")", ";", "v", ".", "finalize", "(", ")", ";", "if", "(", "nelts", "<", "4", "||", "!", "aarch64_sve_expand_vector_init", "(", "target", ",", "v", ",", "nelts", ",", "nelts", ")", ")", "aarch64_sve_expand_vector_init_insert_elems", "(", "target", ",", "v", ",", "nelts", ")", ";", "}", "</s>" ]

[ "Initialize", "register", "TARGET", "from", "the", "elements", "in", "PARALLEL", "rtx", "VALS", "." ]

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

[]

[ "<s>", "bool", "m68k_legitimate_base_reg_p", "(", "rtx", "x", ",", "bool", "strict_p", ")", "{", "if", "(", "!", "strict_p", "&&", "GET_CODE", "(", "x", ")", "==", "SUBREG", ")", "x", "=", "SUBREG_REG", "(", "x", ")", ";", "return", "(", "REG_P", "(", "x", ")", "&&", "(", "strict_p", "?", "REGNO_OK_FOR_BASE_P", "(", "REGNO", "(", "x", ")", ")", ":", "REGNO_OK_FOR_BASE_NONSTRICT_P", "(", "REGNO", "(", "x", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "a", "legitimate", "base", "register", ".", "STRICT_P", "says", "whether", "we", "need", "strict", "checking", "." ]

[ "m68k" ]

[]

[ "<s>", "enum", "machine_mode", "visium_select_cc_mode", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "if", "(", "GET_MODE_CLASS", "(", "GET_MODE", "(", "op0", ")", ")", "==", "MODE_FLOAT", ")", "{", "switch", "(", "code", ")", "{", "case", "EQ", ":", "case", "NE", ":", "case", "ORDERED", ":", "case", "UNORDERED", ":", "case", "UNLT", ":", "case", "UNLE", ":", "case", "UNGT", ":", "case", "UNGE", ":", "return", "CCFPmode", ";", "case", "LT", ":", "case", "LE", ":", "case", "GT", ":", "case", "GE", ":", "return", "CCFPEmode", ";", "case", "UNEQ", ":", "case", "LTGT", ":", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "if", "(", "op1", "==", "constm1_rtx", ")", "return", "CCCmode", ";", "if", "(", "(", "code", "==", "LTU", "||", "code", "==", "GEU", ")", "&&", "GET_CODE", "(", "op0", ")", "==", "PLUS", "&&", "rtx_equal_p", "(", "XEXP", "(", "op0", ",", "0", ")", ",", "op1", ")", ")", "return", "CCCmode", ";", "if", "(", "(", "code", "==", "EQ", "||", "code", "==", "NE", ")", "&&", "GET_CODE", "(", "op1", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "op1", ",", "1", ")", "==", "UNSPEC_ADDV", "||", "XINT", "(", "op1", ",", "1", ")", "==", "UNSPEC_SUBV", "||", "XINT", "(", "op1", ",", "1", ")", "==", "UNSPEC_NEGV", ")", ")", "return", "CCVmode", ";", "if", "(", "op1", "!=", "const0_rtx", ")", "return", "CCmode", ";", "switch", "(", "GET_CODE", "(", "op0", ")", ")", "{", "case", "PLUS", ":", "case", "MINUS", ":", "case", "NEG", ":", "case", "ASHIFT", ":", "case", "LTU", ":", "case", "LT", ":", "return", "CCNZmode", ";", "case", "ZERO_EXTRACT", ":", "return", "CCCmode", ";", "case", "CONST_INT", ":", "gcc_assert", "(", "op0", "==", "constm1_rtx", ")", ";", "case", "REG", ":", "case", "AND", ":", "case", "IOR", ":", "case", "XOR", ":", "case", "NOT", ":", "case", "ASHIFTRT", ":", "case", "LSHIFTRT", ":", "case", "TRUNCATE", ":", "case", "SIGN_EXTEND", ":", "return", "CCmode", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Given", "a", "comparison", "code", "(", "EQ", ",", "NE", ",", "etc", ".", ")", "and", "the", "operands", "of", "a", "COMPARE", ",", "return", "the", "mode", "to", "be", "used", "for", "the", "comparison", "." ]

[ "visium", "0", "1", "1", "1" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "ARM", "::", "GPRRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "return", ";", "}", "if", "(", "ARM", "::", "GPRPairRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "DestReg", ")", ")", "{", "MachineRegisterInfo", "*", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "MRI", "->", "constrainRegClass", "(", "DestReg", ",", "&", "ARM", "::", "GPRPair_with_gsub_1_in_GPRwithAPSRnospRegClass", ")", ";", "}", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRDi8", ")", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_0", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "AddDReg", "(", "MIB", ",", "DestReg", ",", "ARM", "::", "gsub_1", ",", "RegState", "::", "DefineNoRead", ",", "TRI", ")", ";", "MIB", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ".", "add", "(", "predOps", "(", "ARMCC", "::", "AL", ")", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isPhysicalRegister", "(", "DestReg", ")", ")", "MIB", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "ImplicitDefine", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegClass", "ARM::t2LDRi12", "0", "ARMCC::AL", "ARM::GPRPairRegClass", "ARM::GPRPair_with_gsub_1_in_GPRwithAPSRnospRegClass", "ARM::t2LDRDi8", "ARM::gsub_0", "ARM::gsub_1", "0", "ARMCC::AL", "ARM" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getArithmeticInstrCost", "(", "unsigned", "Opcode", ",", "Type", "*", "Ty", ",", "TTI", "::", "OperandValueKind", "Op1Info", ",", "TTI", "::", "OperandValueKind", "Op2Info", ",", "TTI", "::", "OperandValueProperties", "Opd1PropInfo", ",", "TTI", "::", "OperandValueProperties", "Opd2PropInfo", ",", "ArrayRef", "<", "const", "Value", "*", ">", "Args", ")", "{", "assert", "(", "TLI", "->", "InstructionOpcodeToISD", "(", "Opcode", ")", "&&", "\"Invalid opcode\"", ")", ";", "return", "BaseT", "::", "getArithmeticInstrCost", "(", "Opcode", ",", "Ty", ",", "Op1Info", ",", "Op2Info", ",", "Opd1PropInfo", ",", "Opd2PropInfo", ")", ";", "}", "</s>" ]

[ "This", "is", "an", "approximation", "of", "reciprocal", "throughput", "of", "a", "math/logic", "op", "." ]

[ "PowerPC", "PPC", "\"Invalid opcode\"" ]

[]

[ "<s>", "bool", "ix86_expand_fp_vcond", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "3", "]", ")", ";", "rtx", "cmp", ";", "code", "=", "ix86_prepare_sse_fp_compare_args", "(", "operands", "[", "0", "]", ",", "code", ",", "&", "operands", "[", "4", "]", ",", "&", "operands", "[", "5", "]", ")", ";", "if", "(", "code", "==", "UNKNOWN", ")", "return", "false", ";", "if", "(", "ix86_expand_sse_fp_minmax", "(", "operands", "[", "0", "]", ",", "code", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", "return", "true", ";", "cmp", "=", "ix86_expand_sse_cmp", "(", "operands", "[", "0", "]", ",", "code", ",", "operands", "[", "4", "]", ",", "operands", "[", "5", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "ix86_expand_sse_movcc", "(", "operands", "[", "0", "]", ",", "cmp", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "floating-point", "vector", "conditional", "move", ";", "a", "vcond", "operation", "rather", "than", "a", "movcc", "operation", "." ]

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

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "const", "DebugLoc", "&", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ",", "unsigned", "MIFlags", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MF", ".", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "LDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "0", ")", ".", "add", "(", "predOps", "(", "Pred", ",", "PredReg", ")", ")", ".", "setMIFlags", "(", "MIFlags", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARM", "ARMCC::CondCodes", "4", "ARM::LDRcp", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"SI Optimize VGPR LiveRange\"", ";", "}", "</s>" ]

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

[ "AMDGPU", "\"SI Optimize VGPR LiveRange\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "auto", "Attr", "=", "CI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getFnAttribute", "(", "\"disable-tail-calls\"", ")", ";", "if", "(", "!", "CI", "->", "isTailCall", "(", ")", "||", "Attr", ".", "getValueAsString", "(", ")", "==", "\"true\"", ")", "return", "false", ";", "ImmutableCallSite", "CS", "(", "CI", ")", ";", "CallingConv", "::", "ID", "CalleeCC", "=", "CS", ".", "getCallingConv", "(", ")", ";", "if", "(", "!", "mayTailCallThisCC", "(", "CalleeCC", ",", "Subtarget", ".", "isTargetWin64", "(", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "X86", "X86", "\"disable-tail-calls\"", "\"true\"" ]

[]

[ "<s>", "BitVector", "LoongArchRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "LoongArchFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "LoongArch", "::", "R0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "LoongArch", "::", "R2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "LoongArch", "::", "R3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "LoongArch", "::", "R21", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "LoongArch", "::", "R22", ")", ";", "if", "(", "TFI", "->", "hasBP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "LoongArchABI", "::", "getBPReg", "(", ")", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "LoongArch", "LoongArch", "LoongArch", "LoongArch::R0", "LoongArch::R2", "LoongArch::R3", "LoongArch::R21", "LoongArch::R22", "LoongArchABI::getBPReg" ]

[]

[ "<s>", "rtx", "mips_strip_unspec_address", "(", "rtx", "op", ")", "{", "rtx", "base", ",", "offset", ";", "split_const", "(", "op", ",", "&", "base", ",", "&", "offset", ")", ";", "if", "(", "UNSPEC_ADDRESS_P", "(", "base", ")", ")", "op", "=", "plus_constant", "(", "Pmode", ",", "UNSPEC_ADDRESS", "(", "base", ")", ",", "INTVAL", "(", "offset", ")", ")", ";", "return", "op", ";", "}", "</s>" ]

[ "If", "OP", "is", "an", "UNSPEC", "address", ",", "return", "the", "address", "to", "which", "it", "refers", ",", "otherwise", "return", "OP", "itself", "." ]

[ "mips" ]

[]

[ "<s>", "void", "SSEDomainFixPass", "::", "enterBasicBlock", "(", ")", "{", "for", "(", "MachineBasicBlock", "::", "livein_iterator", "i", "=", "MBB", "->", "livein_begin", "(", ")", ",", "e", "=", "MBB", "->", "livein_end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "int", "rx", "=", "RegIndex", "(", "*", "i", ")", ";", "if", "(", "rx", "<", "0", ")", "continue", ";", "for", "(", "MachineBasicBlock", "::", "const_pred_iterator", "pi", "=", "MBB", "->", "pred_begin", "(", ")", ",", "pe", "=", "MBB", "->", "pred_end", "(", ")", ";", "pi", "!=", "pe", ";", "++", "pi", ")", "{", "LiveOutMap", "::", "const_iterator", "fi", "=", "LiveOuts", ".", "find", "(", "*", "pi", ")", ";", "if", "(", "fi", "==", "LiveOuts", ".", "end", "(", ")", ")", "continue", ";", "DomainValue", "*", "pdv", "=", "fi", "->", "second", "[", "rx", "]", ";", "if", "(", "!", "pdv", ")", "continue", ";", "if", "(", "!", "LiveRegs", "||", "!", "LiveRegs", "[", "rx", "]", ")", "{", "SetLiveReg", "(", "rx", ",", "pdv", ")", ";", "continue", ";", "}", "if", "(", "LiveRegs", "[", "rx", "]", "->", "isCollapsed", "(", ")", ")", "{", "unsigned", "domain", "=", "LiveRegs", "[", "rx", "]", "->", "getFirstDomain", "(", ")", ";", "if", "(", "!", "pdv", "->", "isCollapsed", "(", ")", "&&", "pdv", "->", "hasDomain", "(", "domain", ")", ")", "Collapse", "(", "pdv", ",", "domain", ")", ";", "continue", ";", "}", "if", "(", "!", "pdv", "->", "isCollapsed", "(", ")", ")", "Merge", "(", "LiveRegs", "[", "rx", "]", ",", "pdv", ")", ";", "else", "Force", "(", "rx", ",", "pdv", "->", "getFirstDomain", "(", ")", ")", ";", "}", "}", "}", "</s>" ]

[ "Start", "tracking", "liveness", "from", "the", "begin", "of", "basic", "block", "MBB", "." ]

[ "X86", "0" ]

[]

[ "<s>", "bool", "Emitter", "<", "CodeEmitter", ">", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "assert", "(", "(", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Default", "||", "MF", ".", "getTarget", "(", ")", ".", "getRelocationModel", "(", ")", "!=", "Reloc", "::", "Static", ")", "&&", "\"JIT relocation model must be set to static or default!\"", ")", ";", "MCE", ".", "setModuleInfo", "(", "&", "getAnalysis", "<", "MachineModuleInfo", ">", "(", ")", ")", ";", "do", "{", "MovePCtoLROffset", "=", "0", ";", "MCE", ".", "startFunction", "(", "MF", ")", ";", "for", "(", "MachineFunction", "::", "iterator", "BB", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "BB", "!=", "E", ";", "++", "BB", ")", "emitBasicBlock", "(", "*", "BB", ")", ";", "}", "while", "(", "MCE", ".", "finishFunction", "(", "MF", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "PowerPC", "\"JIT relocation model must be set to static or default!\"", "0" ]

[]

[ "<s>", "rtx", "ix86_zero_extend_to_Pmode", "(", "rtx", "exp", ")", "{", "return", "force_reg", "(", "Pmode", ",", "convert_to_mode", "(", "Pmode", ",", "exp", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Zero", "extend", "possibly", "SImode", "EXP", "to", "Pmode", "register", "." ]

[ "i386", "1" ]

[]

[ "<s>", "int", "first_reg_to_save", "(", "void", ")", "{", "int", "first_reg", ";", "for", "(", "first_reg", "=", "13", ";", "first_reg", "<=", "31", ";", "first_reg", "++", ")", "if", "(", "save_reg_p", "(", "first_reg", ")", ")", "break", ";", "return", "first_reg", ";", "}", "</s>" ]

[ "Return", "the", "first", "register", "that", "is", "required", "to", "be", "saved", ".", "16", "if", "none", "." ]

[ "rs6000", "13", "31" ]

[]

[ "<s>", "virtual", "BitVector", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "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", "." ]

[ "PTX" ]

[]

[ "<s>", "virtual", "const", "SparcRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc" ]

[]

[ "<s>", "static", "void", "rs6000_set_current_function", "(", "tree", "fndecl", ")", "{", "tree", "old_tree", "=", "(", "rs6000_previous_fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "rs6000_previous_fndecl", ")", ":", "NULL_TREE", ")", ";", "tree", "new_tree", "=", "(", "fndecl", "?", "DECL_FUNCTION_SPECIFIC_TARGET", "(", "fndecl", ")", ":", "NULL_TREE", ")", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "{", "bool", "print_final", "=", "false", ";", "fprintf", "(", "stderr", ",", "\"\\n==================== rs6000_set_current_function\"", ")", ";", "if", "(", "fndecl", ")", "fprintf", "(", "stderr", ",", "\", fndecl %s (%p)\"", ",", "(", "DECL_NAME", "(", "fndecl", ")", "?", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ":", "\"<unknown>\"", ")", ",", "(", "void", "*", ")", "fndecl", ")", ";", "if", "(", "rs6000_previous_fndecl", ")", "fprintf", "(", "stderr", ",", "\", prev_fndecl (%p)\"", ",", "(", "void", "*", ")", "rs6000_previous_fndecl", ")", ";", "fprintf", "(", "stderr", ",", "\"\\n\"", ")", ";", "if", "(", "new_tree", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nnew fndecl target specific options:\\n\"", ")", ";", "debug_tree", "(", "new_tree", ")", ";", "print_final", "=", "true", ";", "}", "if", "(", "old_tree", ")", "{", "fprintf", "(", "stderr", ",", "\"\\nold fndecl target specific options:\\n\"", ")", ";", "debug_tree", "(", "old_tree", ")", ";", "print_final", "=", "true", ";", "}", "if", "(", "print_final", ")", "fprintf", "(", "stderr", ",", "\"--------------------\\n\"", ")", ";", "}", "if", "(", "fndecl", "&&", "fndecl", "!=", "rs6000_previous_fndecl", ")", "{", "rs6000_previous_fndecl", "=", "fndecl", ";", "if", "(", "old_tree", "==", "new_tree", ")", ";", "else", "if", "(", "new_tree", "&&", "new_tree", "!=", "target_option_default_node", ")", "{", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "else", "if", "(", "old_tree", "&&", "old_tree", "!=", "target_option_default_node", ")", "{", "new_tree", "=", "target_option_current_node", ";", "cl_target_option_restore", "(", "&", "global_options", ",", "TREE_TARGET_OPTION", "(", "new_tree", ")", ")", ";", "if", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", "restore_target_globals", "(", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", ")", ";", "else", "if", "(", "new_tree", "==", "target_option_default_node", ")", "restore_target_globals", "(", "&", "default_target_globals", ")", ";", "else", "TREE_TARGET_GLOBALS", "(", "new_tree", ")", "=", "save_target_globals_default_opts", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Establish", "appropriate", "back-end", "context", "for", "processing", "the", "function", "FNDECL", ".", "The", "argument", "might", "be", "NULL", "to", "indicate", "processing", "at", "top", "level", ",", "outside", "of", "any", "function", "scope", "." ]

[ "rs6000", "\"\\n==================== rs6000_set_current_function\"", "\", fndecl %s (%p)\"", "\"<unknown>\"", "\", prev_fndecl (%p)\"", "\"\\n\"", "\"\\nnew fndecl target specific options:\\n\"", "\"\\nold fndecl target specific options:\\n\"", "\"--------------------\\n\"" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isStoreToStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "unsigned", "Dummy", ";", "if", "(", "isFrameStoreOpcode", "(", "MI", ".", "getOpcode", "(", ")", ",", "Dummy", ")", ")", "{", "unsigned", "Reg", ";", "if", "(", "(", "Reg", "=", "isStoreToStackSlot", "(", "MI", ",", "FrameIndex", ")", ")", ")", "return", "Reg", ";", "SmallVector", "<", "const", "MachineMemOperand", "*", ",", "1", ">", "Accesses", ";", "if", "(", "hasStoreToStackSlot", "(", "MI", ",", "Accesses", ")", ")", "{", "FrameIndex", "=", "cast", "<", "FixedStackPseudoSourceValue", ">", "(", "Accesses", ".", "front", "(", ")", "->", "getPseudoValue", "(", ")", ")", "->", "getFrameIndex", "(", ")", ";", "return", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "isStoreToStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

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

[]

[ "<s>", "bool", "HexagonCopyToCombine", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "IsCombinesDisabled", ")", "return", "false", ";", "bool", "HasChanged", "=", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ShouldCombineAggressively", "=", "MF", ".", "getTarget", "(", ")", ".", "getOptLevel", "(", ")", "<=", "CodeGenOpt", "::", "Default", ";", "for", "(", "MachineFunction", "::", "iterator", "BI", "=", "MF", ".", "begin", "(", ")", ",", "BE", "=", "MF", ".", "end", "(", ")", ";", "BI", "!=", "BE", ";", "++", "BI", ")", "{", "PotentiallyNewifiableTFR", ".", "clear", "(", ")", ";", "findPotentialNewifiableTFRs", "(", "*", "BI", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "MI", "=", "BI", "->", "begin", "(", ")", ",", "End", "=", "BI", "->", "end", "(", ")", ";", "MI", "!=", "End", ";", ")", "{", "MachineInstr", "*", "I1", "=", "MI", "++", ";", "if", "(", "ShouldCombineAggressively", "&&", "PotentiallyNewifiableTFR", ".", "count", "(", "I1", ")", ")", "continue", ";", "if", "(", "!", "isCombinableInstType", "(", "I1", ",", "TII", ",", "ShouldCombineAggressively", ")", ")", "continue", ";", "bool", "DoInsertAtI1", "=", "false", ";", "MachineInstr", "*", "I2", "=", "findPairable", "(", "I1", ",", "DoInsertAtI1", ")", ";", "if", "(", "I2", ")", "{", "HasChanged", "=", "true", ";", "combine", "(", "I1", ",", "I2", ",", "MI", ",", "DoInsertAtI1", ")", ";", "}", "}", "}", "return", "HasChanged", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "aarch64_vector_mode_supported_p", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "vec_flags", "=", "aarch64_classify_vector_mode", "(", "mode", ")", ";", "return", "vec_flags", "!=", "0", "&&", "(", "vec_flags", "&", "VEC_STRUCT", ")", "==", "0", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "tree", "msp430_attr", "(", "tree", "*", "node", ",", "tree", "name", ",", "tree", "args", ",", "int", "flags", "ATTRIBUTE_UNUSED", ",", "bool", "*", "no_add_attrs", ")", "{", "gcc_assert", "(", "DECL_P", "(", "*", "node", ")", ")", ";", "if", "(", "args", "!=", "NULL", ")", "{", "tree", "value", "=", "TREE_VALUE", "(", "args", ")", ";", "switch", "(", "TREE_CODE", "(", "value", ")", ")", "{", "case", "STRING_CST", ":", "if", "(", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"reset\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"nmi\"", ")", "&&", "strcmp", "(", "TREE_STRING_POINTER", "(", "value", ")", ",", "\"watchdog\"", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"unrecognized interrupt vector argument of %qE attribute\"", ",", "name", ")", ";", "break", ";", "case", "INTEGER_CST", ":", "if", "(", "wi", "::", "gtu_p", "(", "wi", "::", "to_wide", "(", "value", ")", ",", "63", ")", ")", "warning", "(", "OPT_Wattributes", ",", "\"numeric argument of %qE attribute must be in range 0..63\"", ",", "name", ")", ";", "break", ";", "default", ":", "warning", "(", "OPT_Wattributes", ",", "\"argument of %qE attribute is not a string constant or number\"", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "break", ";", "}", "}", "const", "char", "*", "message", "=", "NULL", ";", "if", "(", "TREE_CODE", "(", "*", "node", ")", "!=", "FUNCTION_DECL", ")", "{", "message", "=", "\"%qE attribute only applies to functions\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_INTR", ")", ")", "{", "if", "(", "TREE_CODE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", "==", "FUNCTION_TYPE", "&&", "!", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "TREE_TYPE", "(", "*", "node", ")", ")", ")", ")", "message", "=", "\"interrupt handlers must be void\"", ";", "else", "{", "TREE_USED", "(", "*", "node", ")", "=", "1", ";", "DECL_PRESERVE_P", "(", "*", "node", ")", "=", "1", ";", "}", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "{", "warning", "(", "OPT_Wattributes", ",", "\"critical attribute has no effect on interrupt functions\"", ")", ";", "DECL_ATTRIBUTES", "(", "*", "node", ")", "=", "remove_attribute", "(", "ATTR_CRIT", ",", "DECL_ATTRIBUTES", "(", "*", "node", ")", ")", ";", "}", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_REENT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be reentrant\"", ";", "else", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be reentrant\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_CRIT", ")", ")", "{", "if", "(", "is_naked_func", "(", "*", "node", ")", ")", "message", "=", "\"naked functions cannot be critical\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be critical\"", ";", "else", "if", "(", "is_interrupt_func", "(", "*", "node", ")", ")", "message", "=", "\"critical attribute has no effect on interrupt functions\"", ";", "}", "else", "if", "(", "TREE_NAME_EQ", "(", "name", ",", "ATTR_NAKED", ")", ")", "{", "if", "(", "is_critical_func", "(", "*", "node", ")", ")", "message", "=", "\"critical functions cannot be naked\"", ";", "else", "if", "(", "is_reentrant_func", "(", "*", "node", ")", ")", "message", "=", "\"reentrant functions cannot be naked\"", ";", "}", "if", "(", "message", ")", "{", "warning", "(", "OPT_Wattributes", ",", "message", ",", "name", ")", ";", "*", "no_add_attrs", "=", "true", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Verify", "MSP430", "specific", "attributes", "." ]

[ "msp430", "\"reset\"", "\"nmi\"", "\"watchdog\"", "\"unrecognized interrupt vector argument of %qE attribute\"", "63", "\"numeric argument of %qE attribute must be in range 0..63\"", "\"argument of %qE attribute is not a string constant or number\"", "\"%qE attribute only applies to functions\"", "\"interrupt handlers must be void\"", "1", "1", "\"critical attribute has no effect on interrupt functions\"", "\"naked functions cannot be reentrant\"", "\"critical functions cannot be reentrant\"", "\"naked functions cannot be critical\"", "\"reentrant functions cannot be critical\"", "\"critical attribute has no effect on interrupt functions\"", "\"critical functions cannot be naked\"", "\"reentrant functions cannot be naked\"" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget21OpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTarget21OpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MIPS_PC21_S2", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTarget21OpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getBranchTarget21OpValue expects only expressions or immediates\"", "0", "Mips::fixup_MIPS_PC21_S2", "0" ]

[]

[ "<s>", "virtual", "bool", "addInstSelector", "(", ")", "{", "addPass", "(", "createTGSIISelDag", "(", "getTGSITargetMachine", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "TGSI", "TGSI", "TGSI" ]

[]

[ "<s>", "bool", "XCoreAsmPrinter", "::", "PrintAsmOperand", "(", "const", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "unsigned", "AsmVariant", ",", "const", "char", "*", "ExtraCode", ",", "raw_ostream", "&", "O", ")", "{", "printOperand", "(", "MI", ",", "OpNo", ",", "O", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "XCore", "XCore" ]

[]

[ "<s>", "const", "char", "*", "pa_output_lbranch", "(", "rtx", "dest", ",", "rtx_insn", "*", "insn", ",", "int", "xdelay", ")", "{", "rtx", "xoperands", "[", "2", "]", ";", "xoperands", "[", "0", "]", "=", "dest", ";", "if", "(", "xdelay", "&&", "dbr_sequence_length", "(", ")", "!=", "0", ")", "{", "gcc_assert", "(", "!", "JUMP_P", "(", "NEXT_INSN", "(", "insn", ")", ")", ")", ";", "final_scan_insn", "(", "NEXT_INSN", "(", "insn", ")", ",", "asm_out_file", ",", "optimize", ",", "0", ",", "NULL", ")", ";", "SET_INSN_DELETED", "(", "NEXT_INSN", "(", "insn", ")", ")", ";", "}", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "output_asm_insn", "(", "\"std %%r1,-16(%%r30)\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"std %%r1,-40(%%r30)\"", ",", "xoperands", ")", ";", "}", "else", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "output_asm_insn", "(", "\"stw %%r1,-20(%%r30)\"", ",", "xoperands", ")", ";", "else", "output_asm_insn", "(", "\"stw %%r1,-12(%%r30)\"", ",", "xoperands", ")", ";", "}", "if", "(", "TARGET_PORTABLE_RUNTIME", ")", "{", "output_asm_insn", "(", "\"ldil L'%0,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%0(%%r1),%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "if", "(", "flag_pic", ")", "{", "output_asm_insn", "(", "\"{bl|b,l} .+8,%%r1\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_SOM", "||", "!", "TARGET_GAS", ")", "{", "xoperands", "[", "1", "]", "=", "gen_label_rtx", "(", ")", ";", "output_asm_insn", "(", "\"addil L'%l0-%l1,%%r1\"", ",", "xoperands", ")", ";", "targetm", ".", "asm_out", ".", "internal_label", "(", "asm_out_file", ",", "\"L\"", ",", "CODE_LABEL_NUMBER", "(", "xoperands", "[", "1", "]", ")", ")", ";", "output_asm_insn", "(", "\"ldo R'%l0-%l1(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "else", "{", "output_asm_insn", "(", "\"addil L'%l0-$PIC_pcrel$0+4,%%r1\"", ",", "xoperands", ")", ";", "output_asm_insn", "(", "\"ldo R'%l0-$PIC_pcrel$0+8(%%r1),%%r1\"", ",", "xoperands", ")", ";", "}", "output_asm_insn", "(", "\"bv %%r0(%%r1)\"", ",", "xoperands", ")", ";", "}", "else", "output_asm_insn", "(", "\"ldil L'%l0,%%r1\\n\\tbe R'%l0(%%sr4,%%r1)\"", ",", "xoperands", ")", ";", "if", "(", "TARGET_64BIT", ")", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "return", "\"ldd -16(%%r30),%%r1\"", ";", "else", "return", "\"ldd -40(%%r30),%%r1\"", ";", "}", "else", "{", "if", "(", "actual_fsize", "==", "0", "&&", "!", "df_regs_ever_live_p", "(", "2", ")", ")", "return", "\"ldw -20(%%r30),%%r1\"", ";", "else", "return", "\"ldw -12(%%r30),%%r1\"", ";", "}", "}", "</s>" ]

[ "This", "routine", "handles", "output", "of", "long", "unconditional", "branches", "that", "exceed", "the", "maximum", "range", "of", "a", "simple", "branch", "instruction", ".", "Since", "we", "do", "n't", "have", "a", "register", "available", "for", "the", "branch", ",", "we", "save", "register", "%", "r1", "in", "the", "frame", "marker", ",", "load", "the", "branch", "destination", "DEST", "into", "%", "r1", ",", "execute", "the", "branch", ",", "and", "restore", "%", "r1", "in", "the", "delay", "slot", "of", "the", "branch", ".", "Since", "long", "branches", "may", "have", "an", "insn", "in", "the", "delay", "slot", "and", "the", "delay", "slot", "is", "used", "to", "restore", "%", "r1", ",", "we", "in", "general", "need", "to", "extract", "this", "insn", "and", "execute", "it", "before", "the", "branch", ".", "However", ",", "to", "facilitate", "use", "of", "this", "function", "by", "conditional", "branches", ",", "we", "also", "provide", "an", "option", "to", "not", "extract", "the", "delay", "insn", "so", "that", "it", "will", "be", "emitted", "after", "the", "long", "branch", ".", "So", ",", "if", "there", "is", "an", "insn", "in", "the", "delay", "slot", ",", "it", "is", "extracted", "if", "XDELAY", "is", "nonzero", ".", "The", "lengths", "of", "the", "various", "long-branch", "sequences", "are", "20", ",", "16", "and", "24", "bytes", "for", "the", "portable", "runtime", ",", "non-PIC", "and", "PIC", "cases", ",", "respectively", "." ]

[ "pa", "2", "0", "0", "0", "0", "2", "\"std %%r1,-16(%%r30)\"", "\"std %%r1,-40(%%r30)\"", "0", "2", "\"stw %%r1,-20(%%r30)\"", "\"stw %%r1,-12(%%r30)\"", "\"ldil L'%0,%%r1\"", "\"ldo R'%0(%%r1),%%r1\"", "\"bv %%r0(%%r1)\"", "\"{bl|b,l} .+8,%%r1\"", "1", "\"addil L'%l0-%l1,%%r1\"", "\"L\"", "1", "\"ldo R'%l0-%l1(%%r1),%%r1\"", "\"addil L'%l0-$PIC_pcrel$0+4,%%r1\"", "\"ldo R'%l0-$PIC_pcrel$0+8(%%r1),%%r1\"", "\"bv %%r0(%%r1)\"", "\"ldil L'%l0,%%r1\\n\\tbe R'%l0(%%sr4,%%r1)\"", "0", "2", "\"ldd -16(%%r30),%%r1\"", "\"ldd -40(%%r30),%%r1\"", "0", "2", "\"ldw -20(%%r30),%%r1\"", "\"ldw -12(%%r30),%%r1\"" ]

[]

[ "<s>", "bool", "ARMExpandPseudo", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "TargetMachine", "&", "TM", "=", "MF", ".", "getTarget", "(", ")", ";", "TII", "=", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "TM", ".", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "STI", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineFunction", "::", "iterator", "MFI", "=", "MF", ".", "begin", "(", ")", ",", "E", "=", "MF", ".", "end", "(", ")", ";", "MFI", "!=", "E", ";", "++", "MFI", ")", "Modified", "|=", "ExpandMBB", "(", "*", "MFI", ")", ";", "if", "(", "VerifyARMPseudo", ")", "MF", ".", "verify", "(", "this", ",", "\"After expanding ARM pseudo instructions.\"", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "\"After expanding ARM pseudo instructions.\"" ]

[]

[ "<s>", "const", "DataLayout", "*", "getDataLayout", "(", ")", "const", "override", "{", "return", "&", "DL", ";", "}", "</s>" ]

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "BPF" ]

[]

[ "<s>", "static", "bool", "arm_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "int", "call_type", "=", "TARGET_LONG_CALLS", "?", "CALL_LONG", ":", "CALL_NORMAL", ";", "if", "(", "cfun", "->", "machine", "->", "sibcall_blocked", ")", "return", "false", ";", "if", "(", "decl", "==", "NULL", "||", "TARGET_THUMB", ")", "return", "false", ";", "if", "(", "lookup_attribute", "(", "\"short_call\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ")", "call_type", "=", "CALL_SHORT", ";", "else", "if", "(", "lookup_attribute", "(", "\"long_call\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ")", ")", "call_type", "=", "CALL_LONG", ";", "if", "(", "call_type", "==", "CALL_LONG", "&&", "(", "flag_pic", "||", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", ")", ")", "return", "false", ";", "if", "(", "TARGET_INTERWORK", "&&", "TREE_PUBLIC", "(", "decl", ")", "&&", "!", "TREE_ASM_WRITTEN", "(", "decl", ")", ")", "return", "false", ";", "if", "(", "IS_INTERRUPT", "(", "arm_current_func_type", "(", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "." ]

[ "arm", "\"short_call\"", "\"long_call\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "*", "PPCInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "const", "TargetSubtargetInfo", "*", "STI", ",", "const", "ScheduleDAG", "*", "DAG", ")", "const", "{", "unsigned", "Directive", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getCPUDirective", "(", ")", ";", "if", "(", "Directive", "==", "PPC", "::", "DIR_440", "||", "Directive", "==", "PPC", "::", "DIR_A2", "||", "Directive", "==", "PPC", "::", "DIR_E500mc", "||", "Directive", "==", "PPC", "::", "DIR_E5500", ")", "{", "const", "InstrItineraryData", "*", "II", "=", "static_cast", "<", "const", "PPCSubtarget", "*", ">", "(", "STI", ")", "->", "getInstrItineraryData", "(", ")", ";", "return", "new", "ScoreboardHazardRecognizer", "(", "II", ",", "DAG", ")", ";", "}", "return", "TargetInstrInfo", "::", "CreateTargetHazardRecognizer", "(", "STI", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Allocate", "and", "return", "a", "hazard", "recognizer", "to", "use", "for", "this", "target", "when", "scheduling", "the", "machine", "instructions", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC::DIR_440", "PPC::DIR_A2", "PPC::DIR_E500mc", "PPC::DIR_E5500", "PPC" ]

[]