1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 3 2; RUN: opt -S -passes=instsimplify %s | FileCheck %s 3 4; Test that we're able to make use of assumes of fcmps with constants 5; that aren't 0/inf/smallest-normal. Range checks can exclude certain 6; classes. 7 8declare void @llvm.assume(i1 noundef) #0 9declare float @llvm.fabs.f32(float) #0 10 11; -------------------------------------------------------------------- 12; Test assume x < -1.0 with compares to 0 13; -------------------------------------------------------------------- 14 15define i1 @assume_olt_neg1__oeq_0(float %arg) { 16; CHECK-LABEL: define i1 @assume_olt_neg1__oeq_0( 17; CHECK-SAME: float [[ARG:%.*]]) { 18; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 19; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 20; CHECK-NEXT: ret i1 false 21; 22 %olt.neg1 = fcmp olt float %arg, -1.0 23 call void @llvm.assume(i1 %olt.neg1) 24 %cmp = fcmp oeq float %arg, 0.0 25 ret i1 %cmp 26} 27 28define i1 @assume_olt_neg1__ogt_0(float %arg) { 29; CHECK-LABEL: define i1 @assume_olt_neg1__ogt_0( 30; CHECK-SAME: float [[ARG:%.*]]) { 31; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 32; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 33; CHECK-NEXT: ret i1 false 34; 35 %olt.neg1 = fcmp olt float %arg, -1.0 36 call void @llvm.assume(i1 %olt.neg1) 37 %cmp = fcmp ogt float %arg, 0.0 38 ret i1 %cmp 39} 40 41define i1 @assume_olt_neg1__oge_0(float %arg) { 42; CHECK-LABEL: define i1 @assume_olt_neg1__oge_0( 43; CHECK-SAME: float [[ARG:%.*]]) { 44; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 45; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 46; CHECK-NEXT: ret i1 false 47; 48 %olt.neg1 = fcmp olt float %arg, -1.0 49 call void @llvm.assume(i1 %olt.neg1) 50 %cmp = fcmp oge float %arg, 0.0 51 ret i1 %cmp 52} 53 54define i1 @assume_olt_neg1__olt_0(float %arg) { 55; CHECK-LABEL: define i1 @assume_olt_neg1__olt_0( 56; CHECK-SAME: float [[ARG:%.*]]) { 57; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 58; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 59; CHECK-NEXT: ret i1 true 60; 61 %olt.neg1 = fcmp olt float %arg, -1.0 62 call void @llvm.assume(i1 %olt.neg1) 63 %cmp = fcmp olt float %arg, 0.0 64 ret i1 %cmp 65} 66 67define i1 @assume_olt_neg1__ole_0(float %arg) { 68; CHECK-LABEL: define i1 @assume_olt_neg1__ole_0( 69; CHECK-SAME: float [[ARG:%.*]]) { 70; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 71; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 72; CHECK-NEXT: ret i1 true 73; 74 %olt.neg1 = fcmp olt float %arg, -1.0 75 call void @llvm.assume(i1 %olt.neg1) 76 %cmp = fcmp ole float %arg, 0.0 77 ret i1 %cmp 78} 79 80define i1 @assume_olt_neg1__one_0(float %arg) { 81; CHECK-LABEL: define i1 @assume_olt_neg1__one_0( 82; CHECK-SAME: float [[ARG:%.*]]) { 83; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 84; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 85; CHECK-NEXT: ret i1 true 86; 87 %olt.neg1 = fcmp olt float %arg, -1.0 88 call void @llvm.assume(i1 %olt.neg1) 89 %cmp = fcmp one float %arg, 0.0 90 ret i1 %cmp 91} 92 93define i1 @assume_olt_neg1__ord_0(float %arg) { 94; CHECK-LABEL: define i1 @assume_olt_neg1__ord_0( 95; CHECK-SAME: float [[ARG:%.*]]) { 96; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 97; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 98; CHECK-NEXT: ret i1 true 99; 100 %olt.neg1 = fcmp olt float %arg, -1.0 101 call void @llvm.assume(i1 %olt.neg1) 102 %cmp = fcmp ord float %arg, 0.0 103 ret i1 %cmp 104} 105 106define i1 @assume_olt_neg1__ueq_0(float %arg) { 107; CHECK-LABEL: define i1 @assume_olt_neg1__ueq_0( 108; CHECK-SAME: float [[ARG:%.*]]) { 109; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 110; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 111; CHECK-NEXT: ret i1 false 112; 113 %olt.neg1 = fcmp olt float %arg, -1.0 114 call void @llvm.assume(i1 %olt.neg1) 115 %cmp = fcmp ueq float %arg, 0.0 116 ret i1 %cmp 117} 118 119define i1 @assume_olt_neg1__ugt_0(float %arg) { 120; CHECK-LABEL: define i1 @assume_olt_neg1__ugt_0( 121; CHECK-SAME: float [[ARG:%.*]]) { 122; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 123; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 124; CHECK-NEXT: ret i1 false 125; 126 %olt.neg1 = fcmp olt float %arg, -1.0 127 call void @llvm.assume(i1 %olt.neg1) 128 %cmp = fcmp ugt float %arg, 0.0 129 ret i1 %cmp 130} 131 132define i1 @assume_olt_neg1__uge_0(float %arg) { 133; CHECK-LABEL: define i1 @assume_olt_neg1__uge_0( 134; CHECK-SAME: float [[ARG:%.*]]) { 135; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 136; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 137; CHECK-NEXT: ret i1 false 138; 139 %olt.neg1 = fcmp olt float %arg, -1.0 140 call void @llvm.assume(i1 %olt.neg1) 141 %cmp = fcmp uge float %arg, 0.0 142 ret i1 %cmp 143} 144 145define i1 @assume_olt_neg1__ult_0(float %arg) { 146; CHECK-LABEL: define i1 @assume_olt_neg1__ult_0( 147; CHECK-SAME: float [[ARG:%.*]]) { 148; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 149; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 150; CHECK-NEXT: ret i1 true 151; 152 %olt.neg1 = fcmp olt float %arg, -1.0 153 call void @llvm.assume(i1 %olt.neg1) 154 %cmp = fcmp ult float %arg, 0.0 155 ret i1 %cmp 156} 157 158define i1 @assume_olt_neg1__ule_0(float %arg) { 159; CHECK-LABEL: define i1 @assume_olt_neg1__ule_0( 160; CHECK-SAME: float [[ARG:%.*]]) { 161; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 162; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 163; CHECK-NEXT: ret i1 true 164; 165 %olt.neg1 = fcmp olt float %arg, -1.0 166 call void @llvm.assume(i1 %olt.neg1) 167 %cmp = fcmp ule float %arg, 0.0 168 ret i1 %cmp 169} 170 171define i1 @assume_olt_neg1__une_0(float %arg) { 172; CHECK-LABEL: define i1 @assume_olt_neg1__une_0( 173; CHECK-SAME: float [[ARG:%.*]]) { 174; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 175; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 176; CHECK-NEXT: ret i1 true 177; 178 %olt.neg1 = fcmp olt float %arg, -1.0 179 call void @llvm.assume(i1 %olt.neg1) 180 %cmp = fcmp une float %arg, 0.0 181 ret i1 %cmp 182} 183 184define i1 @assume_olt_neg1__uno_0(float %arg) { 185; CHECK-LABEL: define i1 @assume_olt_neg1__uno_0( 186; CHECK-SAME: float [[ARG:%.*]]) { 187; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 188; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 189; CHECK-NEXT: ret i1 false 190; 191 %olt.neg1 = fcmp olt float %arg, -1.0 192 call void @llvm.assume(i1 %olt.neg1) 193 %cmp = fcmp uno float %arg, 0.0 194 ret i1 %cmp 195} 196 197; -------------------------------------------------------------------- 198; Test assume x <= -1.0 with compares to 0 199; -------------------------------------------------------------------- 200 201define i1 @assume_ole_neg1__oeq_0(float %arg) { 202; CHECK-LABEL: define i1 @assume_ole_neg1__oeq_0( 203; CHECK-SAME: float [[ARG:%.*]]) { 204; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 205; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 206; CHECK-NEXT: ret i1 false 207; 208 %ole.neg1 = fcmp ole float %arg, -1.0 209 call void @llvm.assume(i1 %ole.neg1) 210 %cmp = fcmp oeq float %arg, 0.0 211 ret i1 %cmp 212} 213 214define i1 @assume_ole_neg1__ogt_0(float %arg) { 215; CHECK-LABEL: define i1 @assume_ole_neg1__ogt_0( 216; CHECK-SAME: float [[ARG:%.*]]) { 217; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 218; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 219; CHECK-NEXT: ret i1 false 220; 221 %ole.neg1 = fcmp ole float %arg, -1.0 222 call void @llvm.assume(i1 %ole.neg1) 223 %cmp = fcmp ogt float %arg, 0.0 224 ret i1 %cmp 225} 226 227define i1 @assume_ole_neg1__oge_0(float %arg) { 228; CHECK-LABEL: define i1 @assume_ole_neg1__oge_0( 229; CHECK-SAME: float [[ARG:%.*]]) { 230; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 231; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 232; CHECK-NEXT: ret i1 false 233; 234 %ole.neg1 = fcmp ole float %arg, -1.0 235 call void @llvm.assume(i1 %ole.neg1) 236 %cmp = fcmp oge float %arg, 0.0 237 ret i1 %cmp 238} 239 240define i1 @assume_ole_neg1__olt_0(float %arg) { 241; CHECK-LABEL: define i1 @assume_ole_neg1__olt_0( 242; CHECK-SAME: float [[ARG:%.*]]) { 243; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 244; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 245; CHECK-NEXT: ret i1 true 246; 247 %ole.neg1 = fcmp ole float %arg, -1.0 248 call void @llvm.assume(i1 %ole.neg1) 249 %cmp = fcmp olt float %arg, 0.0 250 ret i1 %cmp 251} 252 253define i1 @assume_ole_neg1__ole_0(float %arg) { 254; CHECK-LABEL: define i1 @assume_ole_neg1__ole_0( 255; CHECK-SAME: float [[ARG:%.*]]) { 256; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 257; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 258; CHECK-NEXT: ret i1 true 259; 260 %ole.neg1 = fcmp ole float %arg, -1.0 261 call void @llvm.assume(i1 %ole.neg1) 262 %cmp = fcmp ole float %arg, 0.0 263 ret i1 %cmp 264} 265 266define i1 @assume_ole_neg1__one_0(float %arg) { 267; CHECK-LABEL: define i1 @assume_ole_neg1__one_0( 268; CHECK-SAME: float [[ARG:%.*]]) { 269; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 270; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 271; CHECK-NEXT: ret i1 true 272; 273 %ole.neg1 = fcmp ole float %arg, -1.0 274 call void @llvm.assume(i1 %ole.neg1) 275 %cmp = fcmp one float %arg, 0.0 276 ret i1 %cmp 277} 278 279define i1 @assume_ole_neg1__ord_0(float %arg) { 280; CHECK-LABEL: define i1 @assume_ole_neg1__ord_0( 281; CHECK-SAME: float [[ARG:%.*]]) { 282; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 283; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 284; CHECK-NEXT: ret i1 true 285; 286 %ole.neg1 = fcmp ole float %arg, -1.0 287 call void @llvm.assume(i1 %ole.neg1) 288 %cmp = fcmp ord float %arg, 0.0 289 ret i1 %cmp 290} 291 292define i1 @assume_ole_neg1__ueq_0(float %arg) { 293; CHECK-LABEL: define i1 @assume_ole_neg1__ueq_0( 294; CHECK-SAME: float [[ARG:%.*]]) { 295; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 296; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 297; CHECK-NEXT: ret i1 false 298; 299 %ole.neg1 = fcmp ole float %arg, -1.0 300 call void @llvm.assume(i1 %ole.neg1) 301 %cmp = fcmp ueq float %arg, 0.0 302 ret i1 %cmp 303} 304 305define i1 @assume_ole_neg1__ugt_0(float %arg) { 306; CHECK-LABEL: define i1 @assume_ole_neg1__ugt_0( 307; CHECK-SAME: float [[ARG:%.*]]) { 308; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 309; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 310; CHECK-NEXT: ret i1 false 311; 312 %ole.neg1 = fcmp ole float %arg, -1.0 313 call void @llvm.assume(i1 %ole.neg1) 314 %cmp = fcmp ugt float %arg, 0.0 315 ret i1 %cmp 316} 317 318define i1 @assume_ole_neg1__uge_0(float %arg) { 319; CHECK-LABEL: define i1 @assume_ole_neg1__uge_0( 320; CHECK-SAME: float [[ARG:%.*]]) { 321; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 322; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 323; CHECK-NEXT: ret i1 false 324; 325 %ole.neg1 = fcmp ole float %arg, -1.0 326 call void @llvm.assume(i1 %ole.neg1) 327 %cmp = fcmp uge float %arg, 0.0 328 ret i1 %cmp 329} 330 331define i1 @assume_ole_neg1__ult_0(float %arg) { 332; CHECK-LABEL: define i1 @assume_ole_neg1__ult_0( 333; CHECK-SAME: float [[ARG:%.*]]) { 334; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 335; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 336; CHECK-NEXT: ret i1 true 337; 338 %ole.neg1 = fcmp ole float %arg, -1.0 339 call void @llvm.assume(i1 %ole.neg1) 340 %cmp = fcmp ult float %arg, 0.0 341 ret i1 %cmp 342} 343 344define i1 @assume_ole_neg1__ule_0(float %arg) { 345; CHECK-LABEL: define i1 @assume_ole_neg1__ule_0( 346; CHECK-SAME: float [[ARG:%.*]]) { 347; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 348; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 349; CHECK-NEXT: ret i1 true 350; 351 %ole.neg1 = fcmp ole float %arg, -1.0 352 call void @llvm.assume(i1 %ole.neg1) 353 %cmp = fcmp ule float %arg, 0.0 354 ret i1 %cmp 355} 356 357define i1 @assume_ole_neg1__une_0(float %arg) { 358; CHECK-LABEL: define i1 @assume_ole_neg1__une_0( 359; CHECK-SAME: float [[ARG:%.*]]) { 360; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 361; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 362; CHECK-NEXT: ret i1 true 363; 364 %ole.neg1 = fcmp ole float %arg, -1.0 365 call void @llvm.assume(i1 %ole.neg1) 366 %cmp = fcmp une float %arg, 0.0 367 ret i1 %cmp 368} 369 370define i1 @assume_ole_neg1__uno_0(float %arg) { 371; CHECK-LABEL: define i1 @assume_ole_neg1__uno_0( 372; CHECK-SAME: float [[ARG:%.*]]) { 373; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+00 374; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_NEG1]]) 375; CHECK-NEXT: ret i1 false 376; 377 %ole.neg1 = fcmp ole float %arg, -1.0 378 call void @llvm.assume(i1 %ole.neg1) 379 %cmp = fcmp uno float %arg, 0.0 380 ret i1 %cmp 381} 382 383; -------------------------------------------------------------------- 384; Test assume x > -1.0 with compares to 0 385; -------------------------------------------------------------------- 386 387define i1 @assume_ogt_neg1__oeq_0(float %arg) { 388; CHECK-LABEL: define i1 @assume_ogt_neg1__oeq_0( 389; CHECK-SAME: float [[ARG:%.*]]) { 390; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 391; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 392; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 393; CHECK-NEXT: ret i1 [[CMP]] 394; 395 %ogt.neg1 = fcmp ogt float %arg, -1.0 396 call void @llvm.assume(i1 %ogt.neg1) 397 %cmp = fcmp oeq float %arg, 0.0 398 ret i1 %cmp 399} 400 401define i1 @assume_ogt_neg1__ogt_0(float %arg) { 402; CHECK-LABEL: define i1 @assume_ogt_neg1__ogt_0( 403; CHECK-SAME: float [[ARG:%.*]]) { 404; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 405; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 406; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 407; CHECK-NEXT: ret i1 [[CMP]] 408; 409 %ogt.neg1 = fcmp ogt float %arg, -1.0 410 call void @llvm.assume(i1 %ogt.neg1) 411 %cmp = fcmp ogt float %arg, 0.0 412 ret i1 %cmp 413} 414 415define i1 @assume_ogt_neg1__oge_0(float %arg) { 416; CHECK-LABEL: define i1 @assume_ogt_neg1__oge_0( 417; CHECK-SAME: float [[ARG:%.*]]) { 418; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 419; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 420; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 421; CHECK-NEXT: ret i1 [[CMP]] 422; 423 %ogt.neg1 = fcmp ogt float %arg, -1.0 424 call void @llvm.assume(i1 %ogt.neg1) 425 %cmp = fcmp oge float %arg, 0.0 426 ret i1 %cmp 427} 428 429define i1 @assume_ogt_neg1__olt_0(float %arg) { 430; CHECK-LABEL: define i1 @assume_ogt_neg1__olt_0( 431; CHECK-SAME: float [[ARG:%.*]]) { 432; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 433; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 434; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 435; CHECK-NEXT: ret i1 [[CMP]] 436; 437 %ogt.neg1 = fcmp ogt float %arg, -1.0 438 call void @llvm.assume(i1 %ogt.neg1) 439 %cmp = fcmp olt float %arg, 0.0 440 ret i1 %cmp 441} 442 443define i1 @assume_ogt_neg1__ole_0(float %arg) { 444; CHECK-LABEL: define i1 @assume_ogt_neg1__ole_0( 445; CHECK-SAME: float [[ARG:%.*]]) { 446; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 447; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 448; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 449; CHECK-NEXT: ret i1 [[CMP]] 450; 451 %ogt.neg1 = fcmp ogt float %arg, -1.0 452 call void @llvm.assume(i1 %ogt.neg1) 453 %cmp = fcmp ole float %arg, 0.0 454 ret i1 %cmp 455} 456 457define i1 @assume_ogt_neg1__one_0(float %arg) { 458; CHECK-LABEL: define i1 @assume_ogt_neg1__one_0( 459; CHECK-SAME: float [[ARG:%.*]]) { 460; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 461; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 462; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 463; CHECK-NEXT: ret i1 [[CMP]] 464; 465 %ogt.neg1 = fcmp ogt float %arg, -1.0 466 call void @llvm.assume(i1 %ogt.neg1) 467 %cmp = fcmp one float %arg, 0.0 468 ret i1 %cmp 469} 470 471define i1 @assume_ogt_neg1__ord_0(float %arg) { 472; CHECK-LABEL: define i1 @assume_ogt_neg1__ord_0( 473; CHECK-SAME: float [[ARG:%.*]]) { 474; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 475; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 476; CHECK-NEXT: ret i1 true 477; 478 %ogt.neg1 = fcmp ogt float %arg, -1.0 479 call void @llvm.assume(i1 %ogt.neg1) 480 %cmp = fcmp ord float %arg, 0.0 481 ret i1 %cmp 482} 483 484define i1 @assume_ogt_neg1__ueq_0(float %arg) { 485; CHECK-LABEL: define i1 @assume_ogt_neg1__ueq_0( 486; CHECK-SAME: float [[ARG:%.*]]) { 487; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 488; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 489; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 490; CHECK-NEXT: ret i1 [[CMP]] 491; 492 %ogt.neg1 = fcmp ogt float %arg, -1.0 493 call void @llvm.assume(i1 %ogt.neg1) 494 %cmp = fcmp ueq float %arg, 0.0 495 ret i1 %cmp 496} 497 498define i1 @assume_ogt_neg1__ugt_0(float %arg) { 499; CHECK-LABEL: define i1 @assume_ogt_neg1__ugt_0( 500; CHECK-SAME: float [[ARG:%.*]]) { 501; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 502; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 503; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 504; CHECK-NEXT: ret i1 [[CMP]] 505; 506 %ogt.neg1 = fcmp ogt float %arg, -1.0 507 call void @llvm.assume(i1 %ogt.neg1) 508 %cmp = fcmp ugt float %arg, 0.0 509 ret i1 %cmp 510} 511 512define i1 @assume_ogt_neg1__uge_0(float %arg) { 513; CHECK-LABEL: define i1 @assume_ogt_neg1__uge_0( 514; CHECK-SAME: float [[ARG:%.*]]) { 515; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 516; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 517; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 518; CHECK-NEXT: ret i1 [[CMP]] 519; 520 %ogt.neg1 = fcmp ogt float %arg, -1.0 521 call void @llvm.assume(i1 %ogt.neg1) 522 %cmp = fcmp uge float %arg, 0.0 523 ret i1 %cmp 524} 525 526define i1 @assume_ogt_neg1__ult_0(float %arg) { 527; CHECK-LABEL: define i1 @assume_ogt_neg1__ult_0( 528; CHECK-SAME: float [[ARG:%.*]]) { 529; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 530; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 531; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 532; CHECK-NEXT: ret i1 [[CMP]] 533; 534 %ogt.neg1 = fcmp ogt float %arg, -1.0 535 call void @llvm.assume(i1 %ogt.neg1) 536 %cmp = fcmp ult float %arg, 0.0 537 ret i1 %cmp 538} 539 540define i1 @assume_ogt_neg1__ule_0(float %arg) { 541; CHECK-LABEL: define i1 @assume_ogt_neg1__ule_0( 542; CHECK-SAME: float [[ARG:%.*]]) { 543; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 544; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 545; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 546; CHECK-NEXT: ret i1 [[CMP]] 547; 548 %ogt.neg1 = fcmp ogt float %arg, -1.0 549 call void @llvm.assume(i1 %ogt.neg1) 550 %cmp = fcmp ule float %arg, 0.0 551 ret i1 %cmp 552} 553 554define i1 @assume_ogt_neg1__une_0(float %arg) { 555; CHECK-LABEL: define i1 @assume_ogt_neg1__une_0( 556; CHECK-SAME: float [[ARG:%.*]]) { 557; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 558; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 559; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 560; CHECK-NEXT: ret i1 [[CMP]] 561; 562 %ogt.neg1 = fcmp ogt float %arg, -1.0 563 call void @llvm.assume(i1 %ogt.neg1) 564 %cmp = fcmp une float %arg, 0.0 565 ret i1 %cmp 566} 567 568define i1 @assume_ogt_neg1__uno_0(float %arg) { 569; CHECK-LABEL: define i1 @assume_ogt_neg1__uno_0( 570; CHECK-SAME: float [[ARG:%.*]]) { 571; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00 572; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_NEG1]]) 573; CHECK-NEXT: ret i1 false 574; 575 %ogt.neg1 = fcmp ogt float %arg, -1.0 576 call void @llvm.assume(i1 %ogt.neg1) 577 %cmp = fcmp uno float %arg, 0.0 578 ret i1 %cmp 579} 580 581; -------------------------------------------------------------------- 582; Test assume x >= -1.0 with compares to 0 583; -------------------------------------------------------------------- 584 585define i1 @assume_oge_neg1__oeq_0(float %arg) { 586; CHECK-LABEL: define i1 @assume_oge_neg1__oeq_0( 587; CHECK-SAME: float [[ARG:%.*]]) { 588; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 589; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 590; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 591; CHECK-NEXT: ret i1 [[CMP]] 592; 593 %oge.neg1 = fcmp oge float %arg, -1.0 594 call void @llvm.assume(i1 %oge.neg1) 595 %cmp = fcmp oeq float %arg, 0.0 596 ret i1 %cmp 597} 598 599define i1 @assume_oge_neg1__ogt_0(float %arg) { 600; CHECK-LABEL: define i1 @assume_oge_neg1__ogt_0( 601; CHECK-SAME: float [[ARG:%.*]]) { 602; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 603; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 604; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 605; CHECK-NEXT: ret i1 [[CMP]] 606; 607 %oge.neg1 = fcmp oge float %arg, -1.0 608 call void @llvm.assume(i1 %oge.neg1) 609 %cmp = fcmp ogt float %arg, 0.0 610 ret i1 %cmp 611} 612 613define i1 @assume_oge_neg1__oge_0(float %arg) { 614; CHECK-LABEL: define i1 @assume_oge_neg1__oge_0( 615; CHECK-SAME: float [[ARG:%.*]]) { 616; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 617; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 618; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 619; CHECK-NEXT: ret i1 [[CMP]] 620; 621 %oge.neg1 = fcmp oge float %arg, -1.0 622 call void @llvm.assume(i1 %oge.neg1) 623 %cmp = fcmp oge float %arg, 0.0 624 ret i1 %cmp 625} 626 627define i1 @assume_oge_neg1__olt_0(float %arg) { 628; CHECK-LABEL: define i1 @assume_oge_neg1__olt_0( 629; CHECK-SAME: float [[ARG:%.*]]) { 630; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 631; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 632; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 633; CHECK-NEXT: ret i1 [[CMP]] 634; 635 %oge.neg1 = fcmp oge float %arg, -1.0 636 call void @llvm.assume(i1 %oge.neg1) 637 %cmp = fcmp olt float %arg, 0.0 638 ret i1 %cmp 639} 640 641define i1 @assume_oge_neg1__ole_0(float %arg) { 642; CHECK-LABEL: define i1 @assume_oge_neg1__ole_0( 643; CHECK-SAME: float [[ARG:%.*]]) { 644; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 645; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 646; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 647; CHECK-NEXT: ret i1 [[CMP]] 648; 649 %oge.neg1 = fcmp oge float %arg, -1.0 650 call void @llvm.assume(i1 %oge.neg1) 651 %cmp = fcmp ole float %arg, 0.0 652 ret i1 %cmp 653} 654 655define i1 @assume_oge_neg1__one_0(float %arg) { 656; CHECK-LABEL: define i1 @assume_oge_neg1__one_0( 657; CHECK-SAME: float [[ARG:%.*]]) { 658; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 659; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 660; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 661; CHECK-NEXT: ret i1 [[CMP]] 662; 663 %oge.neg1 = fcmp oge float %arg, -1.0 664 call void @llvm.assume(i1 %oge.neg1) 665 %cmp = fcmp one float %arg, 0.0 666 ret i1 %cmp 667} 668 669define i1 @assume_oge_neg1__ord_0(float %arg) { 670; CHECK-LABEL: define i1 @assume_oge_neg1__ord_0( 671; CHECK-SAME: float [[ARG:%.*]]) { 672; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 673; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 674; CHECK-NEXT: ret i1 true 675; 676 %oge.neg1 = fcmp oge float %arg, -1.0 677 call void @llvm.assume(i1 %oge.neg1) 678 %cmp = fcmp ord float %arg, 0.0 679 ret i1 %cmp 680} 681 682define i1 @assume_oge_neg1__ueq_0(float %arg) { 683; CHECK-LABEL: define i1 @assume_oge_neg1__ueq_0( 684; CHECK-SAME: float [[ARG:%.*]]) { 685; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 686; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 687; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 688; CHECK-NEXT: ret i1 [[CMP]] 689; 690 %oge.neg1 = fcmp oge float %arg, -1.0 691 call void @llvm.assume(i1 %oge.neg1) 692 %cmp = fcmp ueq float %arg, 0.0 693 ret i1 %cmp 694} 695 696define i1 @assume_oge_neg1__ugt_0(float %arg) { 697; CHECK-LABEL: define i1 @assume_oge_neg1__ugt_0( 698; CHECK-SAME: float [[ARG:%.*]]) { 699; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 700; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 701; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 702; CHECK-NEXT: ret i1 [[CMP]] 703; 704 %oge.neg1 = fcmp oge float %arg, -1.0 705 call void @llvm.assume(i1 %oge.neg1) 706 %cmp = fcmp ugt float %arg, 0.0 707 ret i1 %cmp 708} 709 710define i1 @assume_oge_neg1__uge_0(float %arg) { 711; CHECK-LABEL: define i1 @assume_oge_neg1__uge_0( 712; CHECK-SAME: float [[ARG:%.*]]) { 713; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 714; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 715; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 716; CHECK-NEXT: ret i1 [[CMP]] 717; 718 %oge.neg1 = fcmp oge float %arg, -1.0 719 call void @llvm.assume(i1 %oge.neg1) 720 %cmp = fcmp uge float %arg, 0.0 721 ret i1 %cmp 722} 723 724define i1 @assume_oge_neg1__ult_0(float %arg) { 725; CHECK-LABEL: define i1 @assume_oge_neg1__ult_0( 726; CHECK-SAME: float [[ARG:%.*]]) { 727; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 728; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 729; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 730; CHECK-NEXT: ret i1 [[CMP]] 731; 732 %oge.neg1 = fcmp oge float %arg, -1.0 733 call void @llvm.assume(i1 %oge.neg1) 734 %cmp = fcmp ult float %arg, 0.0 735 ret i1 %cmp 736} 737 738define i1 @assume_oge_neg1__ule_0(float %arg) { 739; CHECK-LABEL: define i1 @assume_oge_neg1__ule_0( 740; CHECK-SAME: float [[ARG:%.*]]) { 741; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 742; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 743; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 744; CHECK-NEXT: ret i1 [[CMP]] 745; 746 %oge.neg1 = fcmp oge float %arg, -1.0 747 call void @llvm.assume(i1 %oge.neg1) 748 %cmp = fcmp ule float %arg, 0.0 749 ret i1 %cmp 750} 751 752define i1 @assume_oge_neg1__une_0(float %arg) { 753; CHECK-LABEL: define i1 @assume_oge_neg1__une_0( 754; CHECK-SAME: float [[ARG:%.*]]) { 755; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 756; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 757; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 758; CHECK-NEXT: ret i1 [[CMP]] 759; 760 %oge.neg1 = fcmp oge float %arg, -1.0 761 call void @llvm.assume(i1 %oge.neg1) 762 %cmp = fcmp une float %arg, 0.0 763 ret i1 %cmp 764} 765 766define i1 @assume_oge_neg1__uno_0(float %arg) { 767; CHECK-LABEL: define i1 @assume_oge_neg1__uno_0( 768; CHECK-SAME: float [[ARG:%.*]]) { 769; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00 770; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_NEG1]]) 771; CHECK-NEXT: ret i1 false 772; 773 %oge.neg1 = fcmp oge float %arg, -1.0 774 call void @llvm.assume(i1 %oge.neg1) 775 %cmp = fcmp uno float %arg, 0.0 776 ret i1 %cmp 777} 778 779; -------------------------------------------------------------------- 780; Test assume x u>= -1.0 with compares to 0 781; -------------------------------------------------------------------- 782 783define i1 @assume_uge_neg1__oeq_0(float %arg) { 784; CHECK-LABEL: define i1 @assume_uge_neg1__oeq_0( 785; CHECK-SAME: float [[ARG:%.*]]) { 786; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 787; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 788; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 789; CHECK-NEXT: ret i1 [[CMP]] 790; 791 %uge.neg1 = fcmp uge float %arg, -1.0 792 call void @llvm.assume(i1 %uge.neg1) 793 %cmp = fcmp oeq float %arg, 0.0 794 ret i1 %cmp 795} 796 797define i1 @assume_uge_neg1__ogt_0(float %arg) { 798; CHECK-LABEL: define i1 @assume_uge_neg1__ogt_0( 799; CHECK-SAME: float [[ARG:%.*]]) { 800; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 801; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 802; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 803; CHECK-NEXT: ret i1 [[CMP]] 804; 805 %uge.neg1 = fcmp uge float %arg, -1.0 806 call void @llvm.assume(i1 %uge.neg1) 807 %cmp = fcmp ogt float %arg, 0.0 808 ret i1 %cmp 809} 810 811define i1 @assume_uge_neg1__oge_0(float %arg) { 812; CHECK-LABEL: define i1 @assume_uge_neg1__oge_0( 813; CHECK-SAME: float [[ARG:%.*]]) { 814; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 815; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 816; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 817; CHECK-NEXT: ret i1 [[CMP]] 818; 819 %uge.neg1 = fcmp uge float %arg, -1.0 820 call void @llvm.assume(i1 %uge.neg1) 821 %cmp = fcmp oge float %arg, 0.0 822 ret i1 %cmp 823} 824 825define i1 @assume_uge_neg1__olt_0(float %arg) { 826; CHECK-LABEL: define i1 @assume_uge_neg1__olt_0( 827; CHECK-SAME: float [[ARG:%.*]]) { 828; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 829; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 830; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 831; CHECK-NEXT: ret i1 [[CMP]] 832; 833 %uge.neg1 = fcmp uge float %arg, -1.0 834 call void @llvm.assume(i1 %uge.neg1) 835 %cmp = fcmp olt float %arg, 0.0 836 ret i1 %cmp 837} 838 839define i1 @assume_uge_neg1__ole_0(float %arg) { 840; CHECK-LABEL: define i1 @assume_uge_neg1__ole_0( 841; CHECK-SAME: float [[ARG:%.*]]) { 842; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 843; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 844; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 845; CHECK-NEXT: ret i1 [[CMP]] 846; 847 %uge.neg1 = fcmp uge float %arg, -1.0 848 call void @llvm.assume(i1 %uge.neg1) 849 %cmp = fcmp ole float %arg, 0.0 850 ret i1 %cmp 851} 852 853define i1 @assume_uge_neg1__one_0(float %arg) { 854; CHECK-LABEL: define i1 @assume_uge_neg1__one_0( 855; CHECK-SAME: float [[ARG:%.*]]) { 856; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 857; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 858; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 859; CHECK-NEXT: ret i1 [[CMP]] 860; 861 %uge.neg1 = fcmp uge float %arg, -1.0 862 call void @llvm.assume(i1 %uge.neg1) 863 %cmp = fcmp one float %arg, 0.0 864 ret i1 %cmp 865} 866 867define i1 @assume_uge_neg1__ord_0(float %arg) { 868; CHECK-LABEL: define i1 @assume_uge_neg1__ord_0( 869; CHECK-SAME: float [[ARG:%.*]]) { 870; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 871; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 872; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 873; CHECK-NEXT: ret i1 [[CMP]] 874; 875 %uge.neg1 = fcmp uge float %arg, -1.0 876 call void @llvm.assume(i1 %uge.neg1) 877 %cmp = fcmp ord float %arg, 0.0 878 ret i1 %cmp 879} 880 881define i1 @assume_uge_neg1__ueq_0(float %arg) { 882; CHECK-LABEL: define i1 @assume_uge_neg1__ueq_0( 883; CHECK-SAME: float [[ARG:%.*]]) { 884; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 885; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 886; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 887; CHECK-NEXT: ret i1 [[CMP]] 888; 889 %uge.neg1 = fcmp uge float %arg, -1.0 890 call void @llvm.assume(i1 %uge.neg1) 891 %cmp = fcmp ueq float %arg, 0.0 892 ret i1 %cmp 893} 894 895define i1 @assume_uge_neg1__ugt_0(float %arg) { 896; CHECK-LABEL: define i1 @assume_uge_neg1__ugt_0( 897; CHECK-SAME: float [[ARG:%.*]]) { 898; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 899; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 900; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 901; CHECK-NEXT: ret i1 [[CMP]] 902; 903 %uge.neg1 = fcmp uge float %arg, -1.0 904 call void @llvm.assume(i1 %uge.neg1) 905 %cmp = fcmp ugt float %arg, 0.0 906 ret i1 %cmp 907} 908 909define i1 @assume_uge_neg1__uge_0(float %arg) { 910; CHECK-LABEL: define i1 @assume_uge_neg1__uge_0( 911; CHECK-SAME: float [[ARG:%.*]]) { 912; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 913; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 914; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 915; CHECK-NEXT: ret i1 [[CMP]] 916; 917 %uge.neg1 = fcmp uge float %arg, -1.0 918 call void @llvm.assume(i1 %uge.neg1) 919 %cmp = fcmp uge float %arg, 0.0 920 ret i1 %cmp 921} 922 923define i1 @assume_uge_neg1__ult_0(float %arg) { 924; CHECK-LABEL: define i1 @assume_uge_neg1__ult_0( 925; CHECK-SAME: float [[ARG:%.*]]) { 926; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 927; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 928; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 929; CHECK-NEXT: ret i1 [[CMP]] 930; 931 %uge.neg1 = fcmp uge float %arg, -1.0 932 call void @llvm.assume(i1 %uge.neg1) 933 %cmp = fcmp ult float %arg, 0.0 934 ret i1 %cmp 935} 936 937define i1 @assume_uge_neg1__ule_0(float %arg) { 938; CHECK-LABEL: define i1 @assume_uge_neg1__ule_0( 939; CHECK-SAME: float [[ARG:%.*]]) { 940; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 941; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 942; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 943; CHECK-NEXT: ret i1 [[CMP]] 944; 945 %uge.neg1 = fcmp uge float %arg, -1.0 946 call void @llvm.assume(i1 %uge.neg1) 947 %cmp = fcmp ule float %arg, 0.0 948 ret i1 %cmp 949} 950 951define i1 @assume_uge_neg1__une_0(float %arg) { 952; CHECK-LABEL: define i1 @assume_uge_neg1__une_0( 953; CHECK-SAME: float [[ARG:%.*]]) { 954; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 955; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 956; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 957; CHECK-NEXT: ret i1 [[CMP]] 958; 959 %uge.neg1 = fcmp uge float %arg, -1.0 960 call void @llvm.assume(i1 %uge.neg1) 961 %cmp = fcmp une float %arg, 0.0 962 ret i1 %cmp 963} 964 965define i1 @assume_uge_neg1__uno_0(float %arg) { 966; CHECK-LABEL: define i1 @assume_uge_neg1__uno_0( 967; CHECK-SAME: float [[ARG:%.*]]) { 968; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00 969; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_NEG1]]) 970; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 971; CHECK-NEXT: ret i1 [[CMP]] 972; 973 %uge.neg1 = fcmp uge float %arg, -1.0 974 call void @llvm.assume(i1 %uge.neg1) 975 %cmp = fcmp uno float %arg, 0.0 976 ret i1 %cmp 977} 978 979; -------------------------------------------------------------------- 980; Test assume x u> -1.0 with compares to 0 981; -------------------------------------------------------------------- 982 983define i1 @assume_ugt_neg1__oeq_0(float %arg) { 984; CHECK-LABEL: define i1 @assume_ugt_neg1__oeq_0( 985; CHECK-SAME: float [[ARG:%.*]]) { 986; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 987; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 988; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 989; CHECK-NEXT: ret i1 [[CMP]] 990; 991 %ugt.neg1 = fcmp ugt float %arg, -1.0 992 call void @llvm.assume(i1 %ugt.neg1) 993 %cmp = fcmp oeq float %arg, 0.0 994 ret i1 %cmp 995} 996 997define i1 @assume_ugt_neg1__ogt_0(float %arg) { 998; CHECK-LABEL: define i1 @assume_ugt_neg1__ogt_0( 999; CHECK-SAME: float [[ARG:%.*]]) { 1000; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1001; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1002; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 1003; CHECK-NEXT: ret i1 [[CMP]] 1004; 1005 %ugt.neg1 = fcmp ugt float %arg, -1.0 1006 call void @llvm.assume(i1 %ugt.neg1) 1007 %cmp = fcmp ogt float %arg, 0.0 1008 ret i1 %cmp 1009} 1010 1011define i1 @assume_ugt_neg1__oge_0(float %arg) { 1012; CHECK-LABEL: define i1 @assume_ugt_neg1__oge_0( 1013; CHECK-SAME: float [[ARG:%.*]]) { 1014; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1015; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1016; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 1017; CHECK-NEXT: ret i1 [[CMP]] 1018; 1019 %ugt.neg1 = fcmp ugt float %arg, -1.0 1020 call void @llvm.assume(i1 %ugt.neg1) 1021 %cmp = fcmp oge float %arg, 0.0 1022 ret i1 %cmp 1023} 1024 1025define i1 @assume_ugt_neg1__olt_0(float %arg) { 1026; CHECK-LABEL: define i1 @assume_ugt_neg1__olt_0( 1027; CHECK-SAME: float [[ARG:%.*]]) { 1028; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1029; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1030; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 1031; CHECK-NEXT: ret i1 [[CMP]] 1032; 1033 %ugt.neg1 = fcmp ugt float %arg, -1.0 1034 call void @llvm.assume(i1 %ugt.neg1) 1035 %cmp = fcmp olt float %arg, 0.0 1036 ret i1 %cmp 1037} 1038 1039define i1 @assume_ugt_neg1__ole_0(float %arg) { 1040; CHECK-LABEL: define i1 @assume_ugt_neg1__ole_0( 1041; CHECK-SAME: float [[ARG:%.*]]) { 1042; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1043; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1044; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 1045; CHECK-NEXT: ret i1 [[CMP]] 1046; 1047 %ugt.neg1 = fcmp ugt float %arg, -1.0 1048 call void @llvm.assume(i1 %ugt.neg1) 1049 %cmp = fcmp ole float %arg, 0.0 1050 ret i1 %cmp 1051} 1052 1053define i1 @assume_ugt_neg1__one_0(float %arg) { 1054; CHECK-LABEL: define i1 @assume_ugt_neg1__one_0( 1055; CHECK-SAME: float [[ARG:%.*]]) { 1056; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1057; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1058; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1059; CHECK-NEXT: ret i1 [[CMP]] 1060; 1061 %ugt.neg1 = fcmp ugt float %arg, -1.0 1062 call void @llvm.assume(i1 %ugt.neg1) 1063 %cmp = fcmp one float %arg, 0.0 1064 ret i1 %cmp 1065} 1066 1067define i1 @assume_ugt_neg1__ord_0(float %arg) { 1068; CHECK-LABEL: define i1 @assume_ugt_neg1__ord_0( 1069; CHECK-SAME: float [[ARG:%.*]]) { 1070; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1071; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1072; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 1073; CHECK-NEXT: ret i1 [[CMP]] 1074; 1075 %ugt.neg1 = fcmp ugt float %arg, -1.0 1076 call void @llvm.assume(i1 %ugt.neg1) 1077 %cmp = fcmp ord float %arg, 0.0 1078 ret i1 %cmp 1079} 1080 1081define i1 @assume_ugt_neg1__ueq_0(float %arg) { 1082; CHECK-LABEL: define i1 @assume_ugt_neg1__ueq_0( 1083; CHECK-SAME: float [[ARG:%.*]]) { 1084; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1085; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1086; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1087; CHECK-NEXT: ret i1 [[CMP]] 1088; 1089 %ugt.neg1 = fcmp ugt float %arg, -1.0 1090 call void @llvm.assume(i1 %ugt.neg1) 1091 %cmp = fcmp ueq float %arg, 0.0 1092 ret i1 %cmp 1093} 1094 1095define i1 @assume_ugt_neg1__ugt_0(float %arg) { 1096; CHECK-LABEL: define i1 @assume_ugt_neg1__ugt_0( 1097; CHECK-SAME: float [[ARG:%.*]]) { 1098; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1099; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1100; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 1101; CHECK-NEXT: ret i1 [[CMP]] 1102; 1103 %ugt.neg1 = fcmp ugt float %arg, -1.0 1104 call void @llvm.assume(i1 %ugt.neg1) 1105 %cmp = fcmp ugt float %arg, 0.0 1106 ret i1 %cmp 1107} 1108 1109define i1 @assume_ugt_neg1__uge_0(float %arg) { 1110; CHECK-LABEL: define i1 @assume_ugt_neg1__uge_0( 1111; CHECK-SAME: float [[ARG:%.*]]) { 1112; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1113; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1114; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 1115; CHECK-NEXT: ret i1 [[CMP]] 1116; 1117 %ugt.neg1 = fcmp ugt float %arg, -1.0 1118 call void @llvm.assume(i1 %ugt.neg1) 1119 %cmp = fcmp uge float %arg, 0.0 1120 ret i1 %cmp 1121} 1122 1123define i1 @assume_ugt_neg1__ult_0(float %arg) { 1124; CHECK-LABEL: define i1 @assume_ugt_neg1__ult_0( 1125; CHECK-SAME: float [[ARG:%.*]]) { 1126; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1127; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1128; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 1129; CHECK-NEXT: ret i1 [[CMP]] 1130; 1131 %ugt.neg1 = fcmp ugt float %arg, -1.0 1132 call void @llvm.assume(i1 %ugt.neg1) 1133 %cmp = fcmp ult float %arg, 0.0 1134 ret i1 %cmp 1135} 1136 1137define i1 @assume_ugt_neg1__ule_0(float %arg) { 1138; CHECK-LABEL: define i1 @assume_ugt_neg1__ule_0( 1139; CHECK-SAME: float [[ARG:%.*]]) { 1140; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1141; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1142; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 1143; CHECK-NEXT: ret i1 [[CMP]] 1144; 1145 %ugt.neg1 = fcmp ugt float %arg, -1.0 1146 call void @llvm.assume(i1 %ugt.neg1) 1147 %cmp = fcmp ule float %arg, 0.0 1148 ret i1 %cmp 1149} 1150 1151define i1 @assume_ugt_neg1__une_0(float %arg) { 1152; CHECK-LABEL: define i1 @assume_ugt_neg1__une_0( 1153; CHECK-SAME: float [[ARG:%.*]]) { 1154; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1155; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1156; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 1157; CHECK-NEXT: ret i1 [[CMP]] 1158; 1159 %ugt.neg1 = fcmp ugt float %arg, -1.0 1160 call void @llvm.assume(i1 %ugt.neg1) 1161 %cmp = fcmp une float %arg, 0.0 1162 ret i1 %cmp 1163} 1164 1165define i1 @assume_ugt_neg1__uno_0(float %arg) { 1166; CHECK-LABEL: define i1 @assume_ugt_neg1__uno_0( 1167; CHECK-SAME: float [[ARG:%.*]]) { 1168; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00 1169; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_NEG1]]) 1170; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 1171; CHECK-NEXT: ret i1 [[CMP]] 1172; 1173 %ugt.neg1 = fcmp ugt float %arg, -1.0 1174 call void @llvm.assume(i1 %ugt.neg1) 1175 %cmp = fcmp uno float %arg, 0.0 1176 ret i1 %cmp 1177} 1178 1179; -------------------------------------------------------------------- 1180; Test assume x u<= -1.0 with compares to 0 1181; -------------------------------------------------------------------- 1182 1183define i1 @assume_ule_neg1__oeq_0(float %arg) { 1184; CHECK-LABEL: define i1 @assume_ule_neg1__oeq_0( 1185; CHECK-SAME: float [[ARG:%.*]]) { 1186; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1187; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1188; CHECK-NEXT: ret i1 false 1189; 1190 %ule.neg1 = fcmp ule float %arg, -1.0 1191 call void @llvm.assume(i1 %ule.neg1) 1192 %cmp = fcmp oeq float %arg, 0.0 1193 ret i1 %cmp 1194} 1195 1196define i1 @assume_ule_neg1__ogt_0(float %arg) { 1197; CHECK-LABEL: define i1 @assume_ule_neg1__ogt_0( 1198; CHECK-SAME: float [[ARG:%.*]]) { 1199; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1200; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1201; CHECK-NEXT: ret i1 false 1202; 1203 %ule.neg1 = fcmp ule float %arg, -1.0 1204 call void @llvm.assume(i1 %ule.neg1) 1205 %cmp = fcmp ogt float %arg, 0.0 1206 ret i1 %cmp 1207} 1208 1209define i1 @assume_ule_neg1__oge_0(float %arg) { 1210; CHECK-LABEL: define i1 @assume_ule_neg1__oge_0( 1211; CHECK-SAME: float [[ARG:%.*]]) { 1212; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1213; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1214; CHECK-NEXT: ret i1 false 1215; 1216 %ule.neg1 = fcmp ule float %arg, -1.0 1217 call void @llvm.assume(i1 %ule.neg1) 1218 %cmp = fcmp oge float %arg, 0.0 1219 ret i1 %cmp 1220} 1221 1222define i1 @assume_ule_neg1__olt_0(float %arg) { 1223; CHECK-LABEL: define i1 @assume_ule_neg1__olt_0( 1224; CHECK-SAME: float [[ARG:%.*]]) { 1225; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1226; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1227; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 1228; CHECK-NEXT: ret i1 [[CMP]] 1229; 1230 %ule.neg1 = fcmp ule float %arg, -1.0 1231 call void @llvm.assume(i1 %ule.neg1) 1232 %cmp = fcmp olt float %arg, 0.0 1233 ret i1 %cmp 1234} 1235 1236define i1 @assume_ule_neg1__ole_0(float %arg) { 1237; CHECK-LABEL: define i1 @assume_ule_neg1__ole_0( 1238; CHECK-SAME: float [[ARG:%.*]]) { 1239; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1240; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1241; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 1242; CHECK-NEXT: ret i1 [[CMP]] 1243; 1244 %ule.neg1 = fcmp ule float %arg, -1.0 1245 call void @llvm.assume(i1 %ule.neg1) 1246 %cmp = fcmp ole float %arg, 0.0 1247 ret i1 %cmp 1248} 1249 1250define i1 @assume_ule_neg1__one_0(float %arg) { 1251; CHECK-LABEL: define i1 @assume_ule_neg1__one_0( 1252; CHECK-SAME: float [[ARG:%.*]]) { 1253; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1254; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1255; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1256; CHECK-NEXT: ret i1 [[CMP]] 1257; 1258 %ule.neg1 = fcmp ule float %arg, -1.0 1259 call void @llvm.assume(i1 %ule.neg1) 1260 %cmp = fcmp one float %arg, 0.0 1261 ret i1 %cmp 1262} 1263 1264define i1 @assume_ule_neg1__ord_0(float %arg) { 1265; CHECK-LABEL: define i1 @assume_ule_neg1__ord_0( 1266; CHECK-SAME: float [[ARG:%.*]]) { 1267; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1268; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1269; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 1270; CHECK-NEXT: ret i1 [[CMP]] 1271; 1272 %ule.neg1 = fcmp ule float %arg, -1.0 1273 call void @llvm.assume(i1 %ule.neg1) 1274 %cmp = fcmp ord float %arg, 0.0 1275 ret i1 %cmp 1276} 1277 1278define i1 @assume_ule_neg1__ueq_0(float %arg) { 1279; CHECK-LABEL: define i1 @assume_ule_neg1__ueq_0( 1280; CHECK-SAME: float [[ARG:%.*]]) { 1281; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1282; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1283; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1284; CHECK-NEXT: ret i1 [[CMP]] 1285; 1286 %ule.neg1 = fcmp ule float %arg, -1.0 1287 call void @llvm.assume(i1 %ule.neg1) 1288 %cmp = fcmp ueq float %arg, 0.0 1289 ret i1 %cmp 1290} 1291 1292define i1 @assume_ule_neg1__ugt_0(float %arg) { 1293; CHECK-LABEL: define i1 @assume_ule_neg1__ugt_0( 1294; CHECK-SAME: float [[ARG:%.*]]) { 1295; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1296; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1297; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 1298; CHECK-NEXT: ret i1 [[CMP]] 1299; 1300 %ule.neg1 = fcmp ule float %arg, -1.0 1301 call void @llvm.assume(i1 %ule.neg1) 1302 %cmp = fcmp ugt float %arg, 0.0 1303 ret i1 %cmp 1304} 1305 1306define i1 @assume_ule_neg1__uge_0(float %arg) { 1307; CHECK-LABEL: define i1 @assume_ule_neg1__uge_0( 1308; CHECK-SAME: float [[ARG:%.*]]) { 1309; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1310; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1311; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 1312; CHECK-NEXT: ret i1 [[CMP]] 1313; 1314 %ule.neg1 = fcmp ule float %arg, -1.0 1315 call void @llvm.assume(i1 %ule.neg1) 1316 %cmp = fcmp uge float %arg, 0.0 1317 ret i1 %cmp 1318} 1319 1320define i1 @assume_ule_neg1__ult_0(float %arg) { 1321; CHECK-LABEL: define i1 @assume_ule_neg1__ult_0( 1322; CHECK-SAME: float [[ARG:%.*]]) { 1323; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1324; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1325; CHECK-NEXT: ret i1 true 1326; 1327 %ule.neg1 = fcmp ule float %arg, -1.0 1328 call void @llvm.assume(i1 %ule.neg1) 1329 %cmp = fcmp ult float %arg, 0.0 1330 ret i1 %cmp 1331} 1332 1333define i1 @assume_ule_neg1__ule_0(float %arg) { 1334; CHECK-LABEL: define i1 @assume_ule_neg1__ule_0( 1335; CHECK-SAME: float [[ARG:%.*]]) { 1336; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1337; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1338; CHECK-NEXT: ret i1 true 1339; 1340 %ule.neg1 = fcmp ule float %arg, -1.0 1341 call void @llvm.assume(i1 %ule.neg1) 1342 %cmp = fcmp ule float %arg, 0.0 1343 ret i1 %cmp 1344} 1345 1346define i1 @assume_ule_neg1__une_0(float %arg) { 1347; CHECK-LABEL: define i1 @assume_ule_neg1__une_0( 1348; CHECK-SAME: float [[ARG:%.*]]) { 1349; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1350; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1351; CHECK-NEXT: ret i1 true 1352; 1353 %ule.neg1 = fcmp ule float %arg, -1.0 1354 call void @llvm.assume(i1 %ule.neg1) 1355 %cmp = fcmp une float %arg, 0.0 1356 ret i1 %cmp 1357} 1358 1359define i1 @assume_ule_neg1__uno_0(float %arg) { 1360; CHECK-LABEL: define i1 @assume_ule_neg1__uno_0( 1361; CHECK-SAME: float [[ARG:%.*]]) { 1362; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+00 1363; CHECK-NEXT: call void @llvm.assume(i1 [[ULE_NEG1]]) 1364; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 1365; CHECK-NEXT: ret i1 [[CMP]] 1366; 1367 %ule.neg1 = fcmp ule float %arg, -1.0 1368 call void @llvm.assume(i1 %ule.neg1) 1369 %cmp = fcmp uno float %arg, 0.0 1370 ret i1 %cmp 1371} 1372 1373; -------------------------------------------------------------------- 1374; Test assume x u< -1.0 with compares to 0 1375; -------------------------------------------------------------------- 1376 1377define i1 @assume_ult_neg1__oeq_0(float %arg) { 1378; CHECK-LABEL: define i1 @assume_ult_neg1__oeq_0( 1379; CHECK-SAME: float [[ARG:%.*]]) { 1380; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1381; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1382; CHECK-NEXT: ret i1 false 1383; 1384 %ult.neg1 = fcmp ult float %arg, -1.0 1385 call void @llvm.assume(i1 %ult.neg1) 1386 %cmp = fcmp oeq float %arg, 0.0 1387 ret i1 %cmp 1388} 1389 1390define i1 @assume_ult_neg1__ogt_0(float %arg) { 1391; CHECK-LABEL: define i1 @assume_ult_neg1__ogt_0( 1392; CHECK-SAME: float [[ARG:%.*]]) { 1393; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1394; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1395; CHECK-NEXT: ret i1 false 1396; 1397 %ult.neg1 = fcmp ult float %arg, -1.0 1398 call void @llvm.assume(i1 %ult.neg1) 1399 %cmp = fcmp ogt float %arg, 0.0 1400 ret i1 %cmp 1401} 1402 1403define i1 @assume_ult_neg1__oge_0(float %arg) { 1404; CHECK-LABEL: define i1 @assume_ult_neg1__oge_0( 1405; CHECK-SAME: float [[ARG:%.*]]) { 1406; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1407; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1408; CHECK-NEXT: ret i1 false 1409; 1410 %ult.neg1 = fcmp ult float %arg, -1.0 1411 call void @llvm.assume(i1 %ult.neg1) 1412 %cmp = fcmp oge float %arg, 0.0 1413 ret i1 %cmp 1414} 1415 1416define i1 @assume_ult_neg1__olt_0(float %arg) { 1417; CHECK-LABEL: define i1 @assume_ult_neg1__olt_0( 1418; CHECK-SAME: float [[ARG:%.*]]) { 1419; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1420; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1421; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 1422; CHECK-NEXT: ret i1 [[CMP]] 1423; 1424 %ult.neg1 = fcmp ult float %arg, -1.0 1425 call void @llvm.assume(i1 %ult.neg1) 1426 %cmp = fcmp olt float %arg, 0.0 1427 ret i1 %cmp 1428} 1429 1430define i1 @assume_ult_neg1__ole_0(float %arg) { 1431; CHECK-LABEL: define i1 @assume_ult_neg1__ole_0( 1432; CHECK-SAME: float [[ARG:%.*]]) { 1433; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1434; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1435; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 1436; CHECK-NEXT: ret i1 [[CMP]] 1437; 1438 %ult.neg1 = fcmp ult float %arg, -1.0 1439 call void @llvm.assume(i1 %ult.neg1) 1440 %cmp = fcmp ole float %arg, 0.0 1441 ret i1 %cmp 1442} 1443 1444define i1 @assume_ult_neg1__one_0(float %arg) { 1445; CHECK-LABEL: define i1 @assume_ult_neg1__one_0( 1446; CHECK-SAME: float [[ARG:%.*]]) { 1447; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1448; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1449; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1450; CHECK-NEXT: ret i1 [[CMP]] 1451; 1452 %ult.neg1 = fcmp ult float %arg, -1.0 1453 call void @llvm.assume(i1 %ult.neg1) 1454 %cmp = fcmp one float %arg, 0.0 1455 ret i1 %cmp 1456} 1457 1458define i1 @assume_ult_neg1__ord_0(float %arg) { 1459; CHECK-LABEL: define i1 @assume_ult_neg1__ord_0( 1460; CHECK-SAME: float [[ARG:%.*]]) { 1461; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1462; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1463; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 1464; CHECK-NEXT: ret i1 [[CMP]] 1465; 1466 %ult.neg1 = fcmp ult float %arg, -1.0 1467 call void @llvm.assume(i1 %ult.neg1) 1468 %cmp = fcmp ord float %arg, 0.0 1469 ret i1 %cmp 1470} 1471 1472define i1 @assume_ult_neg1__ueq_0(float %arg) { 1473; CHECK-LABEL: define i1 @assume_ult_neg1__ueq_0( 1474; CHECK-SAME: float [[ARG:%.*]]) { 1475; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1476; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1477; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1478; CHECK-NEXT: ret i1 [[CMP]] 1479; 1480 %ult.neg1 = fcmp ult float %arg, -1.0 1481 call void @llvm.assume(i1 %ult.neg1) 1482 %cmp = fcmp ueq float %arg, 0.0 1483 ret i1 %cmp 1484} 1485 1486define i1 @assume_ult_neg1__ugt_0(float %arg) { 1487; CHECK-LABEL: define i1 @assume_ult_neg1__ugt_0( 1488; CHECK-SAME: float [[ARG:%.*]]) { 1489; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1490; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1491; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 1492; CHECK-NEXT: ret i1 [[CMP]] 1493; 1494 %ult.neg1 = fcmp ult float %arg, -1.0 1495 call void @llvm.assume(i1 %ult.neg1) 1496 %cmp = fcmp ugt float %arg, 0.0 1497 ret i1 %cmp 1498} 1499 1500define i1 @assume_ult_neg1__uge_0(float %arg) { 1501; CHECK-LABEL: define i1 @assume_ult_neg1__uge_0( 1502; CHECK-SAME: float [[ARG:%.*]]) { 1503; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1504; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1505; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 1506; CHECK-NEXT: ret i1 [[CMP]] 1507; 1508 %ult.neg1 = fcmp ult float %arg, -1.0 1509 call void @llvm.assume(i1 %ult.neg1) 1510 %cmp = fcmp uge float %arg, 0.0 1511 ret i1 %cmp 1512} 1513 1514define i1 @assume_ult_neg1__ult_0(float %arg) { 1515; CHECK-LABEL: define i1 @assume_ult_neg1__ult_0( 1516; CHECK-SAME: float [[ARG:%.*]]) { 1517; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1518; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1519; CHECK-NEXT: ret i1 true 1520; 1521 %ult.neg1 = fcmp ult float %arg, -1.0 1522 call void @llvm.assume(i1 %ult.neg1) 1523 %cmp = fcmp ult float %arg, 0.0 1524 ret i1 %cmp 1525} 1526 1527define i1 @assume_ult_neg1__ule_0(float %arg) { 1528; CHECK-LABEL: define i1 @assume_ult_neg1__ule_0( 1529; CHECK-SAME: float [[ARG:%.*]]) { 1530; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1531; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1532; CHECK-NEXT: ret i1 true 1533; 1534 %ult.neg1 = fcmp ult float %arg, -1.0 1535 call void @llvm.assume(i1 %ult.neg1) 1536 %cmp = fcmp ule float %arg, 0.0 1537 ret i1 %cmp 1538} 1539 1540define i1 @assume_ult_neg1__une_0(float %arg) { 1541; CHECK-LABEL: define i1 @assume_ult_neg1__une_0( 1542; CHECK-SAME: float [[ARG:%.*]]) { 1543; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1544; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1545; CHECK-NEXT: ret i1 true 1546; 1547 %ult.neg1 = fcmp ult float %arg, -1.0 1548 call void @llvm.assume(i1 %ult.neg1) 1549 %cmp = fcmp une float %arg, 0.0 1550 ret i1 %cmp 1551} 1552 1553define i1 @assume_ult_neg1__uno_0(float %arg) { 1554; CHECK-LABEL: define i1 @assume_ult_neg1__uno_0( 1555; CHECK-SAME: float [[ARG:%.*]]) { 1556; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00 1557; CHECK-NEXT: call void @llvm.assume(i1 [[ULT_NEG1]]) 1558; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 1559; CHECK-NEXT: ret i1 [[CMP]] 1560; 1561 %ult.neg1 = fcmp ult float %arg, -1.0 1562 call void @llvm.assume(i1 %ult.neg1) 1563 %cmp = fcmp uno float %arg, 0.0 1564 ret i1 %cmp 1565} 1566 1567; -------------------------------------------------------------------- 1568; Test assume x == 0 with compares to 0 1569; -------------------------------------------------------------------- 1570 1571define i1 @assume_oeq_0__oeq_0(float %arg) { 1572; CHECK-LABEL: define i1 @assume_oeq_0__oeq_0( 1573; CHECK-SAME: float [[ARG:%.*]]) { 1574; CHECK-NEXT: [[OEQ_0:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 1575; CHECK-NEXT: call void @llvm.assume(i1 [[OEQ_0]]) 1576; CHECK-NEXT: ret i1 true 1577; 1578 %oeq.0 = fcmp oeq float %arg, 0.0 1579 call void @llvm.assume(i1 %oeq.0) 1580 %cmp = fcmp oeq float %arg, 0.0 1581 ret i1 %cmp 1582} 1583 1584define i1 @assume_oeq_0__ueq_0(float %arg) { 1585; CHECK-LABEL: define i1 @assume_oeq_0__ueq_0( 1586; CHECK-SAME: float [[ARG:%.*]]) { 1587; CHECK-NEXT: [[OEQ_0:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 1588; CHECK-NEXT: call void @llvm.assume(i1 [[OEQ_0]]) 1589; CHECK-NEXT: ret i1 true 1590; 1591 %oeq.0 = fcmp oeq float %arg, 0.0 1592 call void @llvm.assume(i1 %oeq.0) 1593 %cmp = fcmp ueq float %arg, 0.0 1594 ret i1 %cmp 1595} 1596 1597define i1 @assume_one_0__oeq_0(float %arg) { 1598; CHECK-LABEL: define i1 @assume_one_0__oeq_0( 1599; CHECK-SAME: float [[ARG:%.*]]) { 1600; CHECK-NEXT: [[OEQ_0:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1601; CHECK-NEXT: call void @llvm.assume(i1 [[OEQ_0]]) 1602; CHECK-NEXT: ret i1 false 1603; 1604 %oeq.0 = fcmp one float %arg, 0.0 1605 call void @llvm.assume(i1 %oeq.0) 1606 %cmp = fcmp oeq float %arg, 0.0 1607 ret i1 %cmp 1608} 1609 1610define i1 @assume_ueq_0__oeq_0(float %arg) { 1611; CHECK-LABEL: define i1 @assume_ueq_0__oeq_0( 1612; CHECK-SAME: float [[ARG:%.*]]) { 1613; CHECK-NEXT: [[OEQ_0:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1614; CHECK-NEXT: call void @llvm.assume(i1 [[OEQ_0]]) 1615; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 1616; CHECK-NEXT: ret i1 [[CMP]] 1617; 1618 %oeq.0 = fcmp ueq float %arg, 0.0 1619 call void @llvm.assume(i1 %oeq.0) 1620 %cmp = fcmp oeq float %arg, 0.0 1621 ret i1 %cmp 1622} 1623 1624define i1 @assume_ueq_0__ueq_0(float %arg) { 1625; CHECK-LABEL: define i1 @assume_ueq_0__ueq_0( 1626; CHECK-SAME: float [[ARG:%.*]]) { 1627; CHECK-NEXT: [[UEQ_0:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1628; CHECK-NEXT: call void @llvm.assume(i1 [[UEQ_0]]) 1629; CHECK-NEXT: ret i1 true 1630; 1631 %ueq.0 = fcmp ueq float %arg, 0.0 1632 call void @llvm.assume(i1 %ueq.0) 1633 %cmp = fcmp ueq float %arg, 0.0 1634 ret i1 %cmp 1635} 1636 1637define i1 @assume_one_0__ueq_0(float %arg) { 1638; CHECK-LABEL: define i1 @assume_one_0__ueq_0( 1639; CHECK-SAME: float [[ARG:%.*]]) { 1640; CHECK-NEXT: [[ONE_0:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1641; CHECK-NEXT: call void @llvm.assume(i1 [[ONE_0]]) 1642; CHECK-NEXT: ret i1 false 1643; 1644 %one.0 = fcmp one float %arg, 0.0 1645 call void @llvm.assume(i1 %one.0) 1646 %cmp = fcmp ueq float %arg, 0.0 1647 ret i1 %cmp 1648} 1649 1650define i1 @assume_one_0__one_0(float %arg) { 1651; CHECK-LABEL: define i1 @assume_one_0__one_0( 1652; CHECK-SAME: float [[ARG:%.*]]) { 1653; CHECK-NEXT: [[ONE_0:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1654; CHECK-NEXT: call void @llvm.assume(i1 [[ONE_0]]) 1655; CHECK-NEXT: ret i1 true 1656; 1657 %one.0 = fcmp one float %arg, 0.0 1658 call void @llvm.assume(i1 %one.0) 1659 %cmp = fcmp one float %arg, 0.0 1660 ret i1 %cmp 1661} 1662 1663define i1 @assume_une_0__oeq_0(float %arg) { 1664; CHECK-LABEL: define i1 @assume_une_0__oeq_0( 1665; CHECK-SAME: float [[ARG:%.*]]) { 1666; CHECK-NEXT: [[ONE_0:%.*]] = fcmp une float [[ARG]], 0.000000e+00 1667; CHECK-NEXT: call void @llvm.assume(i1 [[ONE_0]]) 1668; CHECK-NEXT: ret i1 false 1669; 1670 %one.0 = fcmp une float %arg, 0.0 1671 call void @llvm.assume(i1 %one.0) 1672 %cmp = fcmp oeq float %arg, 0.0 1673 ret i1 %cmp 1674} 1675 1676define i1 @assume_une_0__one_0(float %arg) { 1677; CHECK-LABEL: define i1 @assume_une_0__one_0( 1678; CHECK-SAME: float [[ARG:%.*]]) { 1679; CHECK-NEXT: [[ONE_0:%.*]] = fcmp une float [[ARG]], 0.000000e+00 1680; CHECK-NEXT: call void @llvm.assume(i1 [[ONE_0]]) 1681; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1682; CHECK-NEXT: ret i1 [[CMP]] 1683; 1684 %one.0 = fcmp une float %arg, 0.0 1685 call void @llvm.assume(i1 %one.0) 1686 %cmp = fcmp one float %arg, 0.0 1687 ret i1 %cmp 1688} 1689 1690; -------------------------------------------------------------------- 1691; Test assume x < 1.0 with compares to 0 1692; -------------------------------------------------------------------- 1693 1694define i1 @assume_olt_pos1__oeq_0(float %arg) { 1695; CHECK-LABEL: define i1 @assume_olt_pos1__oeq_0( 1696; CHECK-SAME: float [[ARG:%.*]]) { 1697; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1698; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1699; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 1700; CHECK-NEXT: ret i1 [[CMP]] 1701; 1702 %olt.pos1 = fcmp olt float %arg, 1.0 1703 call void @llvm.assume(i1 %olt.pos1) 1704 %cmp = fcmp oeq float %arg, 0.0 1705 ret i1 %cmp 1706} 1707 1708define i1 @assume_olt_pos1__ogt_0(float %arg) { 1709; CHECK-LABEL: define i1 @assume_olt_pos1__ogt_0( 1710; CHECK-SAME: float [[ARG:%.*]]) { 1711; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1712; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1713; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 1714; CHECK-NEXT: ret i1 [[CMP]] 1715; 1716 %olt.pos1 = fcmp olt float %arg, 1.0 1717 call void @llvm.assume(i1 %olt.pos1) 1718 %cmp = fcmp ogt float %arg, 0.0 1719 ret i1 %cmp 1720} 1721 1722define i1 @assume_olt_pos1__oge_0(float %arg) { 1723; CHECK-LABEL: define i1 @assume_olt_pos1__oge_0( 1724; CHECK-SAME: float [[ARG:%.*]]) { 1725; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1726; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1727; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 1728; CHECK-NEXT: ret i1 [[CMP]] 1729; 1730 %olt.pos1 = fcmp olt float %arg, 1.0 1731 call void @llvm.assume(i1 %olt.pos1) 1732 %cmp = fcmp oge float %arg, 0.0 1733 ret i1 %cmp 1734} 1735 1736define i1 @assume_olt_pos1__olt_0(float %arg) { 1737; CHECK-LABEL: define i1 @assume_olt_pos1__olt_0( 1738; CHECK-SAME: float [[ARG:%.*]]) { 1739; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1740; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1741; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 1742; CHECK-NEXT: ret i1 [[CMP]] 1743; 1744 %olt.pos1 = fcmp olt float %arg, 1.0 1745 call void @llvm.assume(i1 %olt.pos1) 1746 %cmp = fcmp olt float %arg, 0.0 1747 ret i1 %cmp 1748} 1749 1750define i1 @assume_olt_pos1__ole_0(float %arg) { 1751; CHECK-LABEL: define i1 @assume_olt_pos1__ole_0( 1752; CHECK-SAME: float [[ARG:%.*]]) { 1753; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1754; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1755; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 1756; CHECK-NEXT: ret i1 [[CMP]] 1757; 1758 %olt.pos1 = fcmp olt float %arg, 1.0 1759 call void @llvm.assume(i1 %olt.pos1) 1760 %cmp = fcmp ole float %arg, 0.0 1761 ret i1 %cmp 1762} 1763 1764define i1 @assume_olt_pos1__one_0(float %arg) { 1765; CHECK-LABEL: define i1 @assume_olt_pos1__one_0( 1766; CHECK-SAME: float [[ARG:%.*]]) { 1767; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1768; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1769; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1770; CHECK-NEXT: ret i1 [[CMP]] 1771; 1772 %olt.pos1 = fcmp olt float %arg, 1.0 1773 call void @llvm.assume(i1 %olt.pos1) 1774 %cmp = fcmp one float %arg, 0.0 1775 ret i1 %cmp 1776} 1777 1778define i1 @assume_olt_pos1__ord_0(float %arg) { 1779; CHECK-LABEL: define i1 @assume_olt_pos1__ord_0( 1780; CHECK-SAME: float [[ARG:%.*]]) { 1781; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1782; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1783; CHECK-NEXT: ret i1 true 1784; 1785 %olt.pos1 = fcmp olt float %arg, 1.0 1786 call void @llvm.assume(i1 %olt.pos1) 1787 %cmp = fcmp ord float %arg, 0.0 1788 ret i1 %cmp 1789} 1790 1791define i1 @assume_olt_pos1__ueq_0(float %arg) { 1792; CHECK-LABEL: define i1 @assume_olt_pos1__ueq_0( 1793; CHECK-SAME: float [[ARG:%.*]]) { 1794; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1795; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1796; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1797; CHECK-NEXT: ret i1 [[CMP]] 1798; 1799 %olt.pos1 = fcmp olt float %arg, 1.0 1800 call void @llvm.assume(i1 %olt.pos1) 1801 %cmp = fcmp ueq float %arg, 0.0 1802 ret i1 %cmp 1803} 1804 1805define i1 @assume_olt_pos1__ugt_0(float %arg) { 1806; CHECK-LABEL: define i1 @assume_olt_pos1__ugt_0( 1807; CHECK-SAME: float [[ARG:%.*]]) { 1808; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1809; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1810; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 1811; CHECK-NEXT: ret i1 [[CMP]] 1812; 1813 %olt.pos1 = fcmp olt float %arg, 1.0 1814 call void @llvm.assume(i1 %olt.pos1) 1815 %cmp = fcmp ugt float %arg, 0.0 1816 ret i1 %cmp 1817} 1818 1819define i1 @assume_olt_pos1__uge_0(float %arg) { 1820; CHECK-LABEL: define i1 @assume_olt_pos1__uge_0( 1821; CHECK-SAME: float [[ARG:%.*]]) { 1822; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1823; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1824; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 1825; CHECK-NEXT: ret i1 [[CMP]] 1826; 1827 %olt.pos1 = fcmp olt float %arg, 1.0 1828 call void @llvm.assume(i1 %olt.pos1) 1829 %cmp = fcmp uge float %arg, 0.0 1830 ret i1 %cmp 1831} 1832 1833define i1 @assume_olt_pos1__ult_0(float %arg) { 1834; CHECK-LABEL: define i1 @assume_olt_pos1__ult_0( 1835; CHECK-SAME: float [[ARG:%.*]]) { 1836; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1837; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1838; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 1839; CHECK-NEXT: ret i1 [[CMP]] 1840; 1841 %olt.pos1 = fcmp olt float %arg, 1.0 1842 call void @llvm.assume(i1 %olt.pos1) 1843 %cmp = fcmp ult float %arg, 0.0 1844 ret i1 %cmp 1845} 1846 1847define i1 @assume_olt_pos1__ule_0(float %arg) { 1848; CHECK-LABEL: define i1 @assume_olt_pos1__ule_0( 1849; CHECK-SAME: float [[ARG:%.*]]) { 1850; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1851; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1852; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 1853; CHECK-NEXT: ret i1 [[CMP]] 1854; 1855 %olt.pos1 = fcmp olt float %arg, 1.0 1856 call void @llvm.assume(i1 %olt.pos1) 1857 %cmp = fcmp ule float %arg, 0.0 1858 ret i1 %cmp 1859} 1860 1861define i1 @assume_olt_pos1__une_0(float %arg) { 1862; CHECK-LABEL: define i1 @assume_olt_pos1__une_0( 1863; CHECK-SAME: float [[ARG:%.*]]) { 1864; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1865; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1866; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 1867; CHECK-NEXT: ret i1 [[CMP]] 1868; 1869 %olt.pos1 = fcmp olt float %arg, 1.0 1870 call void @llvm.assume(i1 %olt.pos1) 1871 %cmp = fcmp une float %arg, 0.0 1872 ret i1 %cmp 1873} 1874 1875define i1 @assume_olt_pos1__uno_0(float %arg) { 1876; CHECK-LABEL: define i1 @assume_olt_pos1__uno_0( 1877; CHECK-SAME: float [[ARG:%.*]]) { 1878; CHECK-NEXT: [[OLT_POS1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 1879; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_POS1]]) 1880; CHECK-NEXT: ret i1 false 1881; 1882 %olt.pos1 = fcmp olt float %arg, 1.0 1883 call void @llvm.assume(i1 %olt.pos1) 1884 %cmp = fcmp uno float %arg, 0.0 1885 ret i1 %cmp 1886} 1887 1888; -------------------------------------------------------------------- 1889; Test assume x <= 1.0 with compares to 0 1890; -------------------------------------------------------------------- 1891 1892define i1 @assume_ole_pos1__oeq_0(float %arg) { 1893; CHECK-LABEL: define i1 @assume_ole_pos1__oeq_0( 1894; CHECK-SAME: float [[ARG:%.*]]) { 1895; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1896; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1897; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00 1898; CHECK-NEXT: ret i1 [[CMP]] 1899; 1900 %ole.pos1 = fcmp ole float %arg, 1.0 1901 call void @llvm.assume(i1 %ole.pos1) 1902 %cmp = fcmp oeq float %arg, 0.0 1903 ret i1 %cmp 1904} 1905 1906define i1 @assume_ole_pos1__ogt_0(float %arg) { 1907; CHECK-LABEL: define i1 @assume_ole_pos1__ogt_0( 1908; CHECK-SAME: float [[ARG:%.*]]) { 1909; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1910; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1911; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 1912; CHECK-NEXT: ret i1 [[CMP]] 1913; 1914 %ole.pos1 = fcmp ole float %arg, 1.0 1915 call void @llvm.assume(i1 %ole.pos1) 1916 %cmp = fcmp ogt float %arg, 0.0 1917 ret i1 %cmp 1918} 1919 1920define i1 @assume_ole_pos1__oge_0(float %arg) { 1921; CHECK-LABEL: define i1 @assume_ole_pos1__oge_0( 1922; CHECK-SAME: float [[ARG:%.*]]) { 1923; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1924; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1925; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 1926; CHECK-NEXT: ret i1 [[CMP]] 1927; 1928 %ole.pos1 = fcmp ole float %arg, 1.0 1929 call void @llvm.assume(i1 %ole.pos1) 1930 %cmp = fcmp oge float %arg, 0.0 1931 ret i1 %cmp 1932} 1933 1934define i1 @assume_ole_pos1__olt_0(float %arg) { 1935; CHECK-LABEL: define i1 @assume_ole_pos1__olt_0( 1936; CHECK-SAME: float [[ARG:%.*]]) { 1937; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1938; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1939; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 0.000000e+00 1940; CHECK-NEXT: ret i1 [[CMP]] 1941; 1942 %ole.pos1 = fcmp ole float %arg, 1.0 1943 call void @llvm.assume(i1 %ole.pos1) 1944 %cmp = fcmp olt float %arg, 0.0 1945 ret i1 %cmp 1946} 1947 1948define i1 @assume_ole_pos1__ole_0(float %arg) { 1949; CHECK-LABEL: define i1 @assume_ole_pos1__ole_0( 1950; CHECK-SAME: float [[ARG:%.*]]) { 1951; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1952; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1953; CHECK-NEXT: [[CMP:%.*]] = fcmp ole float [[ARG]], 0.000000e+00 1954; CHECK-NEXT: ret i1 [[CMP]] 1955; 1956 %ole.pos1 = fcmp ole float %arg, 1.0 1957 call void @llvm.assume(i1 %ole.pos1) 1958 %cmp = fcmp ole float %arg, 0.0 1959 ret i1 %cmp 1960} 1961 1962define i1 @assume_ole_pos1__one_0(float %arg) { 1963; CHECK-LABEL: define i1 @assume_ole_pos1__one_0( 1964; CHECK-SAME: float [[ARG:%.*]]) { 1965; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1966; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1967; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 1968; CHECK-NEXT: ret i1 [[CMP]] 1969; 1970 %ole.pos1 = fcmp ole float %arg, 1.0 1971 call void @llvm.assume(i1 %ole.pos1) 1972 %cmp = fcmp one float %arg, 0.0 1973 ret i1 %cmp 1974} 1975 1976define i1 @assume_ole_pos1__ord_0(float %arg) { 1977; CHECK-LABEL: define i1 @assume_ole_pos1__ord_0( 1978; CHECK-SAME: float [[ARG:%.*]]) { 1979; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1980; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1981; CHECK-NEXT: ret i1 true 1982; 1983 %ole.pos1 = fcmp ole float %arg, 1.0 1984 call void @llvm.assume(i1 %ole.pos1) 1985 %cmp = fcmp ord float %arg, 0.0 1986 ret i1 %cmp 1987} 1988 1989define i1 @assume_ole_pos1__ueq_0(float %arg) { 1990; CHECK-LABEL: define i1 @assume_ole_pos1__ueq_0( 1991; CHECK-SAME: float [[ARG:%.*]]) { 1992; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 1993; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 1994; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 1995; CHECK-NEXT: ret i1 [[CMP]] 1996; 1997 %ole.pos1 = fcmp ole float %arg, 1.0 1998 call void @llvm.assume(i1 %ole.pos1) 1999 %cmp = fcmp ueq float %arg, 0.0 2000 ret i1 %cmp 2001} 2002 2003define i1 @assume_ole_pos1__ugt_0(float %arg) { 2004; CHECK-LABEL: define i1 @assume_ole_pos1__ugt_0( 2005; CHECK-SAME: float [[ARG:%.*]]) { 2006; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 2007; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 2008; CHECK-NEXT: [[CMP:%.*]] = fcmp ugt float [[ARG]], 0.000000e+00 2009; CHECK-NEXT: ret i1 [[CMP]] 2010; 2011 %ole.pos1 = fcmp ole float %arg, 1.0 2012 call void @llvm.assume(i1 %ole.pos1) 2013 %cmp = fcmp ugt float %arg, 0.0 2014 ret i1 %cmp 2015} 2016 2017define i1 @assume_ole_pos1__uge_0(float %arg) { 2018; CHECK-LABEL: define i1 @assume_ole_pos1__uge_0( 2019; CHECK-SAME: float [[ARG:%.*]]) { 2020; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 2021; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 2022; CHECK-NEXT: [[CMP:%.*]] = fcmp uge float [[ARG]], 0.000000e+00 2023; CHECK-NEXT: ret i1 [[CMP]] 2024; 2025 %ole.pos1 = fcmp ole float %arg, 1.0 2026 call void @llvm.assume(i1 %ole.pos1) 2027 %cmp = fcmp uge float %arg, 0.0 2028 ret i1 %cmp 2029} 2030 2031define i1 @assume_ole_pos1__ult_0(float %arg) { 2032; CHECK-LABEL: define i1 @assume_ole_pos1__ult_0( 2033; CHECK-SAME: float [[ARG:%.*]]) { 2034; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 2035; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 2036; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 2037; CHECK-NEXT: ret i1 [[CMP]] 2038; 2039 %ole.pos1 = fcmp ole float %arg, 1.0 2040 call void @llvm.assume(i1 %ole.pos1) 2041 %cmp = fcmp ult float %arg, 0.0 2042 ret i1 %cmp 2043} 2044 2045define i1 @assume_ole_pos1__ule_0(float %arg) { 2046; CHECK-LABEL: define i1 @assume_ole_pos1__ule_0( 2047; CHECK-SAME: float [[ARG:%.*]]) { 2048; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 2049; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 2050; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 2051; CHECK-NEXT: ret i1 [[CMP]] 2052; 2053 %ole.pos1 = fcmp ole float %arg, 1.0 2054 call void @llvm.assume(i1 %ole.pos1) 2055 %cmp = fcmp ule float %arg, 0.0 2056 ret i1 %cmp 2057} 2058 2059define i1 @assume_ole_pos1__une_0(float %arg) { 2060; CHECK-LABEL: define i1 @assume_ole_pos1__une_0( 2061; CHECK-SAME: float [[ARG:%.*]]) { 2062; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 2063; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 2064; CHECK-NEXT: [[CMP:%.*]] = fcmp une float [[ARG]], 0.000000e+00 2065; CHECK-NEXT: ret i1 [[CMP]] 2066; 2067 %ole.pos1 = fcmp ole float %arg, 1.0 2068 call void @llvm.assume(i1 %ole.pos1) 2069 %cmp = fcmp une float %arg, 0.0 2070 ret i1 %cmp 2071} 2072 2073define i1 @assume_ole_pos1__uno_0(float %arg) { 2074; CHECK-LABEL: define i1 @assume_ole_pos1__uno_0( 2075; CHECK-SAME: float [[ARG:%.*]]) { 2076; CHECK-NEXT: [[OLE_POS1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00 2077; CHECK-NEXT: call void @llvm.assume(i1 [[OLE_POS1]]) 2078; CHECK-NEXT: ret i1 false 2079; 2080 %ole.pos1 = fcmp ole float %arg, 1.0 2081 call void @llvm.assume(i1 %ole.pos1) 2082 %cmp = fcmp uno float %arg, 0.0 2083 ret i1 %cmp 2084} 2085 2086; -------------------------------------------------------------------- 2087; Test assume x > 1.0 with compares to 0 2088; -------------------------------------------------------------------- 2089 2090define i1 @assume_ogt_pos1__oeq_0(float %arg) { 2091; CHECK-LABEL: define i1 @assume_ogt_pos1__oeq_0( 2092; CHECK-SAME: float [[ARG:%.*]]) { 2093; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2094; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2095; CHECK-NEXT: ret i1 false 2096; 2097 %ogt.pos1 = fcmp ogt float %arg, 1.0 2098 call void @llvm.assume(i1 %ogt.pos1) 2099 %cmp = fcmp oeq float %arg, 0.0 2100 ret i1 %cmp 2101} 2102 2103define i1 @assume_ogt_pos1__ogt_0(float %arg) { 2104; CHECK-LABEL: define i1 @assume_ogt_pos1__ogt_0( 2105; CHECK-SAME: float [[ARG:%.*]]) { 2106; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2107; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2108; CHECK-NEXT: ret i1 true 2109; 2110 %ogt.pos1 = fcmp ogt float %arg, 1.0 2111 call void @llvm.assume(i1 %ogt.pos1) 2112 %cmp = fcmp ogt float %arg, 0.0 2113 ret i1 %cmp 2114} 2115 2116define i1 @assume_ogt_pos1__oge_0(float %arg) { 2117; CHECK-LABEL: define i1 @assume_ogt_pos1__oge_0( 2118; CHECK-SAME: float [[ARG:%.*]]) { 2119; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2120; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2121; CHECK-NEXT: ret i1 true 2122; 2123 %ogt.pos1 = fcmp ogt float %arg, 1.0 2124 call void @llvm.assume(i1 %ogt.pos1) 2125 %cmp = fcmp oge float %arg, 0.0 2126 ret i1 %cmp 2127} 2128 2129define i1 @assume_ogt_pos1__olt_0(float %arg) { 2130; CHECK-LABEL: define i1 @assume_ogt_pos1__olt_0( 2131; CHECK-SAME: float [[ARG:%.*]]) { 2132; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2133; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2134; CHECK-NEXT: ret i1 false 2135; 2136 %ogt.pos1 = fcmp ogt float %arg, 1.0 2137 call void @llvm.assume(i1 %ogt.pos1) 2138 %cmp = fcmp olt float %arg, 0.0 2139 ret i1 %cmp 2140} 2141 2142define i1 @assume_ogt_pos1__ole_0(float %arg) { 2143; CHECK-LABEL: define i1 @assume_ogt_pos1__ole_0( 2144; CHECK-SAME: float [[ARG:%.*]]) { 2145; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2146; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2147; CHECK-NEXT: ret i1 false 2148; 2149 %ogt.pos1 = fcmp ogt float %arg, 1.0 2150 call void @llvm.assume(i1 %ogt.pos1) 2151 %cmp = fcmp ole float %arg, 0.0 2152 ret i1 %cmp 2153} 2154 2155define i1 @assume_ogt_pos1__one_0(float %arg) { 2156; CHECK-LABEL: define i1 @assume_ogt_pos1__one_0( 2157; CHECK-SAME: float [[ARG:%.*]]) { 2158; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2159; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2160; CHECK-NEXT: ret i1 true 2161; 2162 %ogt.pos1 = fcmp ogt float %arg, 1.0 2163 call void @llvm.assume(i1 %ogt.pos1) 2164 %cmp = fcmp one float %arg, 0.0 2165 ret i1 %cmp 2166} 2167 2168define i1 @assume_ogt_pos1__ord_0(float %arg) { 2169; CHECK-LABEL: define i1 @assume_ogt_pos1__ord_0( 2170; CHECK-SAME: float [[ARG:%.*]]) { 2171; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2172; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2173; CHECK-NEXT: ret i1 true 2174; 2175 %ogt.pos1 = fcmp ogt float %arg, 1.0 2176 call void @llvm.assume(i1 %ogt.pos1) 2177 %cmp = fcmp ord float %arg, 0.0 2178 ret i1 %cmp 2179} 2180 2181define i1 @assume_ogt_pos1__ueq_0(float %arg) { 2182; CHECK-LABEL: define i1 @assume_ogt_pos1__ueq_0( 2183; CHECK-SAME: float [[ARG:%.*]]) { 2184; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2185; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2186; CHECK-NEXT: ret i1 false 2187; 2188 %ogt.pos1 = fcmp ogt float %arg, 1.0 2189 call void @llvm.assume(i1 %ogt.pos1) 2190 %cmp = fcmp ueq float %arg, 0.0 2191 ret i1 %cmp 2192} 2193 2194define i1 @assume_ogt_pos1__ugt_0(float %arg) { 2195; CHECK-LABEL: define i1 @assume_ogt_pos1__ugt_0( 2196; CHECK-SAME: float [[ARG:%.*]]) { 2197; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2198; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2199; CHECK-NEXT: ret i1 true 2200; 2201 %ogt.pos1 = fcmp ogt float %arg, 1.0 2202 call void @llvm.assume(i1 %ogt.pos1) 2203 %cmp = fcmp ugt float %arg, 0.0 2204 ret i1 %cmp 2205} 2206 2207define i1 @assume_ogt_pos1__uge_0(float %arg) { 2208; CHECK-LABEL: define i1 @assume_ogt_pos1__uge_0( 2209; CHECK-SAME: float [[ARG:%.*]]) { 2210; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2211; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2212; CHECK-NEXT: ret i1 true 2213; 2214 %ogt.pos1 = fcmp ogt float %arg, 1.0 2215 call void @llvm.assume(i1 %ogt.pos1) 2216 %cmp = fcmp uge float %arg, 0.0 2217 ret i1 %cmp 2218} 2219 2220define i1 @assume_ogt_pos1__ult_0(float %arg) { 2221; CHECK-LABEL: define i1 @assume_ogt_pos1__ult_0( 2222; CHECK-SAME: float [[ARG:%.*]]) { 2223; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2224; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2225; CHECK-NEXT: ret i1 false 2226; 2227 %ogt.pos1 = fcmp ogt float %arg, 1.0 2228 call void @llvm.assume(i1 %ogt.pos1) 2229 %cmp = fcmp ult float %arg, 0.0 2230 ret i1 %cmp 2231} 2232 2233define i1 @assume_ogt_pos1__ule_0(float %arg) { 2234; CHECK-LABEL: define i1 @assume_ogt_pos1__ule_0( 2235; CHECK-SAME: float [[ARG:%.*]]) { 2236; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2237; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2238; CHECK-NEXT: ret i1 false 2239; 2240 %ogt.pos1 = fcmp ogt float %arg, 1.0 2241 call void @llvm.assume(i1 %ogt.pos1) 2242 %cmp = fcmp ule float %arg, 0.0 2243 ret i1 %cmp 2244} 2245 2246define i1 @assume_ogt_pos1__une_0(float %arg) { 2247; CHECK-LABEL: define i1 @assume_ogt_pos1__une_0( 2248; CHECK-SAME: float [[ARG:%.*]]) { 2249; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2250; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2251; CHECK-NEXT: ret i1 true 2252; 2253 %ogt.pos1 = fcmp ogt float %arg, 1.0 2254 call void @llvm.assume(i1 %ogt.pos1) 2255 %cmp = fcmp une float %arg, 0.0 2256 ret i1 %cmp 2257} 2258 2259define i1 @assume_ogt_pos1__uno_0(float %arg) { 2260; CHECK-LABEL: define i1 @assume_ogt_pos1__uno_0( 2261; CHECK-SAME: float [[ARG:%.*]]) { 2262; CHECK-NEXT: [[OGT_POS1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+00 2263; CHECK-NEXT: call void @llvm.assume(i1 [[OGT_POS1]]) 2264; CHECK-NEXT: ret i1 false 2265; 2266 %ogt.pos1 = fcmp ogt float %arg, 1.0 2267 call void @llvm.assume(i1 %ogt.pos1) 2268 %cmp = fcmp uno float %arg, 0.0 2269 ret i1 %cmp 2270} 2271 2272; -------------------------------------------------------------------- 2273; Test assume x >= 1.0 with compares to 0 2274; -------------------------------------------------------------------- 2275 2276define i1 @assume_oge_pos1__oeq_0(float %arg) { 2277; CHECK-LABEL: define i1 @assume_oge_pos1__oeq_0( 2278; CHECK-SAME: float [[ARG:%.*]]) { 2279; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2280; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2281; CHECK-NEXT: ret i1 false 2282; 2283 %oge.pos1 = fcmp oge float %arg, 1.0 2284 call void @llvm.assume(i1 %oge.pos1) 2285 %cmp = fcmp oeq float %arg, 0.0 2286 ret i1 %cmp 2287} 2288 2289define i1 @assume_oge_pos1__ogt_0(float %arg) { 2290; CHECK-LABEL: define i1 @assume_oge_pos1__ogt_0( 2291; CHECK-SAME: float [[ARG:%.*]]) { 2292; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2293; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2294; CHECK-NEXT: ret i1 true 2295; 2296 %oge.pos1 = fcmp oge float %arg, 1.0 2297 call void @llvm.assume(i1 %oge.pos1) 2298 %cmp = fcmp ogt float %arg, 0.0 2299 ret i1 %cmp 2300} 2301 2302define i1 @assume_oge_pos1__oge_0(float %arg) { 2303; CHECK-LABEL: define i1 @assume_oge_pos1__oge_0( 2304; CHECK-SAME: float [[ARG:%.*]]) { 2305; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2306; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2307; CHECK-NEXT: ret i1 true 2308; 2309 %oge.pos1 = fcmp oge float %arg, 1.0 2310 call void @llvm.assume(i1 %oge.pos1) 2311 %cmp = fcmp oge float %arg, 0.0 2312 ret i1 %cmp 2313} 2314 2315define i1 @assume_oge_pos1__olt_0(float %arg) { 2316; CHECK-LABEL: define i1 @assume_oge_pos1__olt_0( 2317; CHECK-SAME: float [[ARG:%.*]]) { 2318; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2319; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2320; CHECK-NEXT: ret i1 false 2321; 2322 %oge.pos1 = fcmp oge float %arg, 1.0 2323 call void @llvm.assume(i1 %oge.pos1) 2324 %cmp = fcmp olt float %arg, 0.0 2325 ret i1 %cmp 2326} 2327 2328define i1 @assume_oge_pos1__ole_0(float %arg) { 2329; CHECK-LABEL: define i1 @assume_oge_pos1__ole_0( 2330; CHECK-SAME: float [[ARG:%.*]]) { 2331; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2332; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2333; CHECK-NEXT: ret i1 false 2334; 2335 %oge.pos1 = fcmp oge float %arg, 1.0 2336 call void @llvm.assume(i1 %oge.pos1) 2337 %cmp = fcmp ole float %arg, 0.0 2338 ret i1 %cmp 2339} 2340 2341define i1 @assume_oge_pos1__one_0(float %arg) { 2342; CHECK-LABEL: define i1 @assume_oge_pos1__one_0( 2343; CHECK-SAME: float [[ARG:%.*]]) { 2344; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2345; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2346; CHECK-NEXT: ret i1 true 2347; 2348 %oge.pos1 = fcmp oge float %arg, 1.0 2349 call void @llvm.assume(i1 %oge.pos1) 2350 %cmp = fcmp one float %arg, 0.0 2351 ret i1 %cmp 2352} 2353 2354define i1 @assume_oge_pos1__ord_0(float %arg) { 2355; CHECK-LABEL: define i1 @assume_oge_pos1__ord_0( 2356; CHECK-SAME: float [[ARG:%.*]]) { 2357; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2358; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2359; CHECK-NEXT: ret i1 true 2360; 2361 %oge.pos1 = fcmp oge float %arg, 1.0 2362 call void @llvm.assume(i1 %oge.pos1) 2363 %cmp = fcmp ord float %arg, 0.0 2364 ret i1 %cmp 2365} 2366 2367define i1 @assume_oge_pos1__ueq_0(float %arg) { 2368; CHECK-LABEL: define i1 @assume_oge_pos1__ueq_0( 2369; CHECK-SAME: float [[ARG:%.*]]) { 2370; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2371; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2372; CHECK-NEXT: ret i1 false 2373; 2374 %oge.pos1 = fcmp oge float %arg, 1.0 2375 call void @llvm.assume(i1 %oge.pos1) 2376 %cmp = fcmp ueq float %arg, 0.0 2377 ret i1 %cmp 2378} 2379 2380define i1 @assume_oge_pos1__ugt_0(float %arg) { 2381; CHECK-LABEL: define i1 @assume_oge_pos1__ugt_0( 2382; CHECK-SAME: float [[ARG:%.*]]) { 2383; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2384; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2385; CHECK-NEXT: ret i1 true 2386; 2387 %oge.pos1 = fcmp oge float %arg, 1.0 2388 call void @llvm.assume(i1 %oge.pos1) 2389 %cmp = fcmp ugt float %arg, 0.0 2390 ret i1 %cmp 2391} 2392 2393define i1 @assume_oge_pos1__uge_0(float %arg) { 2394; CHECK-LABEL: define i1 @assume_oge_pos1__uge_0( 2395; CHECK-SAME: float [[ARG:%.*]]) { 2396; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2397; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2398; CHECK-NEXT: ret i1 true 2399; 2400 %oge.pos1 = fcmp oge float %arg, 1.0 2401 call void @llvm.assume(i1 %oge.pos1) 2402 %cmp = fcmp uge float %arg, 0.0 2403 ret i1 %cmp 2404} 2405 2406define i1 @assume_oge_pos1__ult_0(float %arg) { 2407; CHECK-LABEL: define i1 @assume_oge_pos1__ult_0( 2408; CHECK-SAME: float [[ARG:%.*]]) { 2409; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2410; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2411; CHECK-NEXT: ret i1 false 2412; 2413 %oge.pos1 = fcmp oge float %arg, 1.0 2414 call void @llvm.assume(i1 %oge.pos1) 2415 %cmp = fcmp ult float %arg, 0.0 2416 ret i1 %cmp 2417} 2418 2419define i1 @assume_oge_pos1__ule_0(float %arg) { 2420; CHECK-LABEL: define i1 @assume_oge_pos1__ule_0( 2421; CHECK-SAME: float [[ARG:%.*]]) { 2422; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2423; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2424; CHECK-NEXT: ret i1 false 2425; 2426 %oge.pos1 = fcmp oge float %arg, 1.0 2427 call void @llvm.assume(i1 %oge.pos1) 2428 %cmp = fcmp ule float %arg, 0.0 2429 ret i1 %cmp 2430} 2431 2432define i1 @assume_oge_pos1__une_0(float %arg) { 2433; CHECK-LABEL: define i1 @assume_oge_pos1__une_0( 2434; CHECK-SAME: float [[ARG:%.*]]) { 2435; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2436; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2437; CHECK-NEXT: ret i1 true 2438; 2439 %oge.pos1 = fcmp oge float %arg, 1.0 2440 call void @llvm.assume(i1 %oge.pos1) 2441 %cmp = fcmp une float %arg, 0.0 2442 ret i1 %cmp 2443} 2444 2445define i1 @assume_oge_pos1__uno_0(float %arg) { 2446; CHECK-LABEL: define i1 @assume_oge_pos1__uno_0( 2447; CHECK-SAME: float [[ARG:%.*]]) { 2448; CHECK-NEXT: [[OGE_POS1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00 2449; CHECK-NEXT: call void @llvm.assume(i1 [[OGE_POS1]]) 2450; CHECK-NEXT: ret i1 false 2451; 2452 %oge.pos1 = fcmp oge float %arg, 1.0 2453 call void @llvm.assume(i1 %oge.pos1) 2454 %cmp = fcmp uno float %arg, 0.0 2455 ret i1 %cmp 2456} 2457 2458; -------------------------------------------------------------------- 2459; Test assume x u> 1.0 with compares to 0 2460; -------------------------------------------------------------------- 2461 2462define i1 @assume_ugt_pos1__oeq_0(float %arg) { 2463; CHECK-LABEL: define i1 @assume_ugt_pos1__oeq_0( 2464; CHECK-SAME: float [[ARG:%.*]]) { 2465; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2466; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2467; CHECK-NEXT: ret i1 false 2468; 2469 %ugt.pos1 = fcmp ugt float %arg, 1.0 2470 call void @llvm.assume(i1 %ugt.pos1) 2471 %cmp = fcmp oeq float %arg, 0.0 2472 ret i1 %cmp 2473} 2474 2475define i1 @assume_ugt_pos1__ogt_0(float %arg) { 2476; CHECK-LABEL: define i1 @assume_ugt_pos1__ogt_0( 2477; CHECK-SAME: float [[ARG:%.*]]) { 2478; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2479; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2480; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 2481; CHECK-NEXT: ret i1 [[CMP]] 2482; 2483 %ugt.pos1 = fcmp ugt float %arg, 1.0 2484 call void @llvm.assume(i1 %ugt.pos1) 2485 %cmp = fcmp ogt float %arg, 0.0 2486 ret i1 %cmp 2487} 2488 2489define i1 @assume_ugt_pos1__oge_0(float %arg) { 2490; CHECK-LABEL: define i1 @assume_ugt_pos1__oge_0( 2491; CHECK-SAME: float [[ARG:%.*]]) { 2492; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2493; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2494; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 2495; CHECK-NEXT: ret i1 [[CMP]] 2496; 2497 %ugt.pos1 = fcmp ugt float %arg, 1.0 2498 call void @llvm.assume(i1 %ugt.pos1) 2499 %cmp = fcmp oge float %arg, 0.0 2500 ret i1 %cmp 2501} 2502 2503define i1 @assume_ugt_pos1__olt_0(float %arg) { 2504; CHECK-LABEL: define i1 @assume_ugt_pos1__olt_0( 2505; CHECK-SAME: float [[ARG:%.*]]) { 2506; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2507; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2508; CHECK-NEXT: ret i1 false 2509; 2510 %ugt.pos1 = fcmp ugt float %arg, 1.0 2511 call void @llvm.assume(i1 %ugt.pos1) 2512 %cmp = fcmp olt float %arg, 0.0 2513 ret i1 %cmp 2514} 2515 2516define i1 @assume_ugt_pos1__ole_0(float %arg) { 2517; CHECK-LABEL: define i1 @assume_ugt_pos1__ole_0( 2518; CHECK-SAME: float [[ARG:%.*]]) { 2519; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2520; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2521; CHECK-NEXT: ret i1 false 2522; 2523 %ugt.pos1 = fcmp ugt float %arg, 1.0 2524 call void @llvm.assume(i1 %ugt.pos1) 2525 %cmp = fcmp ole float %arg, 0.0 2526 ret i1 %cmp 2527} 2528 2529define i1 @assume_ugt_pos1__one_0(float %arg) { 2530; CHECK-LABEL: define i1 @assume_ugt_pos1__one_0( 2531; CHECK-SAME: float [[ARG:%.*]]) { 2532; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2533; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2534; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 2535; CHECK-NEXT: ret i1 [[CMP]] 2536; 2537 %ugt.pos1 = fcmp ugt float %arg, 1.0 2538 call void @llvm.assume(i1 %ugt.pos1) 2539 %cmp = fcmp one float %arg, 0.0 2540 ret i1 %cmp 2541} 2542 2543define i1 @assume_ugt_pos1__ord_0(float %arg) { 2544; CHECK-LABEL: define i1 @assume_ugt_pos1__ord_0( 2545; CHECK-SAME: float [[ARG:%.*]]) { 2546; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2547; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2548; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 2549; CHECK-NEXT: ret i1 [[CMP]] 2550; 2551 %ugt.pos1 = fcmp ugt float %arg, 1.0 2552 call void @llvm.assume(i1 %ugt.pos1) 2553 %cmp = fcmp ord float %arg, 0.0 2554 ret i1 %cmp 2555} 2556 2557define i1 @assume_ugt_pos1__ueq_0(float %arg) { 2558; CHECK-LABEL: define i1 @assume_ugt_pos1__ueq_0( 2559; CHECK-SAME: float [[ARG:%.*]]) { 2560; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2561; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2562; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 2563; CHECK-NEXT: ret i1 [[CMP]] 2564; 2565 %ugt.pos1 = fcmp ugt float %arg, 1.0 2566 call void @llvm.assume(i1 %ugt.pos1) 2567 %cmp = fcmp ueq float %arg, 0.0 2568 ret i1 %cmp 2569} 2570 2571define i1 @assume_ugt_pos1__ugt_0(float %arg) { 2572; CHECK-LABEL: define i1 @assume_ugt_pos1__ugt_0( 2573; CHECK-SAME: float [[ARG:%.*]]) { 2574; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2575; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2576; CHECK-NEXT: ret i1 true 2577; 2578 %ugt.pos1 = fcmp ugt float %arg, 1.0 2579 call void @llvm.assume(i1 %ugt.pos1) 2580 %cmp = fcmp ugt float %arg, 0.0 2581 ret i1 %cmp 2582} 2583 2584define i1 @assume_ugt_pos1__uge_0(float %arg) { 2585; CHECK-LABEL: define i1 @assume_ugt_pos1__uge_0( 2586; CHECK-SAME: float [[ARG:%.*]]) { 2587; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2588; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2589; CHECK-NEXT: ret i1 true 2590; 2591 %ugt.pos1 = fcmp ugt float %arg, 1.0 2592 call void @llvm.assume(i1 %ugt.pos1) 2593 %cmp = fcmp uge float %arg, 0.0 2594 ret i1 %cmp 2595} 2596 2597define i1 @assume_ugt_pos1__ult_0(float %arg) { 2598; CHECK-LABEL: define i1 @assume_ugt_pos1__ult_0( 2599; CHECK-SAME: float [[ARG:%.*]]) { 2600; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2601; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2602; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 2603; CHECK-NEXT: ret i1 [[CMP]] 2604; 2605 %ugt.pos1 = fcmp ugt float %arg, 1.0 2606 call void @llvm.assume(i1 %ugt.pos1) 2607 %cmp = fcmp ult float %arg, 0.0 2608 ret i1 %cmp 2609} 2610 2611define i1 @assume_ugt_pos1__ule_0(float %arg) { 2612; CHECK-LABEL: define i1 @assume_ugt_pos1__ule_0( 2613; CHECK-SAME: float [[ARG:%.*]]) { 2614; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2615; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2616; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 2617; CHECK-NEXT: ret i1 [[CMP]] 2618; 2619 %ugt.pos1 = fcmp ugt float %arg, 1.0 2620 call void @llvm.assume(i1 %ugt.pos1) 2621 %cmp = fcmp ule float %arg, 0.0 2622 ret i1 %cmp 2623} 2624 2625define i1 @assume_ugt_pos1__une_0(float %arg) { 2626; CHECK-LABEL: define i1 @assume_ugt_pos1__une_0( 2627; CHECK-SAME: float [[ARG:%.*]]) { 2628; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2629; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2630; CHECK-NEXT: ret i1 true 2631; 2632 %ugt.pos1 = fcmp ugt float %arg, 1.0 2633 call void @llvm.assume(i1 %ugt.pos1) 2634 %cmp = fcmp une float %arg, 0.0 2635 ret i1 %cmp 2636} 2637 2638define i1 @assume_ugt_pos1__uno_0(float %arg) { 2639; CHECK-LABEL: define i1 @assume_ugt_pos1__uno_0( 2640; CHECK-SAME: float [[ARG:%.*]]) { 2641; CHECK-NEXT: [[UGT_POS1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00 2642; CHECK-NEXT: call void @llvm.assume(i1 [[UGT_POS1]]) 2643; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 2644; CHECK-NEXT: ret i1 [[CMP]] 2645; 2646 %ugt.pos1 = fcmp ugt float %arg, 1.0 2647 call void @llvm.assume(i1 %ugt.pos1) 2648 %cmp = fcmp uno float %arg, 0.0 2649 ret i1 %cmp 2650} 2651 2652; -------------------------------------------------------------------- 2653; Test assume x u>= 1.0 with compares to 0 2654; -------------------------------------------------------------------- 2655 2656define i1 @assume_uge_pos1__oeq_0(float %arg) { 2657; CHECK-LABEL: define i1 @assume_uge_pos1__oeq_0( 2658; CHECK-SAME: float [[ARG:%.*]]) { 2659; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2660; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2661; CHECK-NEXT: ret i1 false 2662; 2663 %uge.pos1 = fcmp uge float %arg, 1.0 2664 call void @llvm.assume(i1 %uge.pos1) 2665 %cmp = fcmp oeq float %arg, 0.0 2666 ret i1 %cmp 2667} 2668 2669define i1 @assume_uge_pos1__ogt_0(float %arg) { 2670; CHECK-LABEL: define i1 @assume_uge_pos1__ogt_0( 2671; CHECK-SAME: float [[ARG:%.*]]) { 2672; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2673; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2674; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[ARG]], 0.000000e+00 2675; CHECK-NEXT: ret i1 [[CMP]] 2676; 2677 %uge.pos1 = fcmp uge float %arg, 1.0 2678 call void @llvm.assume(i1 %uge.pos1) 2679 %cmp = fcmp ogt float %arg, 0.0 2680 ret i1 %cmp 2681} 2682 2683define i1 @assume_uge_pos1__oge_0(float %arg) { 2684; CHECK-LABEL: define i1 @assume_uge_pos1__oge_0( 2685; CHECK-SAME: float [[ARG:%.*]]) { 2686; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2687; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2688; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[ARG]], 0.000000e+00 2689; CHECK-NEXT: ret i1 [[CMP]] 2690; 2691 %uge.pos1 = fcmp uge float %arg, 1.0 2692 call void @llvm.assume(i1 %uge.pos1) 2693 %cmp = fcmp oge float %arg, 0.0 2694 ret i1 %cmp 2695} 2696 2697define i1 @assume_uge_pos1__olt_0(float %arg) { 2698; CHECK-LABEL: define i1 @assume_uge_pos1__olt_0( 2699; CHECK-SAME: float [[ARG:%.*]]) { 2700; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2701; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2702; CHECK-NEXT: ret i1 false 2703; 2704 %uge.pos1 = fcmp uge float %arg, 1.0 2705 call void @llvm.assume(i1 %uge.pos1) 2706 %cmp = fcmp olt float %arg, 0.0 2707 ret i1 %cmp 2708} 2709 2710define i1 @assume_uge_pos1__ole_0(float %arg) { 2711; CHECK-LABEL: define i1 @assume_uge_pos1__ole_0( 2712; CHECK-SAME: float [[ARG:%.*]]) { 2713; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2714; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2715; CHECK-NEXT: ret i1 false 2716; 2717 %uge.pos1 = fcmp uge float %arg, 1.0 2718 call void @llvm.assume(i1 %uge.pos1) 2719 %cmp = fcmp ole float %arg, 0.0 2720 ret i1 %cmp 2721} 2722 2723define i1 @assume_uge_pos1__one_0(float %arg) { 2724; CHECK-LABEL: define i1 @assume_uge_pos1__one_0( 2725; CHECK-SAME: float [[ARG:%.*]]) { 2726; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2727; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2728; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0.000000e+00 2729; CHECK-NEXT: ret i1 [[CMP]] 2730; 2731 %uge.pos1 = fcmp uge float %arg, 1.0 2732 call void @llvm.assume(i1 %uge.pos1) 2733 %cmp = fcmp one float %arg, 0.0 2734 ret i1 %cmp 2735} 2736 2737define i1 @assume_uge_pos1__ord_0(float %arg) { 2738; CHECK-LABEL: define i1 @assume_uge_pos1__ord_0( 2739; CHECK-SAME: float [[ARG:%.*]]) { 2740; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2741; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2742; CHECK-NEXT: [[CMP:%.*]] = fcmp ord float [[ARG]], 0.000000e+00 2743; CHECK-NEXT: ret i1 [[CMP]] 2744; 2745 %uge.pos1 = fcmp uge float %arg, 1.0 2746 call void @llvm.assume(i1 %uge.pos1) 2747 %cmp = fcmp ord float %arg, 0.0 2748 ret i1 %cmp 2749} 2750 2751define i1 @assume_uge_pos1__ueq_0(float %arg) { 2752; CHECK-LABEL: define i1 @assume_uge_pos1__ueq_0( 2753; CHECK-SAME: float [[ARG:%.*]]) { 2754; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2755; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2756; CHECK-NEXT: [[CMP:%.*]] = fcmp ueq float [[ARG]], 0.000000e+00 2757; CHECK-NEXT: ret i1 [[CMP]] 2758; 2759 %uge.pos1 = fcmp uge float %arg, 1.0 2760 call void @llvm.assume(i1 %uge.pos1) 2761 %cmp = fcmp ueq float %arg, 0.0 2762 ret i1 %cmp 2763} 2764 2765define i1 @assume_uge_pos1__ugt_0(float %arg) { 2766; CHECK-LABEL: define i1 @assume_uge_pos1__ugt_0( 2767; CHECK-SAME: float [[ARG:%.*]]) { 2768; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2769; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2770; CHECK-NEXT: ret i1 true 2771; 2772 %uge.pos1 = fcmp uge float %arg, 1.0 2773 call void @llvm.assume(i1 %uge.pos1) 2774 %cmp = fcmp ugt float %arg, 0.0 2775 ret i1 %cmp 2776} 2777 2778define i1 @assume_uge_pos1__uge_0(float %arg) { 2779; CHECK-LABEL: define i1 @assume_uge_pos1__uge_0( 2780; CHECK-SAME: float [[ARG:%.*]]) { 2781; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2782; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2783; CHECK-NEXT: ret i1 true 2784; 2785 %uge.pos1 = fcmp uge float %arg, 1.0 2786 call void @llvm.assume(i1 %uge.pos1) 2787 %cmp = fcmp uge float %arg, 0.0 2788 ret i1 %cmp 2789} 2790 2791define i1 @assume_uge_pos1__ult_0(float %arg) { 2792; CHECK-LABEL: define i1 @assume_uge_pos1__ult_0( 2793; CHECK-SAME: float [[ARG:%.*]]) { 2794; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2795; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2796; CHECK-NEXT: [[CMP:%.*]] = fcmp ult float [[ARG]], 0.000000e+00 2797; CHECK-NEXT: ret i1 [[CMP]] 2798; 2799 %uge.pos1 = fcmp uge float %arg, 1.0 2800 call void @llvm.assume(i1 %uge.pos1) 2801 %cmp = fcmp ult float %arg, 0.0 2802 ret i1 %cmp 2803} 2804 2805define i1 @assume_uge_pos1__ule_0(float %arg) { 2806; CHECK-LABEL: define i1 @assume_uge_pos1__ule_0( 2807; CHECK-SAME: float [[ARG:%.*]]) { 2808; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2809; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2810; CHECK-NEXT: [[CMP:%.*]] = fcmp ule float [[ARG]], 0.000000e+00 2811; CHECK-NEXT: ret i1 [[CMP]] 2812; 2813 %uge.pos1 = fcmp uge float %arg, 1.0 2814 call void @llvm.assume(i1 %uge.pos1) 2815 %cmp = fcmp ule float %arg, 0.0 2816 ret i1 %cmp 2817} 2818 2819define i1 @assume_uge_pos1__une_0(float %arg) { 2820; CHECK-LABEL: define i1 @assume_uge_pos1__une_0( 2821; CHECK-SAME: float [[ARG:%.*]]) { 2822; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2823; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2824; CHECK-NEXT: ret i1 true 2825; 2826 %uge.pos1 = fcmp uge float %arg, 1.0 2827 call void @llvm.assume(i1 %uge.pos1) 2828 %cmp = fcmp une float %arg, 0.0 2829 ret i1 %cmp 2830} 2831 2832define i1 @assume_uge_pos1__uno_0(float %arg) { 2833; CHECK-LABEL: define i1 @assume_uge_pos1__uno_0( 2834; CHECK-SAME: float [[ARG:%.*]]) { 2835; CHECK-NEXT: [[UGE_POS1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00 2836; CHECK-NEXT: call void @llvm.assume(i1 [[UGE_POS1]]) 2837; CHECK-NEXT: [[CMP:%.*]] = fcmp uno float [[ARG]], 0.000000e+00 2838; CHECK-NEXT: ret i1 [[CMP]] 2839; 2840 %uge.pos1 = fcmp uge float %arg, 1.0 2841 call void @llvm.assume(i1 %uge.pos1) 2842 %cmp = fcmp uno float %arg, 0.0 2843 ret i1 %cmp 2844} 2845 2846; -------------------------------------------------------------------- 2847; Test assume x < -1.0 with compares to inf 2848; -------------------------------------------------------------------- 2849 2850define i1 @assume_olt_neg1__oeq_inf(float %arg) { 2851; CHECK-LABEL: define i1 @assume_olt_neg1__oeq_inf( 2852; CHECK-SAME: float [[ARG:%.*]]) { 2853; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 2854; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 2855; CHECK-NEXT: ret i1 false 2856; 2857 %olt.neg1 = fcmp olt float %arg, -1.0 2858 call void @llvm.assume(i1 %olt.neg1) 2859 %cmp = fcmp oeq float %arg, 0x7FF0000000000000 2860 ret i1 %cmp 2861} 2862 2863define i1 @assume_olt_neg1__one_inf(float %arg) { 2864; CHECK-LABEL: define i1 @assume_olt_neg1__one_inf( 2865; CHECK-SAME: float [[ARG:%.*]]) { 2866; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 2867; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 2868; CHECK-NEXT: ret i1 true 2869; 2870 %olt.neg1 = fcmp olt float %arg, -1.0 2871 call void @llvm.assume(i1 %olt.neg1) 2872 %cmp = fcmp one float %arg, 0x7FF0000000000000 2873 ret i1 %cmp 2874} 2875 2876define i1 @assume_olt_neg1__oeq_ninf(float %arg) { 2877; CHECK-LABEL: define i1 @assume_olt_neg1__oeq_ninf( 2878; CHECK-SAME: float [[ARG:%.*]]) { 2879; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 2880; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 2881; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0xFFF0000000000000 2882; CHECK-NEXT: ret i1 [[CMP]] 2883; 2884 %olt.neg1 = fcmp olt float %arg, -1.0 2885 call void @llvm.assume(i1 %olt.neg1) 2886 %cmp = fcmp oeq float %arg, 0xFFF0000000000000 2887 ret i1 %cmp 2888} 2889 2890define i1 @assume_olt_neg1__one_ninf(float %arg) { 2891; CHECK-LABEL: define i1 @assume_olt_neg1__one_ninf( 2892; CHECK-SAME: float [[ARG:%.*]]) { 2893; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00 2894; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_NEG1]]) 2895; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0xFFF0000000000000 2896; CHECK-NEXT: ret i1 [[CMP]] 2897; 2898 %olt.neg1 = fcmp olt float %arg, -1.0 2899 call void @llvm.assume(i1 %olt.neg1) 2900 %cmp = fcmp one float %arg, 0xFFF0000000000000 2901 ret i1 %cmp 2902} 2903 2904; -------------------------------------------------------------------- 2905; Other 2906; -------------------------------------------------------------------- 2907 2908define i1 @assume_olt_1__oeq_2(float %arg) { 2909; CHECK-LABEL: define i1 @assume_olt_1__oeq_2( 2910; CHECK-SAME: float [[ARG:%.*]]) { 2911; CHECK-NEXT: [[OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 2912; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_1]]) 2913; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 2.000000e+00 2914; CHECK-NEXT: ret i1 [[CMP]] 2915; 2916 %olt.1 = fcmp olt float %arg, 1.0 2917 call void @llvm.assume(i1 %olt.1) 2918 %cmp = fcmp oeq float %arg, 2.0 2919 ret i1 %cmp 2920} 2921 2922; Ideally would fold to false 2923define i1 @assume_ogt_2__oeq_2(float %arg) { 2924; CHECK-LABEL: define i1 @assume_ogt_2__oeq_2( 2925; CHECK-SAME: float [[ARG:%.*]]) { 2926; CHECK-NEXT: [[OLT_1:%.*]] = fcmp ogt float [[ARG]], 2.000000e+00 2927; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_1]]) 2928; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 2.000000e+00 2929; CHECK-NEXT: ret i1 [[CMP]] 2930; 2931 %olt.1 = fcmp ogt float %arg, 2.0 2932 call void @llvm.assume(i1 %olt.1) 2933 %cmp = fcmp oeq float %arg, 2.0 2934 ret i1 %cmp 2935} 2936 2937define i1 @assume_olt_2__olt_1(float %arg) { 2938; CHECK-LABEL: define i1 @assume_olt_2__olt_1( 2939; CHECK-SAME: float [[ARG:%.*]]) { 2940; CHECK-NEXT: [[OLT_1:%.*]] = fcmp olt float [[ARG]], 2.000000e+00 2941; CHECK-NEXT: call void @llvm.assume(i1 [[OLT_1]]) 2942; CHECK-NEXT: [[CMP:%.*]] = fcmp olt float [[ARG]], 1.000000e+00 2943; CHECK-NEXT: ret i1 [[CMP]] 2944; 2945 %olt.1 = fcmp olt float %arg, 2.0 2946 call void @llvm.assume(i1 %olt.1) 2947 %cmp = fcmp olt float %arg, 1.0 2948 ret i1 %cmp 2949} 2950 2951; -------------------------------------------------------------------- 2952; Negative infinity 2953; -------------------------------------------------------------------- 2954 2955define i1 @assume_ogt_neginf_one_neginf(float %arg) { 2956; CHECK-LABEL: define i1 @assume_ogt_neginf_one_neginf( 2957; CHECK-SAME: float [[ARG:%.*]]) { 2958; CHECK-NEXT: [[CMP_OGT_NEGINF:%.*]] = fcmp ogt float [[ARG]], 0xFFF0000000000000 2959; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_OGT_NEGINF]]) 2960; CHECK-NEXT: ret i1 true 2961; 2962 %cmp.ogt.neginf = fcmp ogt float %arg, 0xFFF0000000000000 2963 call void @llvm.assume(i1 %cmp.ogt.neginf) 2964 %cmp = fcmp one float %arg, 0xFFF0000000000000 2965 ret i1 %cmp 2966} 2967 2968define i1 @assume_ogt_neginf_oeq_posinf(float %arg) { 2969; CHECK-LABEL: define i1 @assume_ogt_neginf_oeq_posinf( 2970; CHECK-SAME: float [[ARG:%.*]]) { 2971; CHECK-NEXT: [[CMP_OGT_NEGINF:%.*]] = fcmp ogt float [[ARG]], 0xFFF0000000000000 2972; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_OGT_NEGINF]]) 2973; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0x7FF0000000000000 2974; CHECK-NEXT: ret i1 [[CMP]] 2975; 2976 %cmp.ogt.neginf = fcmp ogt float %arg, 0xFFF0000000000000 2977 call void @llvm.assume(i1 %cmp.ogt.neginf) 2978 %cmp = fcmp oeq float %arg, 0x7FF0000000000000 2979 ret i1 %cmp 2980} 2981 2982define i1 @assume_ule_neginf_oeq_neginf(float %arg) { 2983; CHECK-LABEL: define i1 @assume_ule_neginf_oeq_neginf( 2984; CHECK-SAME: float [[ARG:%.*]]) { 2985; CHECK-NEXT: [[CMP_ULE_NEGINF:%.*]] = fcmp ule float [[ARG]], 0xFFF0000000000000 2986; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_ULE_NEGINF]]) 2987; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0xFFF0000000000000 2988; CHECK-NEXT: ret i1 [[CMP]] 2989; 2990 %cmp.ule.neginf = fcmp ule float %arg, 0xFFF0000000000000 2991 call void @llvm.assume(i1 %cmp.ule.neginf) 2992 %cmp = fcmp oeq float %arg, 0xFFF0000000000000 2993 ret i1 %cmp 2994} 2995 2996define i1 @assume_ult_neginf_oeq_neginf(float %arg) { 2997; CHECK-LABEL: define i1 @assume_ult_neginf_oeq_neginf( 2998; CHECK-SAME: float [[ARG:%.*]]) { 2999; CHECK-NEXT: [[CMP_ULT_NEGINF:%.*]] = fcmp ult float [[ARG]], 0xFFF0000000000000 3000; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_ULT_NEGINF]]) 3001; CHECK-NEXT: ret i1 false 3002; 3003 %cmp.ult.neginf = fcmp ult float %arg, 0xFFF0000000000000 3004 call void @llvm.assume(i1 %cmp.ult.neginf) 3005 %cmp = fcmp oeq float %arg, 0xFFF0000000000000 3006 ret i1 %cmp 3007} 3008 3009define i1 @assume_fabs_ogt_neginf_one_neginf(float %arg) { 3010; CHECK-LABEL: define i1 @assume_fabs_ogt_neginf_one_neginf( 3011; CHECK-SAME: float [[ARG:%.*]]) { 3012; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) 3013; CHECK-NEXT: [[CMP_OGT_NEGINF:%.*]] = fcmp ogt float [[FABS_ARG]], 0xFFF0000000000000 3014; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_OGT_NEGINF]]) 3015; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0xFFF0000000000000 3016; CHECK-NEXT: ret i1 [[CMP]] 3017; 3018 %fabs.arg = call float @llvm.fabs.f32(float %arg) 3019 %cmp.ogt.neginf = fcmp ogt float %fabs.arg, 0xFFF0000000000000 3020 call void @llvm.assume(i1 %cmp.ogt.neginf) 3021 %cmp = fcmp one float %arg, 0xFFF0000000000000 3022 ret i1 %cmp 3023} 3024 3025define i1 @assume_fabs_ogt_neginf_one_posinf(float %arg) { 3026; CHECK-LABEL: define i1 @assume_fabs_ogt_neginf_one_posinf( 3027; CHECK-SAME: float [[ARG:%.*]]) { 3028; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) 3029; CHECK-NEXT: [[CMP_OGT_NEGINF:%.*]] = fcmp ogt float [[FABS_ARG]], 0xFFF0000000000000 3030; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_OGT_NEGINF]]) 3031; CHECK-NEXT: [[CMP:%.*]] = fcmp one float [[ARG]], 0x7FF0000000000000 3032; CHECK-NEXT: ret i1 [[CMP]] 3033; 3034 %fabs.arg = call float @llvm.fabs.f32(float %arg) 3035 %cmp.ogt.neginf = fcmp ogt float %fabs.arg, 0xFFF0000000000000 3036 call void @llvm.assume(i1 %cmp.ogt.neginf) 3037 %cmp = fcmp one float %arg, 0x7FF0000000000000 3038 ret i1 %cmp 3039} 3040 3041define i1 @assume_fabs_ule_neginf_oeq_neginf(float %arg) { 3042; CHECK-LABEL: define i1 @assume_fabs_ule_neginf_oeq_neginf( 3043; CHECK-SAME: float [[ARG:%.*]]) { 3044; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) 3045; CHECK-NEXT: [[CMP_OGT_NEGINF:%.*]] = fcmp ule float [[FABS_ARG]], 0xFFF0000000000000 3046; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_OGT_NEGINF]]) 3047; CHECK-NEXT: ret i1 false 3048; 3049 %fabs.arg = call float @llvm.fabs.f32(float %arg) 3050 %cmp.ogt.neginf = fcmp ule float %fabs.arg, 0xFFF0000000000000 3051 call void @llvm.assume(i1 %cmp.ogt.neginf) 3052 %cmp = fcmp oeq float %arg, 0xFFF0000000000000 3053 ret i1 %cmp 3054} 3055 3056define i1 @assume_oge_neginf_oeq_neginf(float %arg) { 3057; CHECK-LABEL: define i1 @assume_oge_neginf_oeq_neginf( 3058; CHECK-SAME: float [[ARG:%.*]]) { 3059; CHECK-NEXT: [[CMP_OGE_NEGINF:%.*]] = fcmp oge float [[ARG]], 0xFFF0000000000000 3060; CHECK-NEXT: call void @llvm.assume(i1 [[CMP_OGE_NEGINF]]) 3061; CHECK-NEXT: [[CMP:%.*]] = fcmp oeq float [[ARG]], 0xFFF0000000000000 3062; CHECK-NEXT: ret i1 [[CMP]] 3063; 3064 %cmp.oge.neginf = fcmp oge float %arg, 0xFFF0000000000000 3065 call void @llvm.assume(i1 %cmp.oge.neginf) 3066 %cmp = fcmp oeq float %arg, 0xFFF0000000000000 3067 ret i1 %cmp 3068} 3069 3070attributes #0 = { nocallback nofree nosync nounwind willreturn memory(inaccessiblemem: readwrite) } 3071