Datasets:

---

docz1105

/

ComBack_Plus_Plus

like 0

[ "USR_OVF", "]", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "Defs", "=", "[" ]

[ "gcc_unreachable", "(", ")", ";" ]

[ "offset", "=", "(", "cfun", "->", "machine", "->", "local_size", "+", "cfun", "->", "machine", "->", "out_args_size", ")", ";", "}", "else", "if", "(", "from_reg", "==", "FRAME_POINTER_REGNUM", "&&", "to_reg", "==", "HARD_FRAME_POINTER_REGNUM", ")", "{", "offset", "=", "(", "-", "<NUM_LIT>", ")", "*", "(", "cfun", "->", "machine", "->", "fp_size", "+", "cfun", "->", "machine", "->", "gp_size", "+", "cfun", "->", "machine", "->", "lp_size", "+", "cfun", "->", "machine", "->", "callee_saved_gpr_regs_size", "+", "cfun", "->", "machine", "->", "callee_saved_area_gpr_padding_bytes", "+", "cfun", "->", "machine", "->", "callee_saved_fpr_regs_size", "+", "cfun", "->", "machine", "->", "eh_return_data_regs_size", ")", ";", "}", "else", "{" ]

[ "StateTransition", "[", "MI", "]", "=", "NonStrictState", ";" ]

[ "void", "SIWholeQuadMode", "::", "fromStrictMode", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Before", ",", "Register", "SavedOrig", ",", "char", "NonStrictState", ",", "char", "CurrentStrictState", ")", "{", "MachineInstr", "*", "MI", ";", "assert", "(", "SavedOrig", ")", ";", "assert", "(", "CurrentStrictState", "==", "StateStrictWWM", "||", "CurrentStrictState", "==", "StateStrictWQM", ")", ";", "if", "(", "CurrentStrictState", "==", "StateStrictWWM", ")", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "Before", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "EXIT_STRICT_WWM", ")", ",", "Exec", ")", ".", "addReg", "(", "SavedOrig", ")", ";", "}", "else", "{", "MI", "=", "BuildMI", "(", "MBB", ",", "Before", ",", "DebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "EXIT_STRICT_WQM", ")", ",", "Exec", ")", ".", "addReg", "(", "SavedOrig", ")", ";", "}", "LIS", "->", "InsertMachineInstrInMaps", "(", "*", "MI", ")", ";" ]

[ "<STR_LIT>", ")" ]

[ "(", "and", "(", "match_code" ]

[ "let", "opNewValue", "=", "<NUM_LIT>", ";" ]

[ "def", "A4_pzxtbtnew", ":", "HInst", "<", "(", "outs", "IntRegs", ":", "$", "Rd32", ")", ",", "(", "ins", "PredRegs", ":", "$", "Pu4", ",", "IntRegs", ":", "$", "Rs32", ")", ",", "<STR_LIT>", ",", "tc_1ae57e39", ",", "TypeALU32_2op", ">", ",", "Enc_fb6577", ",", "PredNewRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";" ]

[ "<FIXS>", "(", "define_insn", "<STR_LIT>", "<FIXE>" ]

[ "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")", "<BUGS>", "(", "define_insn", "<STR_LIT>", "<BUGE>", "[", "(", "set", "(", "match_operand", ":", "VHSDF_HSDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec", ":", "VHSDF_HSDF", "[", "(", "match_operand", ":", "VHSDF_HSDF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "if", "(", "!", "LI", ".", "hasSubRanges", "(", ")", ")", "{" ]

[ "}", "std", "::", "sort", "(", "Indexes", ".", "begin", "(", ")", ",", "Indexes", ".", "end", "(", ")", ")", ";", "auto", "&", "MRI", "=", "(", "*", "R", ".", "begin", "(", ")", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "DenseMap", "<", "MachineInstr", "*", ",", "GCNRPTracker", "::", "LiveRegSet", ">", "LiveRegMap", ";", "SmallVector", "<", "SlotIndex", ",", "<NUM_LIT>", ">", "LiveIdxs", ",", "SRLiveIdxs", ";", "for", "(", "unsigned", "I", "=", "<NUM_LIT>", ",", "E", "=", "MRI", ".", "getNumVirtRegs", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "auto", "Reg", "=", "Register", "::", "index2VirtReg", "(", "I", ")", ";", "if", "(", "!", "LIS", ".", "hasInterval", "(", "Reg", ")", ")", "continue", ";", "auto", "&", "LI", "=", "LIS", ".", "getInterval", "(", "Reg", ")", ";", "LiveIdxs", ".", "clear", "(", ")", ";", "if", "(", "!", "LI", ".", "findIndexesLiveAt", "(", "Indexes", ",", "std", "::", "back_inserter", "(", "LiveIdxs", ")", ")", ")", "continue", ";" ]

[ "const", "BitTracker", "::", "RegisterCell", "&", "lookup", "(", "unsigned", "VR", ")", "{", "unsigned", "RInd", "=", "TargetRegisterInfo", "::", "virtReg2Index", "(", "VR", ")", ";", "if", "(", "RInd", ">=", "CVect", ".", "size", "(", ")", ")", "CVect", ".", "resize", "(", "std", "::", "max", "(", "RInd", "+", "<NUM_LIT>", ",", "<NUM_LIT>", "U", ")", ",", "<NUM_LIT>", ")", ";", "const", "BitTracker", "::", "RegisterCell", "*", "CP", "=", "CVect", "[", "RInd", "]", ";", "if", "(", "CP", "==", "<NUM_LIT>", ")", "CP", "=", "CVect", "[", "RInd", "]", "=", "&", "BT", ".", "lookup", "(", "VR", ")", ";", "return", "*", "CP", ";", "}" ]

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

[ ")", ")", ")", "]" ]

[ "(", "define_expand", "<STR_LIT>", "[", "(", "set", "(", "cc0", ")", "(", "compare", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>" ]

[ "<NUM_LIT>", "}", "=", "size", ";" ]

[ "class", "BaseSIMDVectorLShiftLongBySize", "<", "bit", "Q", ",", "bits", "<", "<NUM_LIT>", ">", "size", ",", "RegisterOperand", "regtype", ",", "string", "asm", ",", "string", "dstkind", ",", "string", "srckind", ",", "string", "amount", ">", ":", "I", "<", "(", "outs", "V128", ":", "$", "Rd", ")", ",", "(", "ins", "regtype", ":", "$", "Rn", ")", ",", "asm", ",", "<STR_LIT>", "#", "dstkind", "#", "<STR_LIT>", "#", "srckind", "#", "<STR_LIT>", "#", "amount", "#", "<STR_LIT>", "#", "dstkind", "#", "<STR_LIT>", "#", "amount", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", ",", "Sched", "<", "[", "WriteVq", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Q", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-" ]

[ "-", "Start", ".", "getPointer", "(", ")", ")", ";" ]

[ "return", "StringRef", "(", "Start", ".", "getPointer", "(", ")", ",", "End", ".", "getPointer", "(", ")" ]

[ "(", "vec_select", ":", "<", "V_HALF", ">" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "<", "V_double_width", ">", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "plus", ":", "<", "V_double_width", ">", "(", "sign_extend", ":", "<", "V_double_width", ">" ]

[ "void", "X86AsmPrinter", "::", "PrintSymbolOperand", "(", "const", "MachineOperand", "&", "MO", ",", "raw_ostream", "&", "O", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "unknown symbol type!", "<STR_LIT>", ")", ";", "case", "MachineOperand", "::", "MO_ConstantPoolIndex", ":", "GetCPISymbol", "(", "MO", ".", "getIndex", "(", ")", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "O", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "MCSymbol", "*", "GVSym", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "GVSym", "=", "getSymbolWithGlobalValueBase", "(", "GV", ",", "<STR_LIT>", "$non_lazy_ptr", "<STR_LIT>", ")", ";", "else", "GVSym", "=", "getSymbol", "(", "GV", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "GVSym", "=", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "<STR_LIT>", "__imp_", "<STR_LIT>", ")", "+", "GVSym", "->", "getName", "(", ")", ")", ";", "else", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "GVSym", "=", "OutContext", ".", "getOrCreateSymbol", "(", "Twine", "(", "<STR_LIT>", ".refptr.", "<STR_LIT>", ")", "+", "GVSym", "->", "getName", "(", ")", ")", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", "||", "MO", ".", "getTargetFlags", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "MCSymbol", "*", "Sym", "=", "getSymbolWithGlobalValueBase", "(", "GV", ",", "<STR_LIT>", "$non_lazy_ptr", "<STR_LIT>", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "MMI", "->", "getObjFileInfo", "<", "MachineModuleInfoMachO", ">", "(", ")", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "!", "StubSym", ".", "getPointer", "(", ")", ")", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "getSymbol", "(", "GV", ")", ",", "!", "GV", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "if", "(", "GVSym", "->", "getName", "(", ")", "[", "<NUM_LIT>", "]", "!=", "'", "$", "'", ")", "GVSym", "->", "print", "(", "O", ",", "MAI", ")", ";", "else", "{", "O", "<<", "'", "(", "'", ";", "GVSym", "->", "print", "(", "O", ",", "MAI", ")", ";", "O", "<<", "'", ")", "'", ";", "}", "printOffset", "(", "MO", ".", "getOffset", "(", ")", ",", "O", ")", ";", "break", ";", "}", "}", "switch", "(", "MO", ".", "getTargetFlags", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Unknown target flag on GV operand", "<STR_LIT>", ")", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", " + [.-", "<STR_LIT>", ";", "MF", "->", "getPICBaseSymbol", "(", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "O", "<<", "'", "]", "'", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "'", "-", "'", ";", "MF", "->", "getPICBaseSymbol", "(", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLSGD", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLSLD", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLSLDM", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@INDNTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@DTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@NTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTNTPOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTPCREL", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOT", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@GOTOFF", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@PLT", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLVP", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@TLVP", "<STR_LIT>", "<<", "'", "-", "'", ";", "MF", "->", "getPICBaseSymbol", "(", ")", "->", "print", "(", "O", ",", "MAI", ")", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", "@SECREL32", "<STR_LIT>", ";", "break", ";", "}", "}" ]

[ "Print", "the", "MachineOperand", "as", "a", "symbol", "." ]

[ "MFI", "->", "Mode", ".", "FP64FP16InputDenormals", "=", "YamlMFI", ".", "Mode", ".", "FP64FP16InputDenormals", ";" ]

[ "if", "(", "MFI", "->", "FrameOffsetReg", "!=", "AMDGPU", "::", "FP_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "FrameOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "FrameOffsetReg", ")", ";", "}", "if", "(", "MFI", "->", "StackPtrOffsetReg", "!=", "AMDGPU", "::", "SP_REG", "&&", "!", "AMDGPU", "::", "SGPR_32RegClass", ".", "contains", "(", "MFI", "->", "StackPtrOffsetReg", ")", ")", "{", "return", "diagnoseRegisterClass", "(", "YamlMFI", ".", "StackPtrOffsetReg", ")", ";", "}", "auto", "parseAndCheckArgument", "=", "[", "&", "]", "(", "const", "Optional", "<", "yaml", "::", "SIArgument", ">", "&", "A", ",", "const", "TargetRegisterClass", "&", "RC", ",", "ArgDescriptor", "&", "Arg", ",", "unsigned", "UserSGPRs", ",", "unsigned", "SystemSGPRs", ")", "{", "if", "(", "!", "A", ")", "return", "false", ";", "if", "(", "A", "->", "IsRegister", ")", "{", "Register", "Reg", ";", "if", "(", "parseNamedRegisterReference", "(", "PFS", ",", "Reg", ",", "A", "->", "RegisterName", ".", "Value", ",", "Error", ")", ")", "{", "SourceRange", "=", "A", "->", "RegisterName", ".", "SourceRange", ";", "return", "true", ";", "}", "if", "(", "!", "RC", ".", "contains", "(", "Reg", ")", ")", "return", "diagnoseRegisterClass", "(", "A", "->", "RegisterName", ")", ";", "Arg", "=", "ArgDescriptor", "::", "createRegister", "(", "Reg", ")", ";", "}", "else", "Arg", "=", "ArgDescriptor", "::", "createStack", "(", "A", "->", "StackOffset", ")", ";", "if", "(", "A", "->", "Mask", ")", "Arg", "=", "ArgDescriptor", "::", "createArg", "(", "Arg", ",", "A", "->", "Mask", ".", "getValue", "(", ")", ")", ";", "MFI", "->", "NumUserSGPRs", "+=", "UserSGPRs", ";", "MFI", "->", "NumSystemSGPRs", "+=", "SystemSGPRs", ";", "return", "false", ";", "}", ";", "if", "(", "YamlMFI", ".", "ArgInfo", "&&", "(", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "PrivateSegmentBuffer", ",", "AMDGPU", "::", "SGPR_128RegClass", ",", "MFI", "->", "ArgInfo", ".", "PrivateSegmentBuffer", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "DispatchPtr", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "DispatchPtr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "QueuePtr", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "QueuePtr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "KernargSegmentPtr", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "KernargSegmentPtr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "DispatchID", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "DispatchID", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "FlatScratchInit", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "FlatScratchInit", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "PrivateSegmentSize", ",", "AMDGPU", "::", "SGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "PrivateSegmentSize", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkGroupIDX", ",", "AMDGPU", "::", "SGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkGroupIDX", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkGroupIDY", ",", "AMDGPU", "::", "SGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkGroupIDY", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkGroupIDZ", ",", "AMDGPU", "::", "SGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkGroupIDZ", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkGroupInfo", ",", "AMDGPU", "::", "SGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkGroupInfo", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "PrivateSegmentWaveByteOffset", ",", "AMDGPU", "::", "SGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "PrivateSegmentWaveByteOffset", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "ImplicitArgPtr", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "ImplicitArgPtr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "ImplicitBufferPtr", ",", "AMDGPU", "::", "SReg_64RegClass", ",", "MFI", "->", "ArgInfo", ".", "ImplicitBufferPtr", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkItemIDX", ",", "AMDGPU", "::", "VGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkItemIDX", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkItemIDY", ",", "AMDGPU", "::", "VGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkItemIDY", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", "||", "parseAndCheckArgument", "(", "YamlMFI", ".", "ArgInfo", "->", "WorkItemIDZ", ",", "AMDGPU", "::", "VGPR_32RegClass", ",", "MFI", "->", "ArgInfo", ".", "WorkItemIDZ", ",", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ")", ")", "return", "true", ";", "MFI", "->", "Mode", ".", "IEEE", "=", "YamlMFI", ".", "Mode", ".", "IEEE", ";", "MFI", "->", "Mode", ".", "DX10Clamp", "=", "YamlMFI", ".", "Mode", ".", "DX10Clamp", ";", "MFI", "->", "Mode", ".", "FP32InputDenormals", "=", "YamlMFI", ".", "Mode", ".", "FP32InputDenormals", ";", "MFI", "->", "Mode", ".", "FP32OutputDenormals", "=", "YamlMFI", ".", "Mode", ".", "FP32OutputDenormals", ";" ]

[ ")", "+", "<NUM_LIT>", ")", ";" ]

[ "fu", "|=", "IS_BSIDE", "(", "flags", ")", "?", "<NUM_LIT>", ":", "<NUM_LIT>", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "*", "MI", "<<", "<STR_LIT>", " fixed to ", "<STR_LIT>", "<<", "TII", "->", "res2Str", "(", "fu", ")", "<<", "<STR_LIT>", "\\n\\n", "<STR_LIT>", ")", ";", "set", ".", "insert", "(", "fu", ")", ";", "return", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "*", "MI", "<<", "<STR_LIT>", " supported by: ", "<STR_LIT>", ")", ";", "for", "(", "int", "i", "=", "<NUM_LIT>", ";", "i", "<", "<STR_LIT>", "::", "<STR_LIT>", ";", "++", "i", ")", "{", "if", "(", "(", "us", ">>", "i", ")", "&", "<NUM_LIT>", ")", "{", "set", ".", "insert", "(", "i", "<<", "<NUM_LIT>", ")", ";", "set", ".", "insert", "(", "(", "i", "<<", "<NUM_LIT>" ]

[ "let", "InOperandList", "=", "(", "ins", ")", ";" ]

[ "class", "LoadInstReadSpec", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "RegisterClass", "Rdst", ",", "string", "asmstr", ",", "list", "<", "dag", ">", "pattern", ">", ":", "TPCInstLoad", "<", "opc", ",", "asmstr", ">", "{", "let", "OutOperandList", "=", "(", "outs", "Rdst", ":", "$", "dst", ")", ";" ]

[ "let", "Constraints", "=", "<STR_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=", "ByteAccess", ";", "let", "mayLoad", "=", "<NUM_LIT>", ";" ]

[ "ByteAccess", ",", "<NUM_LIT>", ">", ";" ]

[ "def", "L2_loadalignb_pbr", ":", "T_load_pbr", "<", "<STR_LIT>", ",", "DoubleRegs", "," ]

[ "<NUM_LIT>", "}", ";" ]

[ "bits", "<", "<NUM_LIT>", ">", "idx", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "idx", "{" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "L", ";" ]

[ "class", "BaseLoadStorePairPostIdx", "<", "bits", "<", "<NUM_LIT>", ">", "opc", ",", "bit", "V", ",", "bit", "L", ",", "dag", "oops", ",", "dag", "iops", ",", "string", "asm", ">", ":", "I", "<", "oops", ",", "iops", ",", "asm", ",", "<STR_LIT>", ",", "<STR_LIT>", ",", "[", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rt", ";", "bits", "<", "<NUM_LIT>", ">", "Rt2", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "offset", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "V", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "}" ]

[ "EVT", "Ty", "=", "Op", ".", "getValueType", "(", ")", ";", "GlobalAddressSDNode", "*", "N", "=", "cast", "<", "GlobalAddressSDNode", ">", "(", "Op", ")", ";", "const", "GlobalValue", "*", "GV", "=", "N", "->", "getGlobal", "(", ")", ";", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "{", "const", "MipsTargetObjectFile", "*", "TLOF", "=", "static_cast", "<", "const", "MipsTargetObjectFile", "*", ">", "(", "getTargetMachine", "(", ")", ".", "getObjFileLowering", "(", ")", ")", ";", "const", "GlobalObject", "*", "GO", "=", "GV", "->", "getBaseObject", "(", ")", ";", "if", "(", "GO", "&&", "TLOF", "->", "IsGlobalInSmallSection", "(", "GO", ",", "getTargetMachine", "(", ")", ")", ")", "return", "getAddrGPRel", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ")", ";", "return", "Subtarget", ".", "hasSym32", "(", ")", "?", "getAddrNonPIC", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ")", ":", "getAddrNonPICSym64", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ")", ";", "}", "if", "(", "GV", "->", "hasLocalLinkage", "(", ")", ")", "return", "getAddrLocal", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "ABI", ".", "IsN32", "(", ")", "||", "ABI", ".", "IsN64", "(", ")", ")", ";", "if", "(", "LargeGOT", ")", "return", "getAddrGlobalLargeGOT", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", ";", "return", "getAddrGlobal", "(", "N", ",", "SDLoc", "(", "N", ")", ",", "Ty", ",", "DAG", ",", "(", "ABI", ".", "IsN32", "(", ")", "||", "ABI", ".", "IsN64", "(", ")", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ",", "DAG", ".", "getEntryNode", "(", ")", ",", "MachinePointerInfo", "::", "getGOT", "(", "DAG", ".", "getMachineFunction", "(", ")", ")", ")", ";" ]

[ ")", ";" ]

[ "if", "(", "!", "N", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "return", "SelectImmShifterOperand", "(", "N", ",", "A", ",", "B", ",", "false" ]

[ ",", "get_t_reg_rtx", "(", ")", ")", ")" ]

[ "[", "(", "const_int", "<NUM_LIT>", ")", "]", "{", "rtx", "high", "=", "gen_highpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "rtx", "low", "=", "gen_lowpart", "(", "SImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "emit_insn", "(", "gen_shar", "(", "high", ",", "high", ")", ")", "emit_insn", "(", "gen_rotcr", "(", "low", ",", "low" ]

[ "<FIXS>", "inst", ",", "<STR_LIT>", ",", "AMDGPUexp", "<FIXE>" ]

[ "}", "class", "EXP_IEEE_Common", "bits", "<NUM_LIT>", ">", "inst", ">", ":", "R600_1OP_Helper", "<BUGS>", "inst", ",", "<STR_LIT>", ",", "fexp2", "<BUGE>", ">", "{", "let", "Itinerary", "=", "TransALU", ";", "}" ]

[ "(", "clobber", "(", "match_scratch", "<NUM_LIT>", ")", ")", "]" ]

[ "(", "fix", ":", "SWI248x", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", ")", ")", "(", "clobber", "(", "match_operand", ":", "SWI248x", "<NUM_LIT>", "<STR_LIT>", ")", ")" ]

[ "static", "void", "avr_asm_out_dtor", "(", "rtx", "symbol", ",", "int", "priority", ")", "{", "fputs", "(", "<STR_LIT>", "\\t.global __do_global_dtors\\n", "<STR_LIT>", ",", "asm_out_file", ")", ";", "default_dtor_section_asm_out_destructor", "(", "symbol", ",", "priority", ")", ";", "}" ]

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

[ "}" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_ternarylogic_epi64", "(", "_", "_", "m128i", "_", "_", "A", ",", "_", "_", "m128i", "_", "_", "B", ",", "_", "_", "m128i", "_", "_", "C", ",", "const", "int", "_", "_", "imm", ")", "{", "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_pternlogq128_mask", "(", "(", "_", "_", "v2di", ")", "_", "_", "A", ",", "(", "_", "_", "v2di", ")", "_", "_", "B", ",", "(", "_", "_", "v2di", ")", "_", "_", "C", ",", "(", "unsigned", "char", ")", "_", "_", "imm", ",", "(", "_", "_", "mmask8", ")", "-", "<NUM_LIT>", ")", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "opc", ";" ]

[ ")", ";" ]

[ "RegisterTargetMachine", "<", "HSAIL_32TargetMachine", ">", "X", "(", "TheHSAIL_32Target" ]

[ "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "<FIXE>", "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "NumBytes", ")", ";", "<FIXE>", "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<FIXE>", "<FIXS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<FIXE>" ]

[ "if", "(", "NumBytes", "<=", "<NUM_LIT>", ")", "{", "<BUGS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "<BUGE>", "addImm", "(", "-", "NumBytes", ")", ";", "}", "else", "{", "<BUGS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addImm", "(", "-", "NumBytes", ")", ";", "<BUGE>", "<BUGS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", "<BUGE>", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "}", "if", "(", "FP", ")", "{", "<BUGS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "<BUGS>", "BuildMI", "(", "MBB", ",", "MBBI", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "<STR_LIT>", "::", "<STR_LIT>", ")", ".", "addReg", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "<BUGE>", "}", "}" ]

[ "match_code", "<STR_LIT>", ")" ]

[ "(", "define_memory_constraint", "<STR_LIT>", "<STR_LIT>", "(", "and", "(" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":" ]

[ "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", ".rp", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", ".approx", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", ".rni", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", ".rzi", "<STR_LIT>", ";", "break", ";", "case", "<STR_LIT>", "::", "<STR_LIT>", ":", "O", "<<", "<STR_LIT>", ".rmi", "<STR_LIT>", ";", "break", ";" ]

[ "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";" ]

[ "case", "Mips", "::", "fixup_Mips_Branch_PCRel", ":", "case", "Mips", "::", "fixup_Mips_PC16", ":", "return", "ELF", "::", "R_MIPS_PC16", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC7_S1", ":", "return", "ELF", "::", "R_MICROMIPS_PC7_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC10_S1", ":", "return", "ELF", "::", "R_MICROMIPS_PC10_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC16_S1", ":", "return", "ELF", "::", "R_MICROMIPS_PC16_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC26_S1", ":", "return", "ELF", "::", "R_MICROMIPS_PC26_S1", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC19_S2", ":", "return", "ELF", "::", "R_MICROMIPS_PC19_S2", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC18_S3", ":", "return", "ELF", "::", "R_MICROMIPS_PC18_S3", ";", "case", "Mips", "::", "fixup_MICROMIPS_PC21_S1", ":", "return", "ELF", "::", "R_MICROMIPS_PC21_S1", ";", "case", "Mips", "::", "fixup_MIPS_PC19_S2", ":", "return", "ELF", "::", "R_MIPS_PC19_S2", ";", "case", "Mips", "::", "fixup_MIPS_PC18_S3", ":", "return", "ELF", "::", "R_MIPS_PC18_S3", ";", "case", "Mips", "::", "fixup_MIPS_PC21_S2", ":", "return", "ELF", "::", "R_MIPS_PC21_S2", ";", "case", "Mips", "::", "fixup_MIPS_PC26_S2", ":", "return", "ELF", "::", "R_MIPS_PC26_S2", ";", "case", "Mips", "::", "fixup_MIPS_PCHI16", ":", "return", "ELF", "::", "R_MIPS_PCHI16", ";", "case", "Mips", "::", "fixup_MIPS_PCLO16", ":", "return", "ELF", "::", "R_MIPS_PCLO16", ";", "}", "llvm_unreachable", "(", "<STR_LIT>", "invalid PC-relative fixup kind!", "<STR_LIT>", ")", ";", "}", "switch", "(", "Kind", ")", "{", "case", "Mips", "::", "fixup_Mips_64", ":", "case", "FK_Data_8", ":", "return", "ELF", "::", "R_MIPS_64", ";", "case", "FK_DTPRel_4", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL32", ";", "case", "FK_DTPRel_8", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL64", ";", "case", "FK_TPRel_4", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL32", ";", "case", "FK_TPRel_8", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL64", ";", "case", "FK_GPRel_4", ":", "if", "(", "is64Bit", "(", ")", ")", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL32", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_64", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ",", "Type", ")", ";", "return", "Type", ";", "}", "return", "ELF", "::", "R_MIPS_GPREL32", ";", "case", "Mips", "::", "fixup_Mips_GPREL16", ":", "return", "ELF", "::", "R_MIPS_GPREL16", ";", "case", "Mips", "::", "fixup_Mips_26", ":", "return", "ELF", "::", "R_MIPS_26", ";", "case", "Mips", "::", "fixup_Mips_CALL16", ":", "return", "ELF", "::", "R_MIPS_CALL16", ";", "case", "Mips", "::", "fixup_Mips_GOT", ":", "return", "ELF", "::", "R_MIPS_GOT16", ";", "case", "Mips", "::", "fixup_Mips_HI16", ":", "return", "ELF", "::", "R_MIPS_HI16", ";", "case", "Mips", "::", "fixup_Mips_LO16", ":", "return", "ELF", "::", "R_MIPS_LO16", ";", "case", "Mips", "::", "fixup_Mips_TLSGD", ":", "return", "ELF", "::", "R_MIPS_TLS_GD", ";", "case", "Mips", "::", "fixup_Mips_GOTTPREL", ":", "return", "ELF", "::", "R_MIPS_TLS_GOTTPREL", ";", "case", "Mips", "::", "fixup_Mips_TPREL_HI", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL_HI16", ";", "case", "Mips", "::", "fixup_Mips_TPREL_LO", ":", "return", "ELF", "::", "R_MIPS_TLS_TPREL_LO16", ";", "case", "Mips", "::", "fixup_Mips_TLSLDM", ":", "return", "ELF", "::", "R_MIPS_TLS_LDM", ";", "case", "Mips", "::", "fixup_Mips_DTPREL_HI", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL_HI16", ";", "case", "Mips", "::", "fixup_Mips_DTPREL_LO", ":", "return", "ELF", "::", "R_MIPS_TLS_DTPREL_LO16", ";", "case", "Mips", "::", "fixup_Mips_GOT_PAGE", ":", "return", "ELF", "::", "R_MIPS_GOT_PAGE", ";", "case", "Mips", "::", "fixup_Mips_GOT_OFST", ":", "return", "ELF", "::", "R_MIPS_GOT_OFST", ";", "case", "Mips", "::", "fixup_Mips_GOT_DISP", ":", "return", "ELF", "::", "R_MIPS_GOT_DISP", ";", "case", "Mips", "::", "fixup_Mips_GPOFF_HI", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MIPS_HI16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_MICROMIPS_GPOFF_HI", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";", "Type", "=", "setRType", "(", "(", "unsigned", ")", "ELF", "::", "R_MICROMIPS_GPREL16", ",", "Type", ")", ";", "Type", "=", "setRType2", "(", "(", "unsigned", ")", "ELF", "::", "R_MICROMIPS_SUB", ",", "Type", ")", ";", "Type", "=", "setRType3", "(", "(", "unsigned", ")", "ELF", "::", "R_MICROMIPS_HI16", ",", "Type", ")", ";", "return", "Type", ";", "}", "case", "Mips", "::", "fixup_Mips_GPOFF_LO", ":", "{", "unsigned", "Type", "=", "(", "unsigned", ")", "ELF", "::", "R_MIPS_NONE", ";" ]

[ "{", "<NUM_LIT>", "}", ";" ]

[ "def", "J4_cmpeqn1_fp1_jump_t", ":", "HInst", "<", "(", "outs", ")", ",", "(", "ins", "GeneralSubRegs", ":", "$", "Rs16", ",", "n1Const", ":", "$", "n1", ",", "b30_2Imm", ":", "$", "Ii", ")", ",", "<STR_LIT>", ",", "tc_3d495a39", ",", "TypeCJ", ">", ",", "Enc_800e04", ",", "PredRel", "{", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "isPredicatedFalse", "=", "<NUM_LIT>", ";", "let", "isTerminator", "=", "<NUM_LIT>", ";", "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P1", "]", ";", "let", "Defs", "=", "[", "P1", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst" ]

[ ")", "==", "Triple", "::", "sparcv9", ";" ]

[ "return", "STI", ".", "getTargetTriple", "(", ")", ".", "getArch", "(" ]

[ "TargetTransformInfo", "::", "PopcntSupportKind", "SystemZTTIImpl", "::", "getPopcntSupport", "(", "unsigned", "TyWidth", ")", "{", "assert", "(", "isPowerOf2_32", "(", "TyWidth", ")", "&&", "<STR_LIT>", "Type width must be power of 2", "<STR_LIT>", ")", ";", "if", "(", "ST", "->", "hasPopulationCount", "(", ")", "&&", "TyWidth", "<=", "<NUM_LIT>", ")", "return", "TTI", "::", "PSK_FastHardware", ";", "return", "TTI", "::", "PSK_Software", ";", "}" ]

[ "Return", "hardware", "support", "for", "population", "count", "." ]

[ ")" ]

[ "(", "define_insn_reservation", "<STR_LIT>", "<NUM_LIT>", "(", "and", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<FIXS>", "emit_move_insn", "(", "my_fp", ",", "plus_constant", "(", "Pmode", ",", "my_fp", ",", "size", ")", ")", ";", "<FIXE>" ]

[ "if", "(", "!", "frame_pointer_needed", ")", "emit_move_insn", "(", "fp", ",", "stack_pointer_rtx", ")", ";", "<BUGS>", "emit_move_insn", "(", "my_fp", ",", "plus_constant", "(", "my_fp", ",", "size", ")", ")", ";", "<BUGE>" ]

[ "void", "visium_expand_copysign", "(", "rtx", "*", "operands", ",", "machine_mode", "mode", ")", "{", "rtx", "op0", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "op1", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "op2", "=", "operands", "[", "<NUM_LIT>", "]", ";", "rtx", "mask", "=", "force_reg", "(", "SImode", ",", "GEN_INT", "(", "<NUM_LIT>", ")", ")", ";", "rtx", "x", ";", "gcc_assert", "(", "mode", "==", "SFmode", ")", ";", "if", "(", "GET_CODE", "(", "op1", ")", "==", "CONST_DOUBLE", ")", "{", "if", "(", "real_isneg", "(", "CONST_DOUBLE_REAL_VALUE", "(", "op1", ")", ")", ")", "op1", "=", "simplify_unary_operation", "(", "ABS", ",", "mode", ",", "op1", ",", "mode", ")", ";", "if", "(", "op1", "!=", "CONST0_RTX", "(", "mode", ")", ")", "{", "long", "l", ";", "REAL_VALUE_TO_TARGET_SINGLE", "(", "*", "CONST_DOUBLE_REAL_VALUE", "(", "op1", ")", ",", "l", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "gen_int_mode", "(", "l", ",", "SImode", ")", ")", ";", "}", "}", "else", "{", "op1", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op1", ")", ")", ";", "op1", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op1", ",", "mask", ")", ")", ";", "}", "mask", "=", "force_reg", "(", "SImode", ",", "gen_rtx_NOT", "(", "SImode", ",", "mask", ")", ")", ";", "op2", "=", "copy_to_mode_reg", "(", "SImode", ",", "gen_lowpart", "(", "SImode", ",", "op2", ")", ")", ";", "op2", "=", "force_reg", "(", "SImode", ",", "gen_rtx_AND", "(", "SImode", ",", "op2", ",", "mask", ")", ")", ";", "if", "(", "op1", "==", "CONST0_RTX", "(", "SFmode", ")", ")", "x", "=", "op2", ";", "else", "x", "=", "force_reg", "(", "SImode", ",", "gen_rtx_IOR", "(", "SImode", ",", "op1", ",", "op2", ")", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "op0", ",", "gen_lowpart", "(", "SFmode", ",", "x", ")", ")", ")", ";", "}" ]

[ "Expand", "a", "copysign", "of", "OPERANDS", "in", "MODE", "." ]

[ "<STR_LIT>", ">", ";" ]

[ "def", "DS_ORDERED_COUNT", ":", "DS_1A_RET_GDS", "<" ]

[ ";" ]

[ "const", "uint16_t", "*", "XtensaRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "return", "CSR_Xtensa_SaveList" ]

[ "<FIXS>", "rtvec", "vtemp", "=", "gen_rtvec", "(", "<NUM_LIT>", ",", "copy_rtx", "(", "PATTERN", "(", "anchor", ")", ")", ",", "copy_rtx", "(", "PATTERN", "(", "floater", ")", ")", ")", ";", "rtx", "temp", "=", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "vtemp", ")", ";", "emit_insn_before", "(", "temp", ",", "anchor", ")", ";", "<FIXE>", "<FIXS>", "temp", "=", "copy_rtx", "(", "PATTERN", "(", "floater", ")", ")", ";", "emit_insn_before", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "temp", ")", ",", "floater", ")", ";", "<FIXE>" ]

[ "||", "anchor_attr", "==", "PA_COMBINE_TYPE_FMPY", ")", ")", "{", "<BUGS>", "emit_insn_before", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "PATTERN", "(", "anchor", ")", ",", "PATTERN", "(", "floater", ")", ")", ")", ",", "anchor", ")", ";", "<BUGE>", "SET_INSN_DELETED", "(", "anchor", ")", ";", "<BUGS>", "emit_insn_before", "(", "gen_rtx_USE", "(", "VOIDmode", ",", "floater", ")", ",", "floater", ")", ";", "<BUGE>", "delete", "_", "insn", "(", "floater", ")", ";", "continue", ";" ]

[ ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "copy0MBB", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addMBB", "(", "thisMBB", ")", ";" ]

[ "MachineBasicBlock", "*", "thisMBB", "=", "BB", ";", "MachineFunction", "*", "F", "=", "BB", "->", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "copy0MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "MachineBasicBlock", "*", "copy1MBB", "=", "F", "->", "CreateMachineBasicBlock", "(", "LLVM_BB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy0MBB", ")", ";", "F", "->", "insert", "(", "I", ",", "copy1MBB", ")", ";", "copy1MBB", "->", "splice", "(", "copy1MBB", "->", "begin", "(", ")", ",", "BB", ",", "std", "::", "next", "(", "MachineBasicBlock", "::", "iterator", "(", "MI", ")", ")", ",", "BB", "->", "end", "(", ")", ")", ";", "copy1MBB", "->", "transferSuccessorsAndUpdatePHIs", "(", "BB", ")", ";", "BB", "->", "addSuccessor", "(", "copy0MBB", ")", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BuildMI", "(", "BB", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ".", "addMBB", "(", "copy1MBB", ")", ".", "addImm", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ")", ";", "BB", "=", "copy0MBB", ";", "BB", "->", "addSuccessor", "(", "copy1MBB", ")", ";", "BB", "=", "copy1MBB", ";", "BuildMI", "(", "*", "BB", ",", "BB", "->", "begin", "(", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ")", ".", "addReg", "(", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")" ]

[ "<STR_LIT>", ")" ]

[ "(", "match_operand", ":", "SF", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>" ]

[ "SDValue", "SparcTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "<STR_LIT>", "Should not custom lower this!", "<STR_LIT>", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "llvm_unreachable", "(", "<STR_LIT>", "TLS not implemented for Sparc.", "<STR_LIT>", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_CC", ":", "return", "LowerBR_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT_CC", ":", "return", "LowerSELECT_CC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ",", "*", "this", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "}" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "num_reg_words", ";" ]

[ "int", "size", ";", "if", "(", "mode", "==", "VOIDmode", ")", "{", "int", "i", ";", "HOST_WIDE_INT", "lo", ";", "HOST_WIDE_INT", "hi", ";", "rtx", "ciw", ";", "lo", "=", "<NUM_LIT>", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "cum", ".", "num_reg_words", "&&", "i", "<", "<NUM_LIT>", ";", "i", "++", ")", "if", "(", "cum", ".", "reg_args_type", "[", "i", "]", ")", "lo", "|=", "(", "<NUM_LIT>", "<<", "(", "<NUM_LIT>", "-", "i", ")", ")", ";", "if", "(", "cum", ".", "num_reg_words", "==", "<NUM_LIT>", "&&", "cum", ".", "reg_args_type", "[", "<NUM_LIT>", "]", ")", "lo", "|=", "<NUM_LIT>", ";", "else", "lo", "|=", "cum", ".", "num_reg_words", ";", "hi", "=", "(", "cum", ".", "num_args", "<<", "<NUM_LIT>", ")", "|", "cum", ".", "num_arg_words", ";", "lo", "=", "lo", "|", "(", "(", "HOST_WIDE_INT", ")", "cum", ".", "num_args", "<<", "<NUM_LIT>", ")", "|", "(", "(", "HOST_WIDE_INT", ")", "cum", ".", "num_arg_words", "<<", "<NUM_LIT>", ")", ";", "hi", "=", "<NUM_LIT>", ";", "ciw", "=", "immed_double_const", "(", "lo", ",", "hi", ",", "DImode", ")", ";", "return", "gen_rtx_UNSPEC", "(", "DImode", ",", "gen_rtvec", "(", "<NUM_LIT>", ",", "ciw", ")", ",", "UNSPEC_UMK_LOAD_CIW", ")", ";", "}", "size", "=", "ALPHA_ARG_SIZE", "(", "mode", ",", "type", ",", "named", ")", ";", "num_args", "=", "cum", "." ]

[ "}" ]

[ "for", "(", "IFMapType", "::", "iterator", "I", "=", "IFMap", ".", "begin", "(", ")", ";", "I", "!=", "End", ";", "++", "I", ")", "{", "IFListType", "&", "LL", "=", "I", "->", "second", ";", "if", "(", "LL", ".", "empty", "(", ")", ")", "continue", ";", "IFListType", "::", "iterator", "MinI", "=", "llvm", "::", "min_element", "(", "LL", ",", "IFO", ")", ";", "assert", "(", "MinI", "!=", "LL", ".", "end", "(", ")", ")", ";", "IFRecordWithRegSet", "M", "=", "*", "MinI", ";", "LL", ".", "clear", "(", ")", ";", "RegisterSet", "Us", ";", "const", "MachineInstr", "*", "DefI", "=", "MRI", "->", "getVRegDef", "(", "I", "->", "first", ")", ";", "getInstrUses", "(", "DefI", ",", "Us", ")", ";", "bool", "Accept", "=", "false", ";", "if", "(", "SelectAll0", ")", "{", "bool", "All0", "=", "true", ";", "for", "(", "unsigned", "R", "=", "Us", ".", "find_first", "(", ")", ";", "R", ";", "R", "=", "Us", ".", "find_next", "(", "R", ")", ")", "{", "if", "(", "UseC", "[", "R", "]", "==", "<NUM_LIT>", ")", "continue", ";", "All0", "=", "false", ";", "break", ";", "}", "Accept", "=", "All0", ";", "}", "else", "if", "(", "SelectHas0", ")", "{", "bool", "Has0", "=", "false", ";", "for", "(", "unsigned", "R", "=", "Us", ".", "find_first", "(", ")", ";", "R", ";", "R", "=", "Us", ".", "find_next", "(", "R", ")", ")", "{", "if", "(", "UseC", "[", "R", "]", "!=", "<NUM_LIT>", ")", "continue", ";", "Has0", "=", "true", ";", "break", ";", "}", "Accept", "=", "Has0", ";", "}", "if", "(", "Accept", ")", "LL", ".", "push_back", "(", "M", ")", ";" ]

[ ")", ")" ]

[ "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>", ")", ")", "(", "eq_attr", "<STR_LIT>", "<STR_LIT>" ]

[ "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")", "]", ")" ]

[ "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "[", "(", "set_attr", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "unspec_volatile", ":", "DI", "[", "(", "match_operand", ":", "DI" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rd", ";" ]

[ "class", "BaseAddSubImm", "<", "bit", "isSub", ",", "bit", "setFlags", ",", "RegisterClass", "dstRegtype", ",", "string", "asm_inst", ",", "string", "asm_ops", ",", "dag", "inputs", ",", "dag", "pattern", ">", ":", "I", "<", "(", "outs", "dstRegtype", ":", "$", "Rd", ")", ",", "inputs", ",", "asm_inst", ",", "asm_ops", ",", "<STR_LIT>", ",", "[", "pattern", "]", ">", ",", "Sched", "<", "[", "WriteI", ",", "ReadI", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "isSub", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "setFlags", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "(", "match_test", "<STR_LIT>", ")", ")", ")" ]

[ "<STR_LIT>", "(", "and", "(", "match_code", "<STR_LIT>", ")" ]

[ "(", "UNSPECV_WRFSBASE", "<STR_LIT>", ")" ]

[ "[", "(", "UNSPECV_RDFSBASE", "<STR_LIT>", ")", "(", "UNSPECV_RDGSBASE", "<STR_LIT>", ")" ]

[ "(", "unspec", ":", "SI", "[", "(", "const_int", "<NUM_LIT>", ")", "]", "UNSPEC_MCLRACC", ")", ")" ]

[ "(", "define_insn", "<STR_LIT>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "}" ]

[ "const", "MachineInstr", "*", "DefI", "=", "MRI", "->", "getVRegDef", "(", "R", ")", ";", "assert", "(", "DefI", "&&", "<STR_LIT>", "Expecting a reaching def in MRI", "<STR_LIT>", ")", ";", "if", "(", "DefI", "->", "isImplicitDef", "(", ")", ")", "return", "true", ";" ]

[ "}" ]

[ "_", "_", "uhasx", "(", "uint16x2_t", "_", "_", "a", ",", "uint16x2_t", "_", "_", "b", ")", "{", "return", "_", "_", "builtin_arm_uhasx", "(", "_", "_", "a", ",", "_", "_", "b", ")", ";" ]

[ "::", "V_MOV_B32_e32", ";" ]

[ "AMDGPU", "::", "sub0", ",", "AMDGPU", "::", "sub1", ",", "AMDGPU", "::", "sub2", ",", "AMDGPU", "::", "sub3", ",", "AMDGPU", "::", "sub4", ",", "AMDGPU", "::", "sub5", ",", "AMDGPU", "::", "sub6", ",", "AMDGPU", "::", "sub7", ",", "<NUM_LIT>", "}", ";", "static", "const", "int16_t", "Sub0_3", "[", "]", "=", "{", "AMDGPU", "::", "sub0", ",", "AMDGPU", "::", "sub1", ",", "AMDGPU", "::", "sub2", ",", "AMDGPU", "::", "sub3", ",", "<NUM_LIT>", "}", ";", "static", "const", "int16_t", "Sub0_2", "[", "]", "=", "{", "AMDGPU", "::", "sub0", ",", "AMDGPU", "::", "sub1", ",", "AMDGPU", "::", "sub2", ",", "<NUM_LIT>", "}", ";", "static", "const", "int16_t", "Sub0_1", "[", "]", "=", "{", "AMDGPU", "::", "sub0", ",", "AMDGPU", "::", "sub1", ",", "<NUM_LIT>", "}", ";", "unsigned", "Opcode", ";", "const", "int16_t", "*", "SubIndices", ";", "if", "(", "AMDGPU", "::", "M0", "==", "DestReg", ")", "{", "for", "(", "MachineBasicBlock", "::", "reverse_iterator", "E", "=", "MBB", ".", "rend", "(", ")", ",", "I", "=", "MachineBasicBlock", "::", "reverse_iterator", "(", "MI", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "if", "(", "!", "I", "->", "definesRegister", "(", "AMDGPU", "::", "M0", ")", ")", "continue", ";", "unsigned", "Opc", "=", "I", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "TargetOpcode", "::", "COPY", "&&", "Opc", "!=", "AMDGPU", "::", "S_MOV_B32", ")", "break", ";", "if", "(", "!", "I", "->", "readsRegister", "(", "SrcReg", ")", ")", "break", ";", "return", ";", "}", "}", "if", "(", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_MOV_B32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "S_MOV_B64", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "AMDGPU", "::", "SReg_128RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "SReg_128RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "SubIndices", "=", "Sub0_3", ";", "}", "else", "if", "(", "AMDGPU", "::", "SReg_256RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "SReg_256RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "SubIndices", "=", "Sub0_7", ";", "}", "else", "if", "(", "AMDGPU", "::", "SReg_512RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "SReg_512RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "Opcode", "=", "AMDGPU", "::", "S_MOV_B32", ";", "SubIndices", "=", "Sub0_15", ";", "}", "else", "if", "(", "AMDGPU", "::", "VReg_32RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "VReg_32RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "AMDGPU", "::", "V_MOV_B32_e32", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "KillSrc", ")", ")", ";", "return", ";", "}", "else", "if", "(", "AMDGPU", "::", "VReg_64RegClass", ".", "contains", "(", "DestReg", ")", ")", "{", "assert", "(", "AMDGPU", "::", "VReg_64RegClass", ".", "contains", "(", "SrcReg", ")", "||", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "SrcReg", ")", ")", ";", "Opcode", "=", "AMDGPU" ]

[ "<FIXS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<FIXE>", "<FIXS>", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<FIXE>" ]

[ "operands", "[", "<NUM_LIT>", "]", "=", "m68hc11_gen_lowpart", "(", "HImode", ",", "operands", "[", "<NUM_LIT>", "]", ")", "(", "define_insn", "<STR_LIT>", "<BUGS>", "[", "(", "set", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "ashift", ":", "SI", "(", "match_operand", ":", "SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "<BUGE>", "(", "const_int", "<NUM_LIT>", ")", ")", ")", "<BUGS>", "(", "clobber", "(", "match_scratch", ":", "HI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "]", "<BUGE>", "<STR_LIT>", "<STR_LIT>", ")" ]

[ "Type", ",", "MIRBuilder", ")", ";" ]

[ "TypeStr", "=", "TypeStr", ".", "startswith", "(", "<STR_LIT>", "int", "<STR_LIT>", ")", "?", "TypeStr", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "int", "<STR_LIT>", ")", ")", ":", "TypeStr", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "uint", "<STR_LIT>", ")", ")", ";", "}", "else", "if", "(", "TypeStr", ".", "startswith", "(", "<STR_LIT>", "float", "<STR_LIT>", ")", ")", "{", "Type", "=", "Type", "::", "getFloatTy", "(", "Ctx", ")", ";", "TypeStr", "=", "TypeStr", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "float", "<STR_LIT>", ")", ")", ";", "}", "else", "if", "(", "TypeStr", ".", "startswith", "(", "<STR_LIT>", "half", "<STR_LIT>", ")", ")", "{", "Type", "=", "Type", "::", "getHalfTy", "(", "Ctx", ")", ";", "TypeStr", "=", "TypeStr", ".", "substr", "(", "strlen", "(", "<STR_LIT>", "half", "<STR_LIT>", ")", ")", ";", "}", "else", "if", "(", "TypeStr", ".", "startswith", "(", "<STR_LIT>", "opencl.sampler_t", "<STR_LIT>", ")", ")", "{", "Type", "=", "StructType", "::", "create", "(", "Ctx", ",", "<STR_LIT>", "opencl.sampler_t", "<STR_LIT>", ")", ";", "}", "else", "llvm_unreachable", "(", "<STR_LIT>", "Unable to recognize SPIRV type name.", "<STR_LIT>", ")", ";", "if", "(", "TypeStr", ".", "startswith", "(", "<STR_LIT>", " vector[", "<STR_LIT>", ")", ")", "{", "TypeStr", "=", "TypeStr", ".", "substr", "(", "strlen", "(", "<STR_LIT>", " vector[", "<STR_LIT>", ")", ")", ";", "TypeStr", "=", "TypeStr", ".", "substr", "(", "<NUM_LIT>", ",", "TypeStr", ".", "find", "(", "'", "]", "'", ")", ")", ";", "}", "TypeStr", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "VecElts", ")", ";", "auto", "SpirvTy", "=", "getOrCreateSPIRVType", "(" ]

[ "if", "(", "Size", "<", "<NUM_LIT>", ")", "return", "false", ";" ]

[ "}", "if", "(", "Size", "==", "<NUM_LIT>", ")", "{", "bool", "AlignedBy8", "=", "Alignment", ">=", "Align", "(", "<NUM_LIT>", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy8", ";", "return", "AlignedBy8", ";", "}", "}", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ")", "{", "bool", "AlignedBy4", "=", "Alignment", ">=", "Align", "(", "<NUM_LIT>", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy4", ";", "return", "AlignedBy4", "||", "Subtarget", "->", "enableFlatScratch", "(", ")", "||", "Subtarget", "->", "hasUnalignedScratchAccess", "(", ")", ";", "}", "if", "(", "AddrSpace", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", "&&", "!", "Subtarget", "->", "hasUnalignedScratchAccess", "(", ")", ")", "{", "bool", "AlignedBy4", "=", "Alignment", ">=", "Align", "(", "<NUM_LIT>", ")", ";", "if", "(", "IsFast", ")", "*", "IsFast", "=", "AlignedBy4", ";", "return", "AlignedBy4", ";", "}", "if", "(", "Subtarget", "->", "hasUnalignedBufferAccessEnabled", "(", ")", "&&", "!", "(", "AddrSpace", "==", "AMDGPUAS", "::", "LOCAL_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "REGION_ADDRESS", ")", ")", "{", "if", "(", "IsFast", ")", "{", "*", "IsFast", "=", "(", "AddrSpace", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS", "||", "AddrSpace", "==", "AMDGPUAS", "::", "CONSTANT_ADDRESS_32BIT", ")", "?", "Alignment", ">=", "Align", "(", "<NUM_LIT>", ")", ":", "Alignment", "!=", "Align", "(", "<NUM_LIT>", ")", ";", "}", "return", "true", ";", "}" ]

[ "(", "clobber", "(", "reg", ":", "SI", "R_MDC", ")", ")", "]" ]

[ "(", "define_split", "[", "(", "set", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "lshiftrt", ":", "DI", "(", "match_operand", ":", "DI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "const_int", "<NUM_LIT>", ")", ")", ")" ]

[ "_", "_", "a", ";" ]

[ "return", "(", "int32x2_t", ")" ]

[ "}" ]

[ "let", "RowFields", "=", "[", "<STR_LIT>", "]", ";", "let", "ColFields", "=", "[", "<STR_LIT>", "]", ";", "let", "KeyCol", "=", "[", "<STR_LIT>", "]", ";", "let", "ValueCols", "=", "[", "[", "<STR_LIT>", "]", "]", ";" ]

[ "}" ]

[ "Roots", ".", "push_back", "(", "N", ")", ";", "continue", ";", "}", "GepNode", "*", "PN", "=", "N", "->", "Parent", ";", "NCM", "[", "PN", "]", ".", "push_back", "(", "N", ")", ";" ]

[ "_", "_", "q1", ",", "int", "_", "_", "q2", ",", "int", "_", "_", "q3", ")", "{" ]

[ "extern", "_", "_", "inline", "_", "_", "m128i", "_", "_", "attribute__", "(", "(", "_", "_", "gnu_inline__", ",", "_", "_", "always_inline__", ",", "_", "_", "artificial__", ")", ")", "_", "mm_setr_epi32", "(", "int", "_", "_", "q0", ",", "int" ]

[ ")", ";" ]

[ "std", "::", "vector", "<", "std", "::", "string", ">", "clrp0", "(", ")", "{", "return", "D", "(", "<STR_LIT>", "clr0", "<STR_LIT>" ]

[ "let", "NumMicroOps", "=", "<NUM_LIT>", ";" ]

[ "def", "ICXWriteResGroup103", ":", "SchedWriteRes", "<", "[", "ICXPort5", ",", "ICXPort23", ",", "ICXPort0156", "]", ">", "{", "let", "Latency", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Rn", ";" ]

[ "class", "AI_crc32", "<", "bit", "C", ",", "bits", "<", "<NUM_LIT>", ">", "sz", ",", "string", "suffix", ",", "SDPatternOperator", "builtin", ">", ":", "AInoP", "<", "(", "outs", "GPRnopc", ":", "$", "Rd", ")", ",", "(", "ins", "GPRnopc", ":", "$", "Rn", ",", "GPRnopc", ":", "$", "Rm", ")", ",", "MiscFrm", ",", "NoItinerary", ",", "!", "strconcat", "(", "<STR_LIT>", ",", "suffix", ")", ",", "<STR_LIT>", ",", "[", "(", "set", "GPRnopc", ":", "$", "Rd", ",", "(", "builtin", "GPRnopc", ":", "$", "Rn", ",", "GPRnopc", ":", "$", "Rm", ")", ")", "]", ">", ",", "Requires", "<", "[", "IsARM", ",", "HasV8", ",", "HasCRC", "]", ">", "{", "bits", "<", "<NUM_LIT>", ">", "Rd", ";", "bits", "<", "<NUM_LIT>", ">", "Rn", ";", "bits", "<", "<NUM_LIT>", ">", "Rm", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "sz", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ ",", "<NUM_LIT>", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";" ]

[ "return", "Ctx", ".", "getELFSection", "(", "<STR_LIT>", ".note.GNU-stack", "<STR_LIT>", ",", "MCSectionELF", "::", "SHT_PROGBITS" ]

[ "v8hi", ")", "_", "_", "W", ",", "(", "_", "_", "mmask8", ")", "_", "_", "U", ")", ";" ]

[ "return", "(", "_", "_", "m128i", ")", "_", "_", "builtin_ia32_vcvtps2ph_mask", "(", "(", "_", "_", "v4sf", ")", "_", "_", "A", ",", "_", "_", "I", ",", "(", "_", "_" ]

[ ")", "{" ]

[ "bool", "ARMDAGToDAGISel", "::", "SelectThumbAddrModeImm5S4", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "OffImm" ]

[ "}" ]

[ "int", "code", "=", "GET_CODE", "(", "cond", ")", ";", "if", "(", "cc_prev_status", ".", "flags", "&", "CC_NO_OVERFLOW", "&&", "(", "code", "==", "GT", "||", "code", "==", "LE", ")", ")", "{", "fprintf", "(", "asm_out_file", ",", "<STR_LIT>", "\\tresflg\tv\\n", "<STR_LIT>", ")", ";" ]

[ "let", "isExtentSigned", "=", "<NUM_LIT>", ";" ]

[ "let", "isBranch", "=", "<NUM_LIT>", ";", "let", "isPredicatedNew", "=", "<NUM_LIT>", ";", "let", "cofRelax1", "=", "<NUM_LIT>", ";", "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";" ]

[ "_", "_", "mmask8", ")", "_", "_", "U", ",", "_", "_", "R", ")", ";" ]

[ "return", "(", "_", "_", "m512d", ")", "_", "_", "builtin_ia32_minpd512_mask", "(", "(", "_", "_", "v8df", ")", "_", "_", "A", ",", "(", "_", "_", "v8df", ")", "_", "_", "B", ",", "(", "_", "_", "v8df", ")", "_", "mm512_setzero_pd", "(", ")", ",", "(" ]

[ "initializeSILoadStoreOptimizerPass", "(", "*", "PR", ")", ";" ]

[ "PassRegistry", "*", "PR", "=", "PassRegistry", "::", "getPassRegistry", "(", ")", ";", "initializeSIFixSGPRLiveRangesPass", "(", "*", "PR", ")", ";", "initializeSIFixControlFlowLiveIntervalsPass", "(", "*", "PR", ")", ";" ]

[ "}", ")" ]

[ "(", "vec_concat", ":", "V32SI", "(", "vec_concat", ":", "V16SI", "(", "match_operand", ":", "V8SI", "<NUM_LIT>", "<STR_LIT>", "<STR_LIT>", ")", "(", "match_operand", ":", "V8SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "match_operand", ":", "V16SI", "<NUM_LIT>", "<STR_LIT>", ")", ")", "(", "match_parallel", "<NUM_LIT>", "<STR_LIT>", "[", "(", "match_operand", "<NUM_LIT>", "<STR_LIT>", ")", "]", ")", ")", ")", "]", "<STR_LIT>", "<STR_LIT>", "<STR_LIT>", "[", "(", "set", "(", "match_dup", "<NUM_LIT>", ")", "(", "zero_extend", ":", "V8DI", "(", "match_dup", "<NUM_LIT>", ")", ")", ")", "]", "{", "operands", "[", "<NUM_LIT>", "]", "=", "lowpart_subreg", "(", "V8DImode", ",", "operands", "[", "<NUM_LIT>", "]", ",", "V16SImode", ")" ]

[ "<STR_LIT>", ")" ]

[ "(", "ior", "(", "match_operand", "<NUM_LIT>" ]

[ "}" ]

[ "let", "cofRelax2", "=", "<NUM_LIT>", ";", "let", "cofMax1", "=", "<NUM_LIT>", ";", "let", "Uses", "=", "[", "P0", "]", ";", "let", "Defs", "=", "[", "P0", ",", "PC", "]", ";", "let", "BaseOpcode", "=", "<STR_LIT>", ";", "let", "isTaken", "=", "Inst", "{", "<NUM_LIT>", "}", ";", "let", "isExtendable", "=", "<NUM_LIT>", ";", "let", "opExtendable", "=", "<NUM_LIT>", ";", "let", "isExtentSigned", "=", "<NUM_LIT>", ";", "let", "opExtentBits", "=", "<NUM_LIT>", ";", "let", "opExtentAlign", "=", "<NUM_LIT>", ";" ]

[ ")", ",", "asm", ",", "<STR_LIT>", "#", "kind", "#", "<STR_LIT>", "#", "opt_shift", "#", "<STR_LIT>", "#", "kind", "#", "<STR_LIT>", "#", "opt_shift", "#", "<STR_LIT>", ",", "<STR_LIT>", ",", "pattern", ">", "{" ]

[ "class", "BaseSIMDModifiedImmVectorTied", "<", "bit", "Q", ",", "bit", "op", ",", "RegisterOperand", "vectype", ",", "Operand", "immtype", ",", "dag", "opt_shift_iop", ",", "string", "opt_shift", ",", "string", "asm", ",", "string", "kind", ",", "list", "<", "dag", ">", "pattern", ">", ":", "BaseSIMDModifiedImm", "<", "Q", ",", "op", ",", "<NUM_LIT>", ",", "(", "outs", "vectype", ":", "$", "dst", ")", ",", "!", "con", "(", "(", "ins", "vectype", ":", "$", "Rd", ",", "immtype", ":", "$", "imm8", ")", ",", "opt_shift_iop" ]

[ "}" ]

[ "else", "if", "(", "ARITHMETIC_P", "(", "plus0", ")", "||", "ARITHMETIC_P", "(", "plus1", ")", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", "-", "<NUM_LIT>", ";", "else", "if", "(", "REG_P", "(", "plus0", ")", "&&", "REG_P", "(", "plus1", ")", ")", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";", "default", ":", "break", ";", "}", "return", "COSTS_N_INSNS", "(", "<NUM_LIT>", ")", ";" ]

[ "let", "validForTailPredication", "=", "<NUM_LIT>", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "size", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "bit_12", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qm", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";" ]

[ "if", "(", "isa", "<", "const", "IntrinsicInst", ">", "(", "Instr", ")", ")", "return", "false", ";" ]

[ "if", "(", "isa", "<", "const", "GetElementPtrInst", ">", "(", "Instr", ")", "&&", "OpIdx", ">", "<NUM_LIT>", ")", "return", "false", ";", "if", "(", "isa", "<", "const", "LandingPadInst", ">", "(", "Instr", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "const", "SwitchInst", ">", "(", "Instr", ")", ")", "return", "false", ";", "if", "(", "isa", "<", "const", "IndirectBrInst", ">", "(", "Instr", ")", ")", "return", "false", ";" ]

[ "<FIXS>", "bool", "skipIfDead", "(", "MachineInstr", "&", "MI", ")", ";", "<FIXE>" ]

[ "bool", "shouldSkip", "(", "MachineBasicBlock", "*", "From", ",", "MachineBasicBlock", "*", "To", ")", ";", "void", "Skip", "(", "MachineInstr", "&", "From", ",", "MachineOperand", "&", "To", ")", ";", "<BUGS>", "void", "SkipIfDead", "(", "MachineInstr", "&", "MI", ")", ";", "<BUGE>", "void", "If", "(", "MachineInstr", "&", "MI", ")", ";", "void", "Else", "(", "MachineInstr", "&", "MI", ",", "bool", "ExecModified", ")", ";" ]

[ "GR64RegClass", ")", ";" ]

[ "default", ":", "return", "<NUM_LIT>", ";", "case", "MVT", "::", "f32", ":", "if", "(", "X86ScalarSSEf32", ")", "Opc", "=", "HasAVX512", "?", "X86", "::", "VMOVSSZrm_alt", ":", "HasAVX", "?", "X86", "::", "VMOVSSrm_alt", ":", "X86", "::", "MOVSSrm_alt", ";", "else", "Opc", "=", "X86", "::", "LD_Fp32m", ";", "break", ";", "case", "MVT", "::", "f64", ":", "if", "(", "X86ScalarSSEf64", ")", "Opc", "=", "HasAVX512", "?", "X86", "::", "VMOVSDZrm_alt", ":", "HasAVX", "?", "X86", "::", "VMOVSDrm_alt", ":", "X86", "::", "MOVSDrm_alt", ";", "else", "Opc", "=", "X86", "::", "LD_Fp64m", ";", "break", ";", "case", "MVT", "::", "f80", ":", "return", "<NUM_LIT>", ";", "}", "Align", "Alignment", "=", "DL", ".", "getPrefTypeAlign", "(", "CFP", "->", "getType", "(", ")", ")", ";", "unsigned", "PICBase", "=", "<NUM_LIT>", ";", "unsigned", "char", "OpFlag", "=", "Subtarget", "->", "classifyLocalReference", "(", "nullptr", ")", ";", "if", "(", "OpFlag", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "PICBase", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "FuncInfo", ".", "MF", ")", ";", "else", "if", "(", "OpFlag", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "PICBase", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "FuncInfo", ".", "MF", ")", ";", "else", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "TM", ".", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Small", ")", "PICBase", "=", "X86", "::", "RIP", ";", "unsigned", "CPI", "=", "MCP", ".", "getConstantPoolIndex", "(", "CFP", ",", "Alignment", ")", ";", "Register", "ResultReg", "=", "createResultReg", "(", "TLI", ".", "getRegClassFor", "(", "VT", ".", "SimpleTy", ")", ")", ";", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "CM", "==", "CodeModel", "::", "Large", ")", "{", "Register", "AddrReg", "=", "createResultReg", "(", "&", "X86", "::" ]

[ "}" ]

[ "if", "(", "!", "SrcIsSSE", "&&", "!", "DstIsSSE", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_EXTEND", ")", "continue", ";", "if", "(", "N", "->", "getConstantOperandVal", "(", "<NUM_LIT>", ")", ")", "continue", ";", "}", "EVT", "MemVT", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "FP_ROUND", ")", "MemVT", "=", "DstVT", ";", "else", "MemVT", "=", "SrcIsSSE", "?", "SrcVT", ":", "DstVT", ";", "SDValue", "MemTmp", "=", "CurDAG", "->", "CreateStackTemporary", "(", "MemVT", ")", ";", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "SDValue", "Store", "=", "CurDAG", "->", "getTruncStore", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "N", "->", "getOperand", "(", "<NUM_LIT>", ")", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "SDValue", "Result", "=", "CurDAG", "->", "getExtLoad", "(", "ISD", "::", "EXTLOAD", ",", "DstVT", ",", "dl", ",", "Store", ",", "MemTmp", ",", "MachinePointerInfo", "(", ")", ",", "MemVT", ",", "false", ",", "false", ",", "<NUM_LIT>", ")", ";", "--", "I", ";", "CurDAG", "->", "ReplaceAllUsesOfValueWith", "(", "SDValue", "(", "N", ",", "<NUM_LIT>", ")", ",", "Result", ")", ";", "++", "I", ";", "CurDAG", "->", "DeleteNode", "(", "N", ")", ";" ]

[ "Qn", "{", "<NUM_LIT>", "}", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qn", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "Qd", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", ";", "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "Inst", "{", "<NUM_LIT>", "}", "=" ]

[ "HalfWordAccess", ";" ]

[ "let", "Inst", "{", "<NUM_LIT>", "-", "<NUM_LIT>", "}", "=", "<NUM_LIT>", ";", "let", "isPredicated", "=", "<NUM_LIT>", ";", "let", "hasNewValue", "=", "<NUM_LIT>", ";", "let", "opNewValue", "=", "<NUM_LIT>", ";", "let", "addrMode", "=", "PostInc", ";", "let", "accessSize", "=" ]

[ "(", "DstReg", ")", ".", "addImm", "(", "Offset", ")", ";" ]

[ "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "unsigned", "BasePtr", "=", "(", "TFI", "->", "hasFP", "(", "MF", ")", "?", "<STR_LIT>", "::", "<STR_LIT>", ":", "<STR_LIT>", "::", "<STR_LIT>", ")", ";", "int", "Offset", "=", "MF", ".", "getFrameInfo", "(", ")", "->", "getObjectOffset", "(", "FrameIndex", ")", ";", "Offset", "+=", "<NUM_LIT>", ";", "if", "(", "!", "TFI", "->", "hasFP", "(", "MF", ")", ")", "Offset", "+=", "MF", ".", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "else", "Offset", "+=", "<NUM_LIT>", ";", "Offset", "+=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "<NUM_LIT>", ")", ".", "getImm", "(", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "<STR_LIT>", "::", "<STR_LIT>", ")", "{", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "MI", ".", "setDesc", "(", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "BasePtr", ",", "false", ")", ";", "if", "(", "Offset", "==", "<NUM_LIT>", ")", "return", ";", "unsigned", "DstReg", "=", "MI", ".", "getOperand", "(", "<NUM_LIT>", ")", ".", "getReg", "(", ")", ";", "if", "(", "Offset", "<", "<NUM_LIT>", ")", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg", "(", "DstReg", ")", ".", "addImm", "(", "-", "Offset", ")", ";", "else", "BuildMI", "(", "MBB", ",", "std", "::", "next", "(", "II", ")", ",", "dl", ",", "TII", ".", "get", "(", "<STR_LIT>", "::", "<STR_LIT>", ")", ",", "DstReg", ")", ".", "addReg" ]

[ "$", "R1", ",", "mode", ":", "$", "BD2", ",", "cond4", ":", "$", "valid", ",", "cond4", ":", "$", "M3", ")", ",", "mnemonic", "#", "<STR_LIT>", ",", "[", "]", ">", "{" ]

[ "class", "CondStoreRSY", "<", "string", "mnemonic", ",", "bits", "<", "<NUM_LIT>", ">", "opcode", ",", "RegisterOperand", "cls", ",", "bits", "<", "<NUM_LIT>", ">", "bytes", ",", "AddressingMode", "mode", "=", "bdaddr20only", ">", ":", "InstRSYb", "<", "opcode", ",", "(", "outs", ")", ",", "(", "ins", "cls", ":" ]

[ "if", "(", "INT16_P", "(", "bytes", ")", ")", "emit_insn", "(", "gen_addsi3", "(", "final_src", ",", "src_reg", ",", "rounded_total", ")", ")", ";" ]

[ "src_reg", "=", "copy_addr_to_reg", "(", "XEXP", "(", "or", "ig_src", ",", "<NUM_LIT>", ")", ")", ";", "if", "(", "align", ">", "UNITS_PER_WORD", ")", "align", "=", "UNITS_PER_WORD", ";", "if", "(", "optimize_size", "||", "!", "constp", "||", "align", "!=", "UNITS_PER_WORD", ")", "{", "block_move_call", "(", "dst_reg", ",", "src_reg", ",", "bytes_rtx", ")", ";", "return", "<NUM_LIT>", ";", "}", "leftover", "=", "bytes", "%", "MAX_MOVE_BYTES", ";", "bytes", "-=", "leftover", ";", "if", "(", "bytes", ")", "{", "rtx_code_label", "*", "label", "=", "NULL", ";", "rtx", "final_src", "=", "NULL_RTX", ";", "rtx", "at_a_time", "=", "GEN_INT", "(", "MAX_MOVE_BYTES", ")", ";", "rtx", "rounded_total", "=", "GEN_INT", "(", "bytes", ")", ";", "rtx", "new", "_", "dst_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "rtx", "new", "_", "src_reg", "=", "gen_reg_rtx", "(", "SImode", ")", ";", "if", "(", "bytes", ">", "MAX_MOVE_BYTES", ")", "{", "final_src", "=", "gen_reg_rtx", "(", "Pmode", ")", ";" ]

[ ",", "stack_pointer_rtx", ",", "adjustment_rtx", ")", ")", ";" ]

[ "break", ";", "}", "else", "{", "int", "words", ";", "gcc_assert", "(", "GET_CODE", "(", "entry_parm", ")", "==", "REG", ")", ";", "if", "(", "GET_MODE", "(", "entry_parm", ")", "==", "BLKmode", ")", "words", "=", "(", "int_size_in_bytes", "(", "passed_type", ")", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "else", "words", "=", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "entry_parm", ")", ")", "+", "<NUM_LIT>", ")", "/", "<NUM_LIT>", ";", "regno", "=", "REGNO", "(", "entry_parm", ")", "+", "words", "-", "<NUM_LIT>", ";", "}", "}", "else", "{", "regno", "=", "GP_ARG_LAST", "+", "<NUM_LIT>", ";", "break", ";", "}", "}", "next_arg_reg", "=", "iq2000_function_arg", "(", "args_so_far", ",", "VOIDmode", ",", "void_type_node", ",", "true", ")", ";", "if", "(", "next_arg_reg", "!=", "<NUM_LIT>", "&&", "GET_CODE", "(", "next_arg_reg", ")", "==", "PARALLEL", ")", "{", "rtvec", "adjust", "=", "XVEC", "(", "next_arg_reg", ",", "<NUM_LIT>", ")", ";", "int", "num", "=", "GET_NUM_ELEM", "(", "adjust", ")", ";", "for", "(", "i", "=", "<NUM_LIT>", ";", "i", "<", "num", ";", "i", "++", ")", "{", "rtx", "pattern", ";", "pattern", "=", "RTVEC_ELT", "(", "adjust", ",", "i", ")", ";", "if", "(", "GET_CODE", "(", "pattern", ")", "!=", "SET", "||", "GET_CODE", "(", "SET_SRC", "(", "pattern", ")", ")", "!=", "ASHIFT", ")", "abort_with_insn", "(", "pattern", ",", "<STR_LIT>", "Insn is not a shift", "<STR_LIT>", ")", ";", "PUT_CODE", "(", "SET_SRC", "(", "pattern", ")", ",", "ASHIFTRT", ")", ";", "emit_insn", "(", "pattern", ")", ";", "}", "}", "tsize", "=", "compute_frame_size", "(", "get_frame_size", "(", ")", ")", ";", "if", "(", "store_args_on_stack", "&&", "(", "stdarg_p", "(", "fntype", ")", "||", "last_arg_is_vararg_marker", ")", ")", "{", "int", "offset", "=", "(", "regno", "-", "GP_ARG_FIRST", ")", "*", "UNITS_PER_WORD", ";", "rtx", "ptr", "=", "stack_pointer_rtx", ";", "for", "(", ";", "regno", "<=", "GP_ARG_LAST", ";", "regno", "++", ")", "{", "if", "(", "offset", "!=", "<NUM_LIT>", ")", "ptr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "offset", ")", ")", ";", "emit_move_insn", "(", "gen_rtx_MEM", "(", "gpr_mode", ",", "ptr", ")", ",", "gen_rtx_REG", "(", "gpr_mode", ",", "regno", ")", ")", ";", "offset", "+=", "GET_MODE_SIZE", "(", "gpr_mode", ")", ";", "}", "}", "if", "(", "tsize", ">", "<NUM_LIT>", ")", "{", "rtx", "tsize_rtx", "=", "GEN_INT", "(", "tsize", ")", ";", "rtx", "adjustment_rtx", ",", "dwarf_pattern", ";", "rtx_insn", "*", "insn", ";", "if", "(", "tsize", ">", "<NUM_LIT>", ")", "{", "adjustment_rtx", "=", "gen_rtx_REG", "(", "Pmode", ",", "IQ2000_TEMP1_REGNUM", ")", ";", "emit_move_insn", "(", "adjustment_rtx", ",", "tsize_rtx", ")", ";", "}", "else", "adjustment_rtx", "=", "tsize_rtx", ";", "insn", "=", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx" ]

[ "}" ]

[ "unsigned", "NewNumElts", "=", "(", "Ty", ".", "getNumElements", "(", ")", "+", "<NUM_LIT>", ")", "/", "Pieces", ";", "return", "std", "::", "make_pair", "(", "TypeIdx", ",", "LLT", "::", "scalarOrVector", "(", "NewNumElts", ",", "EltTy", ")", ")", ";", "}", ";" ]

[ "<FIXS>", "return", "getTargetMachine", "(", ")", ".", "getOptLevel", "(", ")", "!=", "<NUM_LIT>", ";", "<FIXE>" ]

[ "bool", "AArch64TargetLowering", "::", "shouldExpandAtomicCmpXchgInIR", "(", "AtomicCmpXchgInst", "*", "AI", ")", "const", "{", "<BUGS>", "return", "true", ";", "<BUGE>", "}", "Value", "*", "AArch64TargetLowering", "::", "emitLoadLinked", "(", "IRBuilder", ">", "&", "Builder", ",", "Value", "*", "Addr", "," ]

[ ")", "{" ]

[ "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", ")", "return", "false", ";", "if", "(", "VectorTy", "->", "isFPOrFPVectorTy", "(", ")", ")", "return", "false", ";", "if", "(", "!", "isa", "<", "ConstantInt", ">", "(", "Idx", ")", ")", "return", "false", ";", "assert", "(", "VectorTy", "->", "isVectorTy", "(", ")", "&&", "<STR_LIT>", "VectorTy is not a vector type", "<STR_LIT>", ")", ";", "unsigned", "BitWidth", "=", "VectorTy", "->", "getPrimitiveSizeInBits", "(", ")", ".", "getFixedSize", "(", ")", ";", "if", "(", "BitWidth", "==", "<NUM_LIT>", "||", "BitWidth", "==", "<NUM_LIT>" ]

[ ",", "load_mem", ")", ";" ]

[ "if", "(", "!", "insn", "||", "!", "INSN_P", "(", "insn", ")", ")", "return", "false", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "return", "false", ";", "return", "is_load_insn1", "(", "PATTERN", "(", "insn", ")" ]

[ "<FIXS>", "NewBase", "=", "Scratch", ";", "<FIXE>" ]

[ "NewBase", "=", "Regs", "[", "NumRegs", "-", "<NUM_LIT>", "]", ".", "first", ";", "else", "{", "<BUGS>", "NewBase", "=", "RS", "?", "RS", "->", "FindUnusedReg", "(", "&", "ARM", "::", "GPRRegClass", ")", ":", "(", "unsigned", ")", "ARM", "::", "R12", ";", "<BUGE>", "if", "(", "NewBase", "==", "<NUM_LIT>", ")", "return", "false", ";", "}" ]

[ "<FIXS>", "<FIXE>", "<FIXS>", ":", "AMDGPUMCCodeEmitter", "(", "mcii", ")", ",", "MRI", "(", "mri", ")", "{", "}", "<FIXE>" ]

[ "class", "R600MCCodeEmitter", ":", "public", "AMDGPUMCCodeEmitter", "{", "R600MCCodeEmitter", "(", "const", "R600MCCodeEmitter", "&", ")", "=", "delete", ";", "void", "operator", "=", "(", "const", "R600MCCodeEmitter", "&", ")", "=", "delete", ";", "<BUGS>", "const", "MCInstrInfo", "&", "MCII", ";", "<BUGE>", "const", "MCRegisterInfo", "&", "MRI", ";", "public", ":", "R600MCCodeEmitter", "(", "const", "MCInstrInfo", "&", "mcii", ",", "const", "MCRegisterInfo", "&", "mri", ")", "<BUGS>", ":", "MCII", "(", "mcii", ")", ",", "MRI", "(", "mri", ")", "{", "}", "<BUGE>", "void", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", "," ]

[ ":", "Inits", ")", "{" ]

[ "assert", "(", "MDT", ".", "dominates", "(", "&", "*", "To", ",", "&", "*", "From", ")", ")", ";", "auto", "interferes", "=", "[", "&", "MDT", ",", "From", ",", "To", "]", "(", "MachineInstr", "*", "&", "Clobber", ")", "->", "bool", "{", "const", "MachineBasicBlock", "*", "MBBFrom", "=", "From", "->", "getParent", "(", ")", ";", "const", "MachineBasicBlock", "*", "MBBTo", "=", "To", "->", "getParent", "(", ")", ";", "bool", "MayClobberFrom", "=", "isReachable", "(", "Clobber", ",", "&", "*", "From", ",", "MBBTo", ",", "MDT", ")", ";", "bool", "MayClobberTo", "=", "isReachable", "(", "Clobber", ",", "&", "*", "To", ",", "MBBTo", ",", "MDT", ")", ";", "if", "(", "!", "MayClobberFrom", "&&", "!", "MayClobberTo", ")", "return", "false", ";", "if", "(", "(", "MayClobberFrom", "&&", "!", "MayClobberTo", ")", "||", "(", "!", "MayClobberFrom", "&&", "MayClobberTo", ")", ")", "return", "true", ";", "return", "!", "(", "(", "MBBFrom", "==", "MBBTo", "&&", "MDT", ".", "dominates", "(", "Clobber", ",", "&", "*", "From", ")", "&&", "MDT", ".", "dominates", "(", "Clobber", ",", "&", "*", "To", ")", ")", "||", "MDT", ".", "properlyDominates", "(", "Clobber", "->", "getParent", "(", ")", ",", "MBBTo", ")", ")", ";", "}", ";", "return", "(", "llvm", "::", "any_of", "(", "Clobbers", ",", "interferes", ")", ")", "||", "(", "llvm", "::", "any_of", "(", "Inits", ",", "[", "&", "]", "(", "InitListMap", "::", "value_type", "&", "C", ")", "{", "return", "C", ".", "first", "!=", "Init", ".", "first", "&&", "llvm", "::", "any_of", "(", "C", ".", "second", ",", "interferes", ")", ";", "}", ")", ")", ";", "}", ";", "if", "(", "MDT", ".", "dominates", "(", "MI1", ",", "MI2", ")", ")", "{", "if", "(", "!", "interferes", "(", "MI2", ",", "MI1", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Erasing from ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI2", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "*", "MI2", ")", ";", "MergedInstrs", ".", "insert", "(", "MI2", ")", ";", "Changed", "=", "true", ";", "++", "I2", ";", "continue", ";", "}", "}", "else", "if", "(", "MDT", ".", "dominates", "(", "MI2", ",", "MI1", ")", ")", "{", "if", "(", "!", "interferes", "(", "MI1", ",", "MI2", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Erasing from ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI1", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "*", "MI1", ")", ";", "MergedInstrs", ".", "insert", "(", "MI1", ")", ";", "Changed", "=", "true", ";", "++", "I1", ";", "break", ";", "}", "}", "else", "{", "auto", "*", "MBB", "=", "MDT", ".", "findNearestCommonDominator", "(", "MI1", "->", "getParent", "(", ")", ",", "MI2", "->", "getParent", "(", ")", ")", ";", "if", "(", "!", "MBB", ")", "{", "++", "I2", ";", "continue", ";", "}", "MachineBasicBlock", "::", "iterator", "I", "=", "getFirstNonPrologue", "(", "MBB", ",", "TII", ")", ";", "if", "(", "!", "interferes", "(", "MI1", ",", "I", ")", "&&", "!", "interferes", "(", "MI2", ",", "I", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "<STR_LIT>", "Erasing from ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI1", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "*", "MI1", "<<", "<STR_LIT>", "and moving from ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "MI2", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", " to ", "<STR_LIT>", "<<", "printMBBReference", "(", "*", "I", "->", "getParent", "(", ")", ")", "<<", "<STR_LIT>", "<STR_LIT>", "<<", "*", "MI2", ")", ";", "I", "->", "getParent", "(", ")", "->", "splice", "(", "I", ",", "MI2", "->", "getParent", "(", ")", ",", "MI2", ")", ";", "MergedInstrs", ".", "insert", "(", "MI1", ")", ";", "Changed", "=", "true", ";", "++", "I1", ";", "break", ";", "}", "}", "++", "I2", ";", "}", "++", "I1", ";", "}", "}", "for", "(", "auto", "&", "Init" ]

[ "bool", "X86WinAllocaExpander", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "!", "MF", ".", "getInfo", "<", "X86MachineFunctionInfo", ">", "(", ")", "->", "hasWinAlloca", "(", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "TII", "=", "STI", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "STI", "->", "getRegisterInfo", "(", ")", ";", "StackPtr", "=", "TRI", "->", "getStackRegister", "(", ")", ";", "SlotSize", "=", "TRI", "->", "getSlotSize", "(", ")", ";", "StackProbeSize", "=", "<NUM_LIT>", ";", "if", "(", "MF", ".", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "<STR_LIT>", "stack-probe-size", "<STR_LIT>", ")", ")", "{", "MF", ".", "getFunction", "(", ")", ".", "getFnAttribute", "(", "<STR_LIT>", "stack-probe-size", "<STR_LIT>", ")", ".", "getValueAsString", "(", ")", ".", "getAsInteger", "(", "<NUM_LIT>", ",", "StackProbeSize", ")", ";", "}", "LoweringMap", "Lowerings", ";", "computeLowerings", "(", "MF", ",", "Lowerings", ")", ";", "for", "(", "auto", "&", "P", ":", "Lowerings", ")", "lower", "(", "P", ".", "first", ",", "P", ".", "second", ")", ";", "return", "true", ";", "}" ]

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

[ "llvm_unreachable", "(", "<STR_LIT>", "GENLower of sub is misused.", "<STR_LIT>", ")", ";" ]

[ "SDValue", "Tmp", "=", "b", ".", "XOR", "(", "A1", ",", "A2", ")", ";", "return", "b", ".", "IFH1", "(", "b", ".", "HiMask", "(", "<NUM_LIT>", ",", "<NUM_LIT>", ")", ",", "b", ".", "XOR", "(", "Tmp", ",", "b", ".", "SHL", "<", "<NUM_LIT>", ">", "(", "b", ".", "AND", "(", "b", ".", "NOT", "(", "A1", ")", ",", "A2", ")", ")", ")", ",", "Tmp", ")", ";", "}" ]