Skip to content
  1. Dec 05, 2013
  2. Dec 04, 2013
  3. Dec 03, 2013
  4. Dec 02, 2013
  5. Dec 01, 2013
  6. Nov 28, 2013
  7. Nov 26, 2013
    • Nadav Rotem's avatar
      PR1860 - We can't save a list of ExtractElement instructions to CSE because... · b0082d24
      Nadav Rotem authored
      PR1860 - We can't save a list of ExtractElement instructions to CSE because some of these instructions
      may be removed and optimized in future iterations. Instead we save a list of basic blocks that we need to CSE.
      
      llvm-svn: 195791
      b0082d24
    • Arnold Schwaighofer's avatar
      LoopVectorizer: Truncate i64 trip counts of i32 phis if necessary · a2c8e008
      Arnold Schwaighofer authored
      In signed arithmetic we could end up with an i64 trip count for an i32 phi.
      Because it is signed arithmetic we know that this is only defined if the i32
      does not wrap. It is therefore safe to truncate the i64 trip count to a i32
      value.
      
      Fixes PR18049.
      
      llvm-svn: 195787
      a2c8e008
    • Diego Novillo's avatar
      Refactor some code in SampleProfile.cpp · c0dd1037
      Diego Novillo authored
      I'm adding new functionality in the sample profiler. This will
      require more data to be kept around for each function, so I moved
      the structure SampleProfile that we keep for each function into
      a separate class.
      
      There are no functional changes in this patch. It simply provides
      a new home where to place all the new data that I need to propagate
      weights through edges.
      
      There are some other name and minor edits throughout.
      
      llvm-svn: 195780
      c0dd1037
    • Nadav Rotem's avatar
      PR18060 - When we RAUW values with ExtractElement instructions in some cases · f9f8482e
      Nadav Rotem authored
      we generate PHI nodes with multiple entries from the same basic block but
      with different values. Enabling CSE on ExtractElement instructions make sure
      that all of the RAUWed instructions are the same.
      
      llvm-svn: 195773
      f9f8482e
    • Stepan Dyatkovskiy's avatar
      PR17925 bugfix. · abb8505d
      Stepan Dyatkovskiy authored
      Short description.
      
      This issue is about case of treating pointers as integers.
      We treat pointers as different if they references different address space.
      At the same time, we treat pointers equal to integers (with machine address
      width). It was a point of false-positive. Consider next case on 32bit machine:
      
      void foo0(i32 addrespace(1)* %p)
      void foo1(i32 addrespace(2)* %p)
      void foo2(i32 %p)
      
      foo0 != foo1, while
      foo1 == foo2 and foo0 == foo2.
      
      As you can see it breaks transitivity. That means that result depends on order
      of how functions are presented in module. Next order causes merging of foo0
      and foo1: foo2, foo0, foo1
      First foo0 will be merged with foo2, foo0 will be erased. Second foo1 will be
      merged with foo2.
      Depending on order, things could be merged we don't expect to.
      
      The fix:
      Forbid to treat any pointer as integer, except for those, who belong to address space 0.
      
      llvm-svn: 195769
      abb8505d
    • Chandler Carruth's avatar
      [PM] Split the CallGraph out from the ModulePass which creates the · 6378cf53
      Chandler Carruth authored
      CallGraph.
      
      This makes the CallGraph a totally generic analysis object that is the
      container for the graph data structure and the primary interface for
      querying and manipulating it. The pass logic is separated into its own
      class. For compatibility reasons, the pass provides wrapper methods for
      most of the methods on CallGraph -- they all just forward.
      
      This will allow the new pass manager infrastructure to provide its own
      analysis pass that constructs the same CallGraph object and makes it
      available. The idea is that in the new pass manager, the analysis pass's
      'run' method returns a concrete analysis 'result'. Here, that result is
      a 'CallGraph'. The 'run' method will typically do only minimal work,
      deferring much of the work into the implementation of the result object
      in order to be lazy about computing things, but when (like DomTree)
      there is *some* up-front computation, the analysis does it prior to
      handing the result back to the querying pass.
      
      I know some of this is fairly ugly. I'm happy to change it around if
      folks can suggest a cleaner interim state, but there is going to be some
      amount of unavoidable ugliness during the transition period. The good
      thing is that this is very limited and will naturally go away when the
      old pass infrastructure goes away. It won't hang around to bother us
      later.
      
      Next up is the initial new-PM-style call graph analysis. =]
      
      llvm-svn: 195722
      6378cf53
  8. Nov 23, 2013
    • Chandler Carruth's avatar
      Migrate metadata information from scalar to vector instructions during · 57458517
      Chandler Carruth authored
      SLP vectorization. Based on the code in BBVectorizer.
      
      Fixes PR17741.
      
      Patch by Raul Silvera, reviewed by Hal and Nadav. Reformatted by my
      driving of clang-format. =]
      
      llvm-svn: 195528
      57458517
    • Yuchen Wu's avatar
      llvm-cov: Split entry blocks in GCNOProfiling.cpp. · c87ca321
      Yuchen Wu authored
      gcov expects every function to contain an entry block that
      unconditionally branches into the next block. clang does not implement
      basic blocks in this manner, so gcov did not output correct branch info
      if the entry block branched to multiple blocks.
      
      This change splits every function's entry block into an empty block and
      a block with the rest of the instructions. The instrumentation code will
      take care of the rest.
      
      llvm-svn: 195513
      c87ca321
  9. Nov 22, 2013
  10. Nov 21, 2013
Loading